@use-tusk/drift-schemas 0.1.10

package/dist/postgresql/postgresql.js

@@ -0,0 +1,1461 @@
+import { Struct } from "../struct-LJz5_MGH.js";
+import { Timestamp } from "../timestamp-CN7C70ih.js";
+import { MessageType, UnknownFieldHandler, WireType, reflectionMergePartial } from "@protobuf-ts/runtime";
+
+//#region generated/ts/postgresql/postgresql.ts
+/**
+* Transaction state enumeration
+*
+* @generated from protobuf enum tusk.drift.instrumentation.postgresql.v1.TransactionState
+*/
+let TransactionState = /* @__PURE__ */ function(TransactionState$1) {
+	/**
+	* @generated from protobuf enum value: TRANSACTION_STATE_UNSPECIFIED = 0;
+	*/
+	TransactionState$1[TransactionState$1["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+	/**
+	* Not in a transaction
+	*
+	* @generated from protobuf enum value: TRANSACTION_STATE_IDLE = 1;
+	*/
+	TransactionState$1[TransactionState$1["IDLE"] = 1] = "IDLE";
+	/**
+	* Transaction active
+	*
+	* @generated from protobuf enum value: TRANSACTION_STATE_ACTIVE = 2;
+	*/
+	TransactionState$1[TransactionState$1["ACTIVE"] = 2] = "ACTIVE";
+	/**
+	* Idle in transaction
+	*
+	* @generated from protobuf enum value: TRANSACTION_STATE_IDLE_IN_TRANSACTION = 3;
+	*/
+	TransactionState$1[TransactionState$1["IDLE_IN_TRANSACTION"] = 3] = "IDLE_IN_TRANSACTION";
+	/**
+	* Idle in failed transaction
+	*
+	* @generated from protobuf enum value: TRANSACTION_STATE_IDLE_IN_FAILED_TRANSACTION = 4;
+	*/
+	TransactionState$1[TransactionState$1["IDLE_IN_FAILED_TRANSACTION"] = 4] = "IDLE_IN_FAILED_TRANSACTION";
+	return TransactionState$1;
+}({});
+/**
+* PostgreSQL isolation levels
+*
+* @generated from protobuf enum tusk.drift.instrumentation.postgresql.v1.IsolationLevel
+*/
+let IsolationLevel = /* @__PURE__ */ function(IsolationLevel$1) {
+	/**
+	* @generated from protobuf enum value: ISOLATION_LEVEL_UNSPECIFIED = 0;
+	*/
+	IsolationLevel$1[IsolationLevel$1["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+	/**
+	* @generated from protobuf enum value: ISOLATION_LEVEL_READ_UNCOMMITTED = 1;
+	*/
+	IsolationLevel$1[IsolationLevel$1["READ_UNCOMMITTED"] = 1] = "READ_UNCOMMITTED";
+	/**
+	* @generated from protobuf enum value: ISOLATION_LEVEL_READ_COMMITTED = 2;
+	*/
+	IsolationLevel$1[IsolationLevel$1["READ_COMMITTED"] = 2] = "READ_COMMITTED";
+	/**
+	* @generated from protobuf enum value: ISOLATION_LEVEL_REPEATABLE_READ = 3;
+	*/
+	IsolationLevel$1[IsolationLevel$1["REPEATABLE_READ"] = 3] = "REPEATABLE_READ";
+	/**
+	* @generated from protobuf enum value: ISOLATION_LEVEL_SERIALIZABLE = 4;
+	*/
+	IsolationLevel$1[IsolationLevel$1["SERIALIZABLE"] = 4] = "SERIALIZABLE";
+	return IsolationLevel$1;
+}({});
+var PostgreSQLQuery$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.instrumentation.postgresql.v1.PostgreSQLQuery", [
+			{
+				no: 1,
+				name: "text",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 2,
+				name: "values",
+				kind: "scalar",
+				repeat: 2,
+				T: 9
+			},
+			{
+				no: 3,
+				name: "client_type",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 4,
+				name: "connection",
+				kind: "message",
+				T: () => PostgreSQLConnection
+			},
+			{
+				no: 5,
+				name: "options",
+				kind: "message",
+				T: () => QueryOptions
+			},
+			{
+				no: 6,
+				name: "query_id",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 7,
+				name: "tags",
+				kind: "map",
+				K: 9,
+				V: {
+					kind: "scalar",
+					T: 9
+				}
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.text = "";
+		message.values = [];
+		message.clientType = "";
+		message.queryId = "";
+		message.tags = {};
+		if (value !== void 0) reflectionMergePartial(this, message, value);
+		return message;
+	}
+	internalBinaryRead(reader, length, options, target) {
+		let message = target ?? this.create(), end = reader.pos + length;
+		while (reader.pos < end) {
+			let [fieldNo, wireType] = reader.tag();
+			switch (fieldNo) {
+				case 1:
+					message.text = reader.string();
+					break;
+				case 2:
+					message.values.push(reader.string());
+					break;
+				case 3:
+					message.clientType = reader.string();
+					break;
+				case 4:
+					message.connection = PostgreSQLConnection.internalBinaryRead(reader, reader.uint32(), options, message.connection);
+					break;
+				case 5:
+					message.options = QueryOptions.internalBinaryRead(reader, reader.uint32(), options, message.options);
+					break;
+				case 6:
+					message.queryId = reader.string();
+					break;
+				case 7:
+					this.binaryReadMap7(message.tags, reader, options);
+					break;
+				default:
+					let u = options.readUnknownField;
+					if (u === "throw") throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+					let d = reader.skip(wireType);
+					if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+			}
+		}
+		return message;
+	}
+	binaryReadMap7(map, reader, options) {
+		let len = reader.uint32(), end = reader.pos + len, key, val;
+		while (reader.pos < end) {
+			let [fieldNo, wireType] = reader.tag();
+			switch (fieldNo) {
+				case 1:
+					key = reader.string();
+					break;
+				case 2:
+					val = reader.string();
+					break;
+				default: throw new globalThis.Error("unknown map entry field for tusk.drift.instrumentation.postgresql.v1.PostgreSQLQuery.tags");
+			}
+		}
+		map[key ?? ""] = val ?? "";
+	}
+	internalBinaryWrite(message, writer, options) {
+		if (message.text !== "") writer.tag(1, WireType.LengthDelimited).string(message.text);
+		for (let i = 0; i < message.values.length; i++) writer.tag(2, WireType.LengthDelimited).string(message.values[i]);
+		if (message.clientType !== "") writer.tag(3, WireType.LengthDelimited).string(message.clientType);
+		if (message.connection) PostgreSQLConnection.internalBinaryWrite(message.connection, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+		if (message.options) QueryOptions.internalBinaryWrite(message.options, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+		if (message.queryId !== "") writer.tag(6, WireType.LengthDelimited).string(message.queryId);
+		for (let k of globalThis.Object.keys(message.tags)) writer.tag(7, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k).tag(2, WireType.LengthDelimited).string(message.tags[k]).join();
+		let u = options.writeUnknownFields;
+		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+		return writer;
+	}
+};
+/**
+* @generated MessageType for protobuf message tusk.drift.instrumentation.postgresql.v1.PostgreSQLQuery
+*/
+const PostgreSQLQuery = new PostgreSQLQuery$Type();
+var PostgreSQLConnection$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.instrumentation.postgresql.v1.PostgreSQLConnection", [
+			{
+				no: 1,
+				name: "database_name",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 2,
+				name: "username",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 3,
+				name: "host",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 4,
+				name: "port",
+				kind: "scalar",
+				T: 5
+			},
+			{
+				no: 5,
+				name: "application_name",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 6,
+				name: "connection_id",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 7,
+				name: "ssl_enabled",
+				kind: "scalar",
+				T: 8
+			},
+			{
+				no: 8,
+				name: "server_version",
+				kind: "scalar",
+				T: 9
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.databaseName = "";
+		message.username = "";
+		message.host = "";
+		message.port = 0;
+		message.applicationName = "";
+		message.connectionId = "";
+		message.sslEnabled = false;
+		message.serverVersion = "";
+		if (value !== void 0) reflectionMergePartial(this, message, value);
+		return message;
+	}
+	internalBinaryRead(reader, length, options, target) {
+		let message = target ?? this.create(), end = reader.pos + length;
+		while (reader.pos < end) {
+			let [fieldNo, wireType] = reader.tag();
+			switch (fieldNo) {
+				case 1:
+					message.databaseName = reader.string();
+					break;
+				case 2:
+					message.username = reader.string();
+					break;
+				case 3:
+					message.host = reader.string();
+					break;
+				case 4:
+					message.port = reader.int32();
+					break;
+				case 5:
+					message.applicationName = reader.string();
+					break;
+				case 6:
+					message.connectionId = reader.string();
+					break;
+				case 7:
+					message.sslEnabled = reader.bool();
+					break;
+				case 8:
+					message.serverVersion = reader.string();
+					break;
+				default:
+					let u = options.readUnknownField;
+					if (u === "throw") throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+					let d = reader.skip(wireType);
+					if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+			}
+		}
+		return message;
+	}
+	internalBinaryWrite(message, writer, options) {
+		if (message.databaseName !== "") writer.tag(1, WireType.LengthDelimited).string(message.databaseName);
+		if (message.username !== "") writer.tag(2, WireType.LengthDelimited).string(message.username);
+		if (message.host !== "") writer.tag(3, WireType.LengthDelimited).string(message.host);
+		if (message.port !== 0) writer.tag(4, WireType.Varint).int32(message.port);
+		if (message.applicationName !== "") writer.tag(5, WireType.LengthDelimited).string(message.applicationName);
+		if (message.connectionId !== "") writer.tag(6, WireType.LengthDelimited).string(message.connectionId);
+		if (message.sslEnabled !== false) writer.tag(7, WireType.Varint).bool(message.sslEnabled);
+		if (message.serverVersion !== "") writer.tag(8, WireType.LengthDelimited).string(message.serverVersion);
+		let u = options.writeUnknownFields;
+		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+		return writer;
+	}
+};
+/**
+* @generated MessageType for protobuf message tusk.drift.instrumentation.postgresql.v1.PostgreSQLConnection
+*/
+const PostgreSQLConnection = new PostgreSQLConnection$Type();
+var QueryOptions$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.instrumentation.postgresql.v1.QueryOptions", [
+			{
+				no: 1,
+				name: "statement_timeout",
+				kind: "scalar",
+				T: 5
+			},
+			{
+				no: 2,
+				name: "query_timeout",
+				kind: "scalar",
+				T: 5
+			},
+			{
+				no: 3,
+				name: "binary_mode",
+				kind: "scalar",
+				T: 8
+			},
+			{
+				no: 4,
+				name: "cursor_name",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 5,
+				name: "fetch_size",
+				kind: "scalar",
+				T: 5
+			},
+			{
+				no: 6,
+				name: "read_only",
+				kind: "scalar",
+				T: 8
+			},
+			{
+				no: 7,
+				name: "custom_options",
+				kind: "map",
+				K: 9,
+				V: {
+					kind: "scalar",
+					T: 9
+				}
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.statementTimeout = 0;
+		message.queryTimeout = 0;
+		message.binaryMode = false;
+		message.cursorName = "";
+		message.fetchSize = 0;
+		message.readOnly = false;
+		message.customOptions = {};
+		if (value !== void 0) reflectionMergePartial(this, message, value);
+		return message;
+	}
+	internalBinaryRead(reader, length, options, target) {
+		let message = target ?? this.create(), end = reader.pos + length;
+		while (reader.pos < end) {
+			let [fieldNo, wireType] = reader.tag();
+			switch (fieldNo) {
+				case 1:
+					message.statementTimeout = reader.int32();
+					break;
+				case 2:
+					message.queryTimeout = reader.int32();
+					break;
+				case 3:
+					message.binaryMode = reader.bool();
+					break;
+				case 4:
+					message.cursorName = reader.string();
+					break;
+				case 5:
+					message.fetchSize = reader.int32();
+					break;
+				case 6:
+					message.readOnly = reader.bool();
+					break;
+				case 7:
+					this.binaryReadMap7(message.customOptions, reader, options);
+					break;
+				default:
+					let u = options.readUnknownField;
+					if (u === "throw") throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+					let d = reader.skip(wireType);
+					if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+			}
+		}
+		return message;
+	}
+	binaryReadMap7(map, reader, options) {
+		let len = reader.uint32(), end = reader.pos + len, key, val;
+		while (reader.pos < end) {
+			let [fieldNo, wireType] = reader.tag();
+			switch (fieldNo) {
+				case 1:
+					key = reader.string();
+					break;
+				case 2:
+					val = reader.string();
+					break;
+				default: throw new globalThis.Error("unknown map entry field for tusk.drift.instrumentation.postgresql.v1.QueryOptions.custom_options");
+			}
+		}
+		map[key ?? ""] = val ?? "";
+	}
+	internalBinaryWrite(message, writer, options) {
+		if (message.statementTimeout !== 0) writer.tag(1, WireType.Varint).int32(message.statementTimeout);
+		if (message.queryTimeout !== 0) writer.tag(2, WireType.Varint).int32(message.queryTimeout);
+		if (message.binaryMode !== false) writer.tag(3, WireType.Varint).bool(message.binaryMode);
+		if (message.cursorName !== "") writer.tag(4, WireType.LengthDelimited).string(message.cursorName);
+		if (message.fetchSize !== 0) writer.tag(5, WireType.Varint).int32(message.fetchSize);
+		if (message.readOnly !== false) writer.tag(6, WireType.Varint).bool(message.readOnly);
+		for (let k of globalThis.Object.keys(message.customOptions)) writer.tag(7, WireType.LengthDelimited).fork().tag(1, WireType.LengthDelimited).string(k).tag(2, WireType.LengthDelimited).string(message.customOptions[k]).join();
+		let u = options.writeUnknownFields;
+		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+		return writer;
+	}
+};
+/**
+* @generated MessageType for protobuf message tusk.drift.instrumentation.postgresql.v1.QueryOptions
+*/
+const QueryOptions = new QueryOptions$Type();
+var PostgreSQLResult$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.instrumentation.postgresql.v1.PostgreSQLResult", [
+			{
+				no: 1,
+				name: "command",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 2,
+				name: "row_count",
+				kind: "scalar",
+				T: 5
+			},
+			{
+				no: 3,
+				name: "oid",
+				kind: "scalar",
+				opt: true,
+				T: 5
+			},
+			{
+				no: 4,
+				name: "rows",
+				kind: "message",
+				repeat: 2,
+				T: () => Struct
+			},
+			{
+				no: 5,
+				name: "fields",
+				kind: "message",
+				repeat: 2,
+				T: () => PostgreSQLField
+			},
+			{
+				no: 6,
+				name: "execution_info",
+				kind: "message",
+				T: () => QueryExecutionInfo
+			},
+			{
+				no: 7,
+				name: "error",
+				kind: "message",
+				T: () => PostgreSQLError
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.command = "";
+		message.rowCount = 0;
+		message.rows = [];
+		message.fields = [];
+		if (value !== void 0) reflectionMergePartial(this, message, value);
+		return message;
+	}
+	internalBinaryRead(reader, length, options, target) {
+		let message = target ?? this.create(), end = reader.pos + length;
+		while (reader.pos < end) {
+			let [fieldNo, wireType] = reader.tag();
+			switch (fieldNo) {
+				case 1:
+					message.command = reader.string();
+					break;
+				case 2:
+					message.rowCount = reader.int32();
+					break;
+				case 3:
+					message.oid = reader.int32();
+					break;
+				case 4:
+					message.rows.push(Struct.internalBinaryRead(reader, reader.uint32(), options));
+					break;
+				case 5:
+					message.fields.push(PostgreSQLField.internalBinaryRead(reader, reader.uint32(), options));
+					break;
+				case 6:
+					message.executionInfo = QueryExecutionInfo.internalBinaryRead(reader, reader.uint32(), options, message.executionInfo);
+					break;
+				case 7:
+					message.error = PostgreSQLError.internalBinaryRead(reader, reader.uint32(), options, message.error);
+					break;
+				default:
+					let u = options.readUnknownField;
+					if (u === "throw") throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+					let d = reader.skip(wireType);
+					if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+			}
+		}
+		return message;
+	}
+	internalBinaryWrite(message, writer, options) {
+		if (message.command !== "") writer.tag(1, WireType.LengthDelimited).string(message.command);
+		if (message.rowCount !== 0) writer.tag(2, WireType.Varint).int32(message.rowCount);
+		if (message.oid !== void 0) writer.tag(3, WireType.Varint).int32(message.oid);
+		for (let i = 0; i < message.rows.length; i++) Struct.internalBinaryWrite(message.rows[i], writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+		for (let i = 0; i < message.fields.length; i++) PostgreSQLField.internalBinaryWrite(message.fields[i], writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+		if (message.executionInfo) QueryExecutionInfo.internalBinaryWrite(message.executionInfo, writer.tag(6, WireType.LengthDelimited).fork(), options).join();
+		if (message.error) PostgreSQLError.internalBinaryWrite(message.error, writer.tag(7, WireType.LengthDelimited).fork(), options).join();
+		let u = options.writeUnknownFields;
+		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+		return writer;
+	}
+};
+/**
+* @generated MessageType for protobuf message tusk.drift.instrumentation.postgresql.v1.PostgreSQLResult
+*/
+const PostgreSQLResult = new PostgreSQLResult$Type();
+var PostgreSQLField$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.instrumentation.postgresql.v1.PostgreSQLField", [
+			{
+				no: 1,
+				name: "name",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 2,
+				name: "table_id",
+				kind: "scalar",
+				T: 5
+			},
+			{
+				no: 3,
+				name: "column_id",
+				kind: "scalar",
+				T: 5
+			},
+			{
+				no: 4,
+				name: "data_type_id",
+				kind: "scalar",
+				T: 5
+			},
+			{
+				no: 5,
+				name: "data_type_size",
+				kind: "scalar",
+				T: 5
+			},
+			{
+				no: 6,
+				name: "data_type_modifier",
+				kind: "scalar",
+				T: 5
+			},
+			{
+				no: 7,
+				name: "format",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 8,
+				name: "data_type_name",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 9,
+				name: "nullable",
+				kind: "scalar",
+				T: 8
+			},
+			{
+				no: 10,
+				name: "primary_key",
+				kind: "scalar",
+				T: 8
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.name = "";
+		message.tableId = 0;
+		message.columnId = 0;
+		message.dataTypeId = 0;
+		message.dataTypeSize = 0;
+		message.dataTypeModifier = 0;
+		message.format = "";
+		message.dataTypeName = "";
+		message.nullable = false;
+		message.primaryKey = false;
+		if (value !== void 0) reflectionMergePartial(this, message, value);
+		return message;
+	}
+	internalBinaryRead(reader, length, options, target) {
+		let message = target ?? this.create(), end = reader.pos + length;
+		while (reader.pos < end) {
+			let [fieldNo, wireType] = reader.tag();
+			switch (fieldNo) {
+				case 1:
+					message.name = reader.string();
+					break;
+				case 2:
+					message.tableId = reader.int32();
+					break;
+				case 3:
+					message.columnId = reader.int32();
+					break;
+				case 4:
+					message.dataTypeId = reader.int32();
+					break;
+				case 5:
+					message.dataTypeSize = reader.int32();
+					break;
+				case 6:
+					message.dataTypeModifier = reader.int32();
+					break;
+				case 7:
+					message.format = reader.string();
+					break;
+				case 8:
+					message.dataTypeName = reader.string();
+					break;
+				case 9:
+					message.nullable = reader.bool();
+					break;
+				case 10:
+					message.primaryKey = reader.bool();
+					break;
+				default:
+					let u = options.readUnknownField;
+					if (u === "throw") throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+					let d = reader.skip(wireType);
+					if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+			}
+		}
+		return message;
+	}
+	internalBinaryWrite(message, writer, options) {
+		if (message.name !== "") writer.tag(1, WireType.LengthDelimited).string(message.name);
+		if (message.tableId !== 0) writer.tag(2, WireType.Varint).int32(message.tableId);
+		if (message.columnId !== 0) writer.tag(3, WireType.Varint).int32(message.columnId);
+		if (message.dataTypeId !== 0) writer.tag(4, WireType.Varint).int32(message.dataTypeId);
+		if (message.dataTypeSize !== 0) writer.tag(5, WireType.Varint).int32(message.dataTypeSize);
+		if (message.dataTypeModifier !== 0) writer.tag(6, WireType.Varint).int32(message.dataTypeModifier);
+		if (message.format !== "") writer.tag(7, WireType.LengthDelimited).string(message.format);
+		if (message.dataTypeName !== "") writer.tag(8, WireType.LengthDelimited).string(message.dataTypeName);
+		if (message.nullable !== false) writer.tag(9, WireType.Varint).bool(message.nullable);
+		if (message.primaryKey !== false) writer.tag(10, WireType.Varint).bool(message.primaryKey);
+		let u = options.writeUnknownFields;
+		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+		return writer;
+	}
+};
+/**
+* @generated MessageType for protobuf message tusk.drift.instrumentation.postgresql.v1.PostgreSQLField
+*/
+const PostgreSQLField = new PostgreSQLField$Type();
+var QueryExecutionInfo$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.instrumentation.postgresql.v1.QueryExecutionInfo", [
+			{
+				no: 1,
+				name: "parse_time_ms",
+				kind: "scalar",
+				T: 3,
+				L: 0
+			},
+			{
+				no: 2,
+				name: "plan_time_ms",
+				kind: "scalar",
+				T: 3,
+				L: 0
+			},
+			{
+				no: 3,
+				name: "execute_time_ms",
+				kind: "scalar",
+				T: 3,
+				L: 0
+			},
+			{
+				no: 4,
+				name: "total_time_ms",
+				kind: "scalar",
+				T: 3,
+				L: 0
+			},
+			{
+				no: 5,
+				name: "rows_examined",
+				kind: "scalar",
+				T: 3,
+				L: 0
+			},
+			{
+				no: 6,
+				name: "rows_returned",
+				kind: "scalar",
+				T: 3,
+				L: 0
+			},
+			{
+				no: 7,
+				name: "bytes_sent",
+				kind: "scalar",
+				T: 3,
+				L: 0
+			},
+			{
+				no: 8,
+				name: "bytes_received",
+				kind: "scalar",
+				T: 3,
+				L: 0
+			},
+			{
+				no: 9,
+				name: "execution_plan",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 10,
+				name: "notices",
+				kind: "scalar",
+				repeat: 2,
+				T: 9
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.parseTimeMs = 0n;
+		message.planTimeMs = 0n;
+		message.executeTimeMs = 0n;
+		message.totalTimeMs = 0n;
+		message.rowsExamined = 0n;
+		message.rowsReturned = 0n;
+		message.bytesSent = 0n;
+		message.bytesReceived = 0n;
+		message.executionPlan = "";
+		message.notices = [];
+		if (value !== void 0) reflectionMergePartial(this, message, value);
+		return message;
+	}
+	internalBinaryRead(reader, length, options, target) {
+		let message = target ?? this.create(), end = reader.pos + length;
+		while (reader.pos < end) {
+			let [fieldNo, wireType] = reader.tag();
+			switch (fieldNo) {
+				case 1:
+					message.parseTimeMs = reader.int64().toBigInt();
+					break;
+				case 2:
+					message.planTimeMs = reader.int64().toBigInt();
+					break;
+				case 3:
+					message.executeTimeMs = reader.int64().toBigInt();
+					break;
+				case 4:
+					message.totalTimeMs = reader.int64().toBigInt();
+					break;
+				case 5:
+					message.rowsExamined = reader.int64().toBigInt();
+					break;
+				case 6:
+					message.rowsReturned = reader.int64().toBigInt();
+					break;
+				case 7:
+					message.bytesSent = reader.int64().toBigInt();
+					break;
+				case 8:
+					message.bytesReceived = reader.int64().toBigInt();
+					break;
+				case 9:
+					message.executionPlan = reader.string();
+					break;
+				case 10:
+					message.notices.push(reader.string());
+					break;
+				default:
+					let u = options.readUnknownField;
+					if (u === "throw") throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+					let d = reader.skip(wireType);
+					if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+			}
+		}
+		return message;
+	}
+	internalBinaryWrite(message, writer, options) {
+		if (message.parseTimeMs !== 0n) writer.tag(1, WireType.Varint).int64(message.parseTimeMs);
+		if (message.planTimeMs !== 0n) writer.tag(2, WireType.Varint).int64(message.planTimeMs);
+		if (message.executeTimeMs !== 0n) writer.tag(3, WireType.Varint).int64(message.executeTimeMs);
+		if (message.totalTimeMs !== 0n) writer.tag(4, WireType.Varint).int64(message.totalTimeMs);
+		if (message.rowsExamined !== 0n) writer.tag(5, WireType.Varint).int64(message.rowsExamined);
+		if (message.rowsReturned !== 0n) writer.tag(6, WireType.Varint).int64(message.rowsReturned);
+		if (message.bytesSent !== 0n) writer.tag(7, WireType.Varint).int64(message.bytesSent);
+		if (message.bytesReceived !== 0n) writer.tag(8, WireType.Varint).int64(message.bytesReceived);
+		if (message.executionPlan !== "") writer.tag(9, WireType.LengthDelimited).string(message.executionPlan);
+		for (let i = 0; i < message.notices.length; i++) writer.tag(10, WireType.LengthDelimited).string(message.notices[i]);
+		let u = options.writeUnknownFields;
+		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+		return writer;
+	}
+};
+/**
+* @generated MessageType for protobuf message tusk.drift.instrumentation.postgresql.v1.QueryExecutionInfo
+*/
+const QueryExecutionInfo = new QueryExecutionInfo$Type();
+var PostgreSQLError$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.instrumentation.postgresql.v1.PostgreSQLError", [
+			{
+				no: 1,
+				name: "sql_state",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 2,
+				name: "message",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 3,
+				name: "detail",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 4,
+				name: "hint",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 5,
+				name: "position",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 6,
+				name: "where",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 7,
+				name: "schema_name",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 8,
+				name: "table_name",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 9,
+				name: "column_name",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 10,
+				name: "constraint_name",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 11,
+				name: "data_type_name",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 12,
+				name: "file",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 13,
+				name: "line",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 14,
+				name: "routine",
+				kind: "scalar",
+				T: 9
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.sqlState = "";
+		message.message = "";
+		message.detail = "";
+		message.hint = "";
+		message.position = "";
+		message.where = "";
+		message.schemaName = "";
+		message.tableName = "";
+		message.columnName = "";
+		message.constraintName = "";
+		message.dataTypeName = "";
+		message.file = "";
+		message.line = "";
+		message.routine = "";
+		if (value !== void 0) reflectionMergePartial(this, message, value);
+		return message;
+	}
+	internalBinaryRead(reader, length, options, target) {
+		let message = target ?? this.create(), end = reader.pos + length;
+		while (reader.pos < end) {
+			let [fieldNo, wireType] = reader.tag();
+			switch (fieldNo) {
+				case 1:
+					message.sqlState = reader.string();
+					break;
+				case 2:
+					message.message = reader.string();
+					break;
+				case 3:
+					message.detail = reader.string();
+					break;
+				case 4:
+					message.hint = reader.string();
+					break;
+				case 5:
+					message.position = reader.string();
+					break;
+				case 6:
+					message.where = reader.string();
+					break;
+				case 7:
+					message.schemaName = reader.string();
+					break;
+				case 8:
+					message.tableName = reader.string();
+					break;
+				case 9:
+					message.columnName = reader.string();
+					break;
+				case 10:
+					message.constraintName = reader.string();
+					break;
+				case 11:
+					message.dataTypeName = reader.string();
+					break;
+				case 12:
+					message.file = reader.string();
+					break;
+				case 13:
+					message.line = reader.string();
+					break;
+				case 14:
+					message.routine = reader.string();
+					break;
+				default:
+					let u = options.readUnknownField;
+					if (u === "throw") throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+					let d = reader.skip(wireType);
+					if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+			}
+		}
+		return message;
+	}
+	internalBinaryWrite(message, writer, options) {
+		if (message.sqlState !== "") writer.tag(1, WireType.LengthDelimited).string(message.sqlState);
+		if (message.message !== "") writer.tag(2, WireType.LengthDelimited).string(message.message);
+		if (message.detail !== "") writer.tag(3, WireType.LengthDelimited).string(message.detail);
+		if (message.hint !== "") writer.tag(4, WireType.LengthDelimited).string(message.hint);
+		if (message.position !== "") writer.tag(5, WireType.LengthDelimited).string(message.position);
+		if (message.where !== "") writer.tag(6, WireType.LengthDelimited).string(message.where);
+		if (message.schemaName !== "") writer.tag(7, WireType.LengthDelimited).string(message.schemaName);
+		if (message.tableName !== "") writer.tag(8, WireType.LengthDelimited).string(message.tableName);
+		if (message.columnName !== "") writer.tag(9, WireType.LengthDelimited).string(message.columnName);
+		if (message.constraintName !== "") writer.tag(10, WireType.LengthDelimited).string(message.constraintName);
+		if (message.dataTypeName !== "") writer.tag(11, WireType.LengthDelimited).string(message.dataTypeName);
+		if (message.file !== "") writer.tag(12, WireType.LengthDelimited).string(message.file);
+		if (message.line !== "") writer.tag(13, WireType.LengthDelimited).string(message.line);
+		if (message.routine !== "") writer.tag(14, WireType.LengthDelimited).string(message.routine);
+		let u = options.writeUnknownFields;
+		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+		return writer;
+	}
+};
+/**
+* @generated MessageType for protobuf message tusk.drift.instrumentation.postgresql.v1.PostgreSQLError
+*/
+const PostgreSQLError = new PostgreSQLError$Type();
+var PostgreSQLPreparedStatement$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.instrumentation.postgresql.v1.PostgreSQLPreparedStatement", [
+			{
+				no: 1,
+				name: "statement_name",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 2,
+				name: "query_text",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 3,
+				name: "parameter_types",
+				kind: "message",
+				repeat: 2,
+				T: () => PostgreSQLParameterType
+			},
+			{
+				no: 4,
+				name: "prepared_at",
+				kind: "message",
+				T: () => Timestamp
+			},
+			{
+				no: 5,
+				name: "execution_count",
+				kind: "scalar",
+				T: 5
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.statementName = "";
+		message.queryText = "";
+		message.parameterTypes = [];
+		message.executionCount = 0;
+		if (value !== void 0) reflectionMergePartial(this, message, value);
+		return message;
+	}
+	internalBinaryRead(reader, length, options, target) {
+		let message = target ?? this.create(), end = reader.pos + length;
+		while (reader.pos < end) {
+			let [fieldNo, wireType] = reader.tag();
+			switch (fieldNo) {
+				case 1:
+					message.statementName = reader.string();
+					break;
+				case 2:
+					message.queryText = reader.string();
+					break;
+				case 3:
+					message.parameterTypes.push(PostgreSQLParameterType.internalBinaryRead(reader, reader.uint32(), options));
+					break;
+				case 4:
+					message.preparedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.preparedAt);
+					break;
+				case 5:
+					message.executionCount = reader.int32();
+					break;
+				default:
+					let u = options.readUnknownField;
+					if (u === "throw") throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+					let d = reader.skip(wireType);
+					if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+			}
+		}
+		return message;
+	}
+	internalBinaryWrite(message, writer, options) {
+		if (message.statementName !== "") writer.tag(1, WireType.LengthDelimited).string(message.statementName);
+		if (message.queryText !== "") writer.tag(2, WireType.LengthDelimited).string(message.queryText);
+		for (let i = 0; i < message.parameterTypes.length; i++) PostgreSQLParameterType.internalBinaryWrite(message.parameterTypes[i], writer.tag(3, WireType.LengthDelimited).fork(), options).join();
+		if (message.preparedAt) Timestamp.internalBinaryWrite(message.preparedAt, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+		if (message.executionCount !== 0) writer.tag(5, WireType.Varint).int32(message.executionCount);
+		let u = options.writeUnknownFields;
+		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+		return writer;
+	}
+};
+/**
+* @generated MessageType for protobuf message tusk.drift.instrumentation.postgresql.v1.PostgreSQLPreparedStatement
+*/
+const PostgreSQLPreparedStatement = new PostgreSQLPreparedStatement$Type();
+var PostgreSQLParameterType$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.instrumentation.postgresql.v1.PostgreSQLParameterType", [
+			{
+				no: 1,
+				name: "position",
+				kind: "scalar",
+				T: 5
+			},
+			{
+				no: 2,
+				name: "data_type_id",
+				kind: "scalar",
+				T: 5
+			},
+			{
+				no: 3,
+				name: "data_type_name",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 4,
+				name: "nullable",
+				kind: "scalar",
+				T: 8
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.position = 0;
+		message.dataTypeId = 0;
+		message.dataTypeName = "";
+		message.nullable = false;
+		if (value !== void 0) reflectionMergePartial(this, message, value);
+		return message;
+	}
+	internalBinaryRead(reader, length, options, target) {
+		let message = target ?? this.create(), end = reader.pos + length;
+		while (reader.pos < end) {
+			let [fieldNo, wireType] = reader.tag();
+			switch (fieldNo) {
+				case 1:
+					message.position = reader.int32();
+					break;
+				case 2:
+					message.dataTypeId = reader.int32();
+					break;
+				case 3:
+					message.dataTypeName = reader.string();
+					break;
+				case 4:
+					message.nullable = reader.bool();
+					break;
+				default:
+					let u = options.readUnknownField;
+					if (u === "throw") throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+					let d = reader.skip(wireType);
+					if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+			}
+		}
+		return message;
+	}
+	internalBinaryWrite(message, writer, options) {
+		if (message.position !== 0) writer.tag(1, WireType.Varint).int32(message.position);
+		if (message.dataTypeId !== 0) writer.tag(2, WireType.Varint).int32(message.dataTypeId);
+		if (message.dataTypeName !== "") writer.tag(3, WireType.LengthDelimited).string(message.dataTypeName);
+		if (message.nullable !== false) writer.tag(4, WireType.Varint).bool(message.nullable);
+		let u = options.writeUnknownFields;
+		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+		return writer;
+	}
+};
+/**
+* @generated MessageType for protobuf message tusk.drift.instrumentation.postgresql.v1.PostgreSQLParameterType
+*/
+const PostgreSQLParameterType = new PostgreSQLParameterType$Type();
+var PostgreSQLTransaction$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.instrumentation.postgresql.v1.PostgreSQLTransaction", [
+			{
+				no: 1,
+				name: "transaction_id",
+				kind: "scalar",
+				T: 9
+			},
+			{
+				no: 2,
+				name: "state",
+				kind: "enum",
+				T: () => [
+					"tusk.drift.instrumentation.postgresql.v1.TransactionState",
+					TransactionState,
+					"TRANSACTION_STATE_"
+				]
+			},
+			{
+				no: 3,
+				name: "isolation_level",
+				kind: "enum",
+				T: () => [
+					"tusk.drift.instrumentation.postgresql.v1.IsolationLevel",
+					IsolationLevel,
+					"ISOLATION_LEVEL_"
+				]
+			},
+			{
+				no: 4,
+				name: "read_only",
+				kind: "scalar",
+				T: 8
+			},
+			{
+				no: 5,
+				name: "started_at",
+				kind: "message",
+				T: () => Timestamp
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.transactionId = "";
+		message.state = 0;
+		message.isolationLevel = 0;
+		message.readOnly = false;
+		if (value !== void 0) reflectionMergePartial(this, message, value);
+		return message;
+	}
+	internalBinaryRead(reader, length, options, target) {
+		let message = target ?? this.create(), end = reader.pos + length;
+		while (reader.pos < end) {
+			let [fieldNo, wireType] = reader.tag();
+			switch (fieldNo) {
+				case 1:
+					message.transactionId = reader.string();
+					break;
+				case 2:
+					message.state = reader.int32();
+					break;
+				case 3:
+					message.isolationLevel = reader.int32();
+					break;
+				case 4:
+					message.readOnly = reader.bool();
+					break;
+				case 5:
+					message.startedAt = Timestamp.internalBinaryRead(reader, reader.uint32(), options, message.startedAt);
+					break;
+				default:
+					let u = options.readUnknownField;
+					if (u === "throw") throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+					let d = reader.skip(wireType);
+					if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+			}
+		}
+		return message;
+	}
+	internalBinaryWrite(message, writer, options) {
+		if (message.transactionId !== "") writer.tag(1, WireType.LengthDelimited).string(message.transactionId);
+		if (message.state !== 0) writer.tag(2, WireType.Varint).int32(message.state);
+		if (message.isolationLevel !== 0) writer.tag(3, WireType.Varint).int32(message.isolationLevel);
+		if (message.readOnly !== false) writer.tag(4, WireType.Varint).bool(message.readOnly);
+		if (message.startedAt) Timestamp.internalBinaryWrite(message.startedAt, writer.tag(5, WireType.LengthDelimited).fork(), options).join();
+		let u = options.writeUnknownFields;
+		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+		return writer;
+	}
+};
+/**
+* @generated MessageType for protobuf message tusk.drift.instrumentation.postgresql.v1.PostgreSQLTransaction
+*/
+const PostgreSQLTransaction = new PostgreSQLTransaction$Type();
+var PostgreSQLBatch$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.instrumentation.postgresql.v1.PostgreSQLBatch", [
+			{
+				no: 1,
+				name: "queries",
+				kind: "message",
+				repeat: 2,
+				T: () => PostgreSQLQuery
+			},
+			{
+				no: 2,
+				name: "stop_on_error",
+				kind: "scalar",
+				T: 8
+			},
+			{
+				no: 3,
+				name: "return_results",
+				kind: "scalar",
+				T: 8
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.queries = [];
+		message.stopOnError = false;
+		message.returnResults = false;
+		if (value !== void 0) reflectionMergePartial(this, message, value);
+		return message;
+	}
+	internalBinaryRead(reader, length, options, target) {
+		let message = target ?? this.create(), end = reader.pos + length;
+		while (reader.pos < end) {
+			let [fieldNo, wireType] = reader.tag();
+			switch (fieldNo) {
+				case 1:
+					message.queries.push(PostgreSQLQuery.internalBinaryRead(reader, reader.uint32(), options));
+					break;
+				case 2:
+					message.stopOnError = reader.bool();
+					break;
+				case 3:
+					message.returnResults = reader.bool();
+					break;
+				default:
+					let u = options.readUnknownField;
+					if (u === "throw") throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+					let d = reader.skip(wireType);
+					if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+			}
+		}
+		return message;
+	}
+	internalBinaryWrite(message, writer, options) {
+		for (let i = 0; i < message.queries.length; i++) PostgreSQLQuery.internalBinaryWrite(message.queries[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+		if (message.stopOnError !== false) writer.tag(2, WireType.Varint).bool(message.stopOnError);
+		if (message.returnResults !== false) writer.tag(3, WireType.Varint).bool(message.returnResults);
+		let u = options.writeUnknownFields;
+		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+		return writer;
+	}
+};
+/**
+* @generated MessageType for protobuf message tusk.drift.instrumentation.postgresql.v1.PostgreSQLBatch
+*/
+const PostgreSQLBatch = new PostgreSQLBatch$Type();
+var PostgreSQLBatchResult$Type = class extends MessageType {
+	constructor() {
+		super("tusk.drift.instrumentation.postgresql.v1.PostgreSQLBatchResult", [
+			{
+				no: 1,
+				name: "results",
+				kind: "message",
+				repeat: 2,
+				T: () => PostgreSQLResult
+			},
+			{
+				no: 2,
+				name: "successful_queries",
+				kind: "scalar",
+				T: 5
+			},
+			{
+				no: 3,
+				name: "failed_queries",
+				kind: "scalar",
+				T: 5
+			},
+			{
+				no: 4,
+				name: "first_error",
+				kind: "message",
+				T: () => PostgreSQLError
+			}
+		]);
+	}
+	create(value) {
+		const message = globalThis.Object.create(this.messagePrototype);
+		message.results = [];
+		message.successfulQueries = 0;
+		message.failedQueries = 0;
+		if (value !== void 0) reflectionMergePartial(this, message, value);
+		return message;
+	}
+	internalBinaryRead(reader, length, options, target) {
+		let message = target ?? this.create(), end = reader.pos + length;
+		while (reader.pos < end) {
+			let [fieldNo, wireType] = reader.tag();
+			switch (fieldNo) {
+				case 1:
+					message.results.push(PostgreSQLResult.internalBinaryRead(reader, reader.uint32(), options));
+					break;
+				case 2:
+					message.successfulQueries = reader.int32();
+					break;
+				case 3:
+					message.failedQueries = reader.int32();
+					break;
+				case 4:
+					message.firstError = PostgreSQLError.internalBinaryRead(reader, reader.uint32(), options, message.firstError);
+					break;
+				default:
+					let u = options.readUnknownField;
+					if (u === "throw") throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+					let d = reader.skip(wireType);
+					if (u !== false) (u === true ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+			}
+		}
+		return message;
+	}
+	internalBinaryWrite(message, writer, options) {
+		for (let i = 0; i < message.results.length; i++) PostgreSQLResult.internalBinaryWrite(message.results[i], writer.tag(1, WireType.LengthDelimited).fork(), options).join();
+		if (message.successfulQueries !== 0) writer.tag(2, WireType.Varint).int32(message.successfulQueries);
+		if (message.failedQueries !== 0) writer.tag(3, WireType.Varint).int32(message.failedQueries);
+		if (message.firstError) PostgreSQLError.internalBinaryWrite(message.firstError, writer.tag(4, WireType.LengthDelimited).fork(), options).join();
+		let u = options.writeUnknownFields;
+		if (u !== false) (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+		return writer;
+	}
+};
+/**
+* @generated MessageType for protobuf message tusk.drift.instrumentation.postgresql.v1.PostgreSQLBatchResult
+*/
+const PostgreSQLBatchResult = new PostgreSQLBatchResult$Type();
+
+//#endregion
+export { IsolationLevel, PostgreSQLBatch, PostgreSQLBatchResult, PostgreSQLConnection, PostgreSQLError, PostgreSQLField, PostgreSQLParameterType, PostgreSQLPreparedStatement, PostgreSQLQuery, PostgreSQLResult, PostgreSQLTransaction, QueryExecutionInfo, QueryOptions, TransactionState };
+//# sourceMappingURL=postgresql.js.map