@haneullabs/haneul 0.1.0

package/src/grpc/proto/google/protobuf/field_mask.ts

@@ -0,0 +1,309 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// @generated by protobuf-ts 2.9.6 with parameter force_server_none,optimize_code_size,ts_nocheck
+// @generated from protobuf file "google/protobuf/field_mask.proto" (package "google.protobuf", syntax proto3)
+// tslint:disable
+// @ts-nocheck
+//
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+import { typeofJsonValue } from '@protobuf-ts/runtime';
+import type { JsonValue } from '@protobuf-ts/runtime';
+import { lowerCamelCase } from '@protobuf-ts/runtime';
+import type { JsonReadOptions } from '@protobuf-ts/runtime';
+import type { JsonWriteOptions } from '@protobuf-ts/runtime';
+import { MessageType } from '@protobuf-ts/runtime';
+/**
+ * `FieldMask` represents a set of symbolic field paths, for example:
+ *
+ *     paths: "f.a"
+ *     paths: "f.b.d"
+ *
+ * Here `f` represents a field in some root message, `a` and `b`
+ * fields in the message found in `f`, and `d` a field found in the
+ * message in `f.b`.
+ *
+ * Field masks are used to specify a subset of fields that should be
+ * returned by a get operation or modified by an update operation.
+ * Field masks also have a custom JSON encoding (see below).
+ *
+ * # Field Masks in Projections
+ *
+ * When used in the context of a projection, a response message or
+ * sub-message is filtered by the API to only contain those fields as
+ * specified in the mask. For example, if the mask in the previous
+ * example is applied to a response message as follows:
+ *
+ *     f {
+ *       a : 22
+ *       b {
+ *         d : 1
+ *         x : 2
+ *       }
+ *       y : 13
+ *     }
+ *     z: 8
+ *
+ * The result will not contain specific values for fields x,y and z
+ * (their value will be set to the default, and omitted in proto text
+ * output):
+ *
+ *
+ *     f {
+ *       a : 22
+ *       b {
+ *         d : 1
+ *       }
+ *     }
+ *
+ * A repeated field is not allowed except at the last position of a
+ * paths string.
+ *
+ * If a FieldMask object is not present in a get operation, the
+ * operation applies to all fields (as if a FieldMask of all fields
+ * had been specified).
+ *
+ * Note that a field mask does not necessarily apply to the
+ * top-level response message. In case of a REST get operation, the
+ * field mask applies directly to the response, but in case of a REST
+ * list operation, the mask instead applies to each individual message
+ * in the returned resource list. In case of a REST custom method,
+ * other definitions may be used. Where the mask applies will be
+ * clearly documented together with its declaration in the API.  In
+ * any case, the effect on the returned resource/resources is required
+ * behavior for APIs.
+ *
+ * # Field Masks in Update Operations
+ *
+ * A field mask in update operations specifies which fields of the
+ * targeted resource are going to be updated. The API is required
+ * to only change the values of the fields as specified in the mask
+ * and leave the others untouched. If a resource is passed in to
+ * describe the updated values, the API ignores the values of all
+ * fields not covered by the mask.
+ *
+ * If a repeated field is specified for an update operation, new values will
+ * be appended to the existing repeated field in the target resource. Note that
+ * a repeated field is only allowed in the last position of a `paths` string.
+ *
+ * If a sub-message is specified in the last position of the field mask for an
+ * update operation, then new value will be merged into the existing sub-message
+ * in the target resource.
+ *
+ * For example, given the target message:
+ *
+ *     f {
+ *       b {
+ *         d: 1
+ *         x: 2
+ *       }
+ *       c: [1]
+ *     }
+ *
+ * And an update message:
+ *
+ *     f {
+ *       b {
+ *         d: 10
+ *       }
+ *       c: [2]
+ *     }
+ *
+ * then if the field mask is:
+ *
+ *  paths: ["f.b", "f.c"]
+ *
+ * then the result will be:
+ *
+ *     f {
+ *       b {
+ *         d: 10
+ *         x: 2
+ *       }
+ *       c: [1, 2]
+ *     }
+ *
+ * An implementation may provide options to override this default behavior for
+ * repeated and message fields.
+ *
+ * In order to reset a field's value to the default, the field must
+ * be in the mask and set to the default value in the provided resource.
+ * Hence, in order to reset all fields of a resource, provide a default
+ * instance of the resource and set all fields in the mask, or do
+ * not provide a mask as described below.
+ *
+ * If a field mask is not present on update, the operation applies to
+ * all fields (as if a field mask of all fields has been specified).
+ * Note that in the presence of schema evolution, this may mean that
+ * fields the client does not know and has therefore not filled into
+ * the request will be reset to their default. If this is unwanted
+ * behavior, a specific service may require a client to always specify
+ * a field mask, producing an error if not.
+ *
+ * As with get operations, the location of the resource which
+ * describes the updated values in the request message depends on the
+ * operation kind. In any case, the effect of the field mask is
+ * required to be honored by the API.
+ *
+ * ## Considerations for HTTP REST
+ *
+ * The HTTP kind of an update operation which uses a field mask must
+ * be set to PATCH instead of PUT in order to satisfy HTTP semantics
+ * (PUT must only be used for full updates).
+ *
+ * # JSON Encoding of Field Masks
+ *
+ * In JSON, a field mask is encoded as a single string where paths are
+ * separated by a comma. Fields name in each path are converted
+ * to/from lower-camel naming conventions.
+ *
+ * As an example, consider the following message declarations:
+ *
+ *     message Profile {
+ *       User user = 1;
+ *       Photo photo = 2;
+ *     }
+ *     message User {
+ *       string display_name = 1;
+ *       string address = 2;
+ *     }
+ *
+ * In proto a field mask for `Profile` may look as such:
+ *
+ *     mask {
+ *       paths: "user.display_name"
+ *       paths: "photo"
+ *     }
+ *
+ * In JSON, the same mask is represented as below:
+ *
+ *     {
+ *       mask: "user.displayName,photo"
+ *     }
+ *
+ * # Field Masks and Oneof Fields
+ *
+ * Field masks treat fields in oneofs just as regular fields. Consider the
+ * following message:
+ *
+ *     message SampleMessage {
+ *       oneof test_oneof {
+ *         string name = 4;
+ *         SubMessage sub_message = 9;
+ *       }
+ *     }
+ *
+ * The field mask can be:
+ *
+ *     mask {
+ *       paths: "name"
+ *     }
+ *
+ * Or:
+ *
+ *     mask {
+ *       paths: "sub_message"
+ *     }
+ *
+ * Note that oneof type names ("test_oneof" in this case) cannot be used in
+ * paths.
+ *
+ * ## Field Mask Verification
+ *
+ * The implementation of any API method which has a FieldMask type field in the
+ * request should verify the included field paths, and return an
+ * `INVALID_ARGUMENT` error if any path is unmappable.
+ *
+ * @generated from protobuf message google.protobuf.FieldMask
+ */
+export interface FieldMask {
+	/**
+	 * The set of field mask paths.
+	 *
+	 * @generated from protobuf field: repeated string paths = 1;
+	 */
+	paths: string[];
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class FieldMask$Type extends MessageType<FieldMask> {
+	constructor() {
+		super('google.protobuf.FieldMask', [
+			{
+				no: 1,
+				name: 'paths',
+				kind: 'scalar',
+				repeat: 2 /*RepeatType.UNPACKED*/,
+				T: 9 /*ScalarType.STRING*/,
+			},
+		]);
+	}
+	/**
+	 * Encode `FieldMask` to JSON object.
+	 */
+	internalJsonWrite(message: FieldMask, options: JsonWriteOptions): JsonValue {
+		const invalidFieldMaskJsonRegex = /[A-Z]|(_([.0-9_]|$))/g;
+		return message.paths
+			.map((p) => {
+				if (invalidFieldMaskJsonRegex.test(p))
+					throw new Error(
+						'Unable to encode FieldMask to JSON. lowerCamelCase of path name "' +
+							p +
+							'" is irreversible.',
+					);
+				return lowerCamelCase(p);
+			})
+			.join(',');
+	}
+	/**
+	 * Decode `FieldMask` from JSON object.
+	 */
+	internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: FieldMask): FieldMask {
+		if (typeof json !== 'string')
+			throw new Error(
+				'Unable to parse FieldMask from JSON ' + typeofJsonValue(json) + '. Expected string.',
+			);
+		if (!target) target = this.create();
+		if (json === '') return target;
+		let camelToSnake = (str: string) => {
+			if (str.includes('_'))
+				throw new Error('Unable to parse FieldMask from JSON. Path names must be lowerCamelCase.');
+			let sc = str.replace(/[A-Z]/g, (letter) => '_' + letter.toLowerCase());
+			return sc;
+		};
+		target.paths = json.split(',').map(camelToSnake);
+		return target;
+	}
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.FieldMask
+ */
+export const FieldMask = new FieldMask$Type();

package/src/grpc/proto/google/protobuf/struct.ts

@@ -0,0 +1,327 @@
+// Copyright (c) Mysten Labs, Inc.
+// SPDX-License-Identifier: Apache-2.0
+
+// @generated by protobuf-ts 2.9.6 with parameter force_server_none,optimize_code_size,ts_nocheck
+// @generated from protobuf file "google/protobuf/struct.proto" (package "google.protobuf", syntax proto3)
+// tslint:disable
+// @ts-nocheck
+//
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+//
+import { isJsonObject } from '@protobuf-ts/runtime';
+import { typeofJsonValue } from '@protobuf-ts/runtime';
+import type { JsonValue } from '@protobuf-ts/runtime';
+import type { JsonReadOptions } from '@protobuf-ts/runtime';
+import type { JsonWriteOptions } from '@protobuf-ts/runtime';
+import type { JsonObject } from '@protobuf-ts/runtime';
+import { MessageType } from '@protobuf-ts/runtime';
+/**
+ * `Struct` represents a structured data value, consisting of fields
+ * which map to dynamically typed values. In some languages, `Struct`
+ * might be supported by a native representation. For example, in
+ * scripting languages like JS a struct is represented as an
+ * object. The details of that representation are described together
+ * with the proto support for the language.
+ *
+ * The JSON representation for `Struct` is JSON object.
+ *
+ * @generated from protobuf message google.protobuf.Struct
+ */
+export interface Struct {
+	/**
+	 * Unordered map of dynamically typed values.
+	 *
+	 * @generated from protobuf field: map<string, google.protobuf.Value> fields = 1;
+	 */
+	fields: {
+		[key: string]: Value;
+	};
+}
+/**
+ * `Value` represents a dynamically typed value which can be either
+ * null, a number, a string, a boolean, a recursive struct value, or a
+ * list of values. A producer of value is expected to set one of these
+ * variants. Absence of any variant indicates an error.
+ *
+ * The JSON representation for `Value` is JSON value.
+ *
+ * @generated from protobuf message google.protobuf.Value
+ */
+export interface Value {
+	/**
+	 * @generated from protobuf oneof: kind
+	 */
+	kind:
+		| {
+				oneofKind: 'nullValue';
+				/**
+				 * Represents a null value.
+				 *
+				 * @generated from protobuf field: google.protobuf.NullValue null_value = 1;
+				 */
+				nullValue: NullValue;
+		  }
+		| {
+				oneofKind: 'numberValue';
+				/**
+				 * Represents a double value.
+				 *
+				 * @generated from protobuf field: double number_value = 2;
+				 */
+				numberValue: number;
+		  }
+		| {
+				oneofKind: 'stringValue';
+				/**
+				 * Represents a string value.
+				 *
+				 * @generated from protobuf field: string string_value = 3;
+				 */
+				stringValue: string;
+		  }
+		| {
+				oneofKind: 'boolValue';
+				/**
+				 * Represents a boolean value.
+				 *
+				 * @generated from protobuf field: bool bool_value = 4;
+				 */
+				boolValue: boolean;
+		  }
+		| {
+				oneofKind: 'structValue';
+				/**
+				 * Represents a structured value.
+				 *
+				 * @generated from protobuf field: google.protobuf.Struct struct_value = 5;
+				 */
+				structValue: Struct;
+		  }
+		| {
+				oneofKind: 'listValue';
+				/**
+				 * Represents a repeated `Value`.
+				 *
+				 * @generated from protobuf field: google.protobuf.ListValue list_value = 6;
+				 */
+				listValue: ListValue;
+		  }
+		| {
+				oneofKind: undefined;
+		  };
+}
+/**
+ * `ListValue` is a wrapper around a repeated field of values.
+ *
+ * The JSON representation for `ListValue` is JSON array.
+ *
+ * @generated from protobuf message google.protobuf.ListValue
+ */
+export interface ListValue {
+	/**
+	 * Repeated field of dynamically typed values.
+	 *
+	 * @generated from protobuf field: repeated google.protobuf.Value values = 1;
+	 */
+	values: Value[];
+}
+/**
+ * `NullValue` is a singleton enumeration to represent the null value for the
+ * `Value` type union.
+ *
+ * The JSON representation for `NullValue` is JSON `null`.
+ *
+ * @generated from protobuf enum google.protobuf.NullValue
+ */
+export enum NullValue {
+	/**
+	 * Null value.
+	 *
+	 * @generated from protobuf enum value: NULL_VALUE = 0;
+	 */
+	NULL_VALUE = 0,
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class Struct$Type extends MessageType<Struct> {
+	constructor() {
+		super('google.protobuf.Struct', [
+			{
+				no: 1,
+				name: 'fields',
+				kind: 'map',
+				K: 9 /*ScalarType.STRING*/,
+				V: { kind: 'message', T: () => Value },
+			},
+		]);
+	}
+	/**
+	 * Encode `Struct` to JSON object.
+	 */
+	internalJsonWrite(message: Struct, options: JsonWriteOptions): JsonValue {
+		let json: JsonObject = {};
+		for (let [k, v] of Object.entries(message.fields)) {
+			json[k] = Value.toJson(v);
+		}
+		return json;
+	}
+	/**
+	 * Decode `Struct` from JSON object.
+	 */
+	internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: Struct): Struct {
+		if (!isJsonObject(json))
+			throw new globalThis.Error(
+				'Unable to parse message ' + this.typeName + ' from JSON ' + typeofJsonValue(json) + '.',
+			);
+		if (!target) target = this.create();
+		for (let [k, v] of globalThis.Object.entries(json)) {
+			target.fields[k] = Value.fromJson(v);
+		}
+		return target;
+	}
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.Struct
+ */
+export const Struct = new Struct$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class Value$Type extends MessageType<Value> {
+	constructor() {
+		super('google.protobuf.Value', [
+			{
+				no: 1,
+				name: 'null_value',
+				kind: 'enum',
+				oneof: 'kind',
+				T: () => ['google.protobuf.NullValue', NullValue],
+			},
+			{ no: 2, name: 'number_value', kind: 'scalar', oneof: 'kind', T: 1 /*ScalarType.DOUBLE*/ },
+			{ no: 3, name: 'string_value', kind: 'scalar', oneof: 'kind', T: 9 /*ScalarType.STRING*/ },
+			{ no: 4, name: 'bool_value', kind: 'scalar', oneof: 'kind', T: 8 /*ScalarType.BOOL*/ },
+			{ no: 5, name: 'struct_value', kind: 'message', oneof: 'kind', T: () => Struct },
+			{ no: 6, name: 'list_value', kind: 'message', oneof: 'kind', T: () => ListValue },
+		]);
+	}
+	/**
+	 * Encode `Value` to JSON value.
+	 */
+	internalJsonWrite(message: Value, options: JsonWriteOptions): JsonValue {
+		if (message.kind.oneofKind === undefined) throw new globalThis.Error();
+		switch (message.kind.oneofKind) {
+			case undefined:
+				throw new globalThis.Error();
+			case 'boolValue':
+				return message.kind.boolValue;
+			case 'nullValue':
+				return null;
+			case 'numberValue':
+				let numberValue = message.kind.numberValue;
+				if (typeof numberValue == 'number' && !Number.isFinite(numberValue))
+					throw new globalThis.Error();
+				return numberValue;
+			case 'stringValue':
+				return message.kind.stringValue;
+			case 'listValue':
+				let listValueField = this.fields.find((f) => f.no === 6);
+				if (listValueField?.kind !== 'message') throw new globalThis.Error();
+				return listValueField.T().toJson(message.kind.listValue);
+			case 'structValue':
+				let structValueField = this.fields.find((f) => f.no === 5);
+				if (structValueField?.kind !== 'message') throw new globalThis.Error();
+				return structValueField.T().toJson(message.kind.structValue);
+		}
+	}
+	/**
+	 * Decode `Value` from JSON value.
+	 */
+	internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: Value): Value {
+		if (!target) target = this.create();
+		switch (typeof json) {
+			case 'number':
+				target.kind = { oneofKind: 'numberValue', numberValue: json };
+				break;
+			case 'string':
+				target.kind = { oneofKind: 'stringValue', stringValue: json };
+				break;
+			case 'boolean':
+				target.kind = { oneofKind: 'boolValue', boolValue: json };
+				break;
+			case 'object':
+				if (json === null) {
+					target.kind = { oneofKind: 'nullValue', nullValue: NullValue.NULL_VALUE };
+				} else if (globalThis.Array.isArray(json)) {
+					target.kind = { oneofKind: 'listValue', listValue: ListValue.fromJson(json) };
+				} else {
+					target.kind = { oneofKind: 'structValue', structValue: Struct.fromJson(json) };
+				}
+				break;
+			default:
+				throw new globalThis.Error(
+					'Unable to parse ' + this.typeName + ' from JSON ' + typeofJsonValue(json),
+				);
+		}
+		return target;
+	}
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.Value
+ */
+export const Value = new Value$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class ListValue$Type extends MessageType<ListValue> {
+	constructor() {
+		super('google.protobuf.ListValue', [
+			{ no: 1, name: 'values', kind: 'message', repeat: 1 /*RepeatType.PACKED*/, T: () => Value },
+		]);
+	}
+	/**
+	 * Encode `ListValue` to JSON array.
+	 */
+	internalJsonWrite(message: ListValue, options: JsonWriteOptions): JsonValue {
+		return message.values.map((v) => Value.toJson(v));
+	}
+	/**
+	 * Decode `ListValue` from JSON array.
+	 */
+	internalJsonRead(json: JsonValue, options: JsonReadOptions, target?: ListValue): ListValue {
+		if (!globalThis.Array.isArray(json))
+			throw new globalThis.Error(
+				'Unable to parse ' + this.typeName + ' from JSON ' + typeofJsonValue(json),
+			);
+		if (!target) target = this.create();
+		let values = json.map((v) => Value.fromJson(v));
+		target.values.push(...values);
+		return target;
+	}
+}
+/**
+ * @generated MessageType for protobuf message google.protobuf.ListValue
+ */
+export const ListValue = new ListValue$Type();