@alienplatform/sdk 1.11.1 → 1.12.0

package/dist/event-streams.js

@@ -1,6 +1,564 @@
 import { n as __esmMin } from "./rolldown-runtime.js";
-import { Dt as fromUtf8, r as init_serde, wt as toUtf8 } from "./serde.js";
-//#region ../../node_modules/.pnpm/@smithy+core@3.24.7/node_modules/@smithy/core/dist-es/submodules/event-streams/EventStreamSerde.js
+import { Pt as fromUtf8, a as Crc32Node, at as fromHex, jt as toUtf8, l as init_serde, n as init_checksum, st as toHex } from "./checksum.js";
+import { Readable } from "node:stream";
+//#region ../../node_modules/.pnpm/@smithy+core@3.29.1/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-codec/Int64.js
+function negate(bytes) {
+	for (let i = 0; i < 8; i++) bytes[i] ^= 255;
+	for (let i = 7; i > -1; i--) {
+		bytes[i]++;
+		if (bytes[i] !== 0) break;
+	}
+}
+var Int64;
+var init_Int64 = __esmMin((() => {
+	init_serde();
+	Int64 = class Int64 {
+		bytes;
+		constructor(bytes) {
+			this.bytes = bytes;
+			if (bytes.byteLength !== 8) throw new Error("Int64 buffers must be exactly 8 bytes");
+		}
+		static fromNumber(number) {
+			if (number > 0x8000000000000000 || number < -0x8000000000000000) throw new Error(`${number} is too large (or, if negative, too small) to represent as an Int64`);
+			const bytes = /* @__PURE__ */ new Uint8Array(8);
+			for (let i = 7, remaining = Math.abs(Math.round(number)); i > -1 && remaining > 0; i--, remaining /= 256) bytes[i] = remaining;
+			if (number < 0) negate(bytes);
+			return new Int64(bytes);
+		}
+		valueOf() {
+			const bytes = this.bytes.slice(0);
+			const negative = bytes[0] & 128;
+			if (negative) negate(bytes);
+			return parseInt(toHex(bytes), 16) * (negative ? -1 : 1);
+		}
+		toString() {
+			return String(this.valueOf());
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.29.1/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-codec/HeaderMarshaller.js
+var HeaderMarshaller, HEADER_VALUE_TYPE, BOOLEAN_TAG, BYTE_TAG, SHORT_TAG, INT_TAG, LONG_TAG, BINARY_TAG, STRING_TAG, TIMESTAMP_TAG, UUID_TAG, UUID_PATTERN;
+var init_HeaderMarshaller = __esmMin((() => {
+	init_serde();
+	init_Int64();
+	HeaderMarshaller = class {
+		toUtf8;
+		fromUtf8;
+		constructor(toUtf8, fromUtf8) {
+			this.toUtf8 = toUtf8;
+			this.fromUtf8 = fromUtf8;
+		}
+		format(headers) {
+			const chunks = [];
+			for (const headerName of Object.keys(headers)) {
+				const bytes = this.fromUtf8(headerName);
+				chunks.push(Uint8Array.from([bytes.byteLength]), bytes, this.formatHeaderValue(headers[headerName]));
+			}
+			const out = new Uint8Array(chunks.reduce((carry, bytes) => carry + bytes.byteLength, 0));
+			let position = 0;
+			for (const chunk of chunks) {
+				out.set(chunk, position);
+				position += chunk.byteLength;
+			}
+			return out;
+		}
+		formatHeaderValue(header) {
+			switch (header.type) {
+				case "boolean": return Uint8Array.from([header.value ? 0 : 1]);
+				case "byte": return Uint8Array.from([2, header.value]);
+				case "short":
+					const shortView = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(3));
+					shortView.setUint8(0, 3);
+					shortView.setInt16(1, header.value, false);
+					return new Uint8Array(shortView.buffer);
+				case "integer":
+					const intView = /* @__PURE__ */ new DataView(/* @__PURE__ */ new ArrayBuffer(5));
+					intView.setUint8(0, 4);
+					intView.setInt32(1, header.value, false);
+					return new Uint8Array(intView.buffer);
+				case "long":
+					const longBytes = /* @__PURE__ */ new Uint8Array(9);
+					longBytes[0] = 5;
+					longBytes.set(header.value.bytes, 1);
+					return longBytes;
+				case "binary":
+					const binView = new DataView(new ArrayBuffer(3 + header.value.byteLength));
+					binView.setUint8(0, 6);
+					binView.setUint16(1, header.value.byteLength, false);
+					const binBytes = new Uint8Array(binView.buffer);
+					binBytes.set(header.value, 3);
+					return binBytes;
+				case "string":
+					const utf8Bytes = this.fromUtf8(header.value);
+					const strView = new DataView(new ArrayBuffer(3 + utf8Bytes.byteLength));
+					strView.setUint8(0, 7);
+					strView.setUint16(1, utf8Bytes.byteLength, false);
+					const strBytes = new Uint8Array(strView.buffer);
+					strBytes.set(utf8Bytes, 3);
+					return strBytes;
+				case "timestamp":
+					const tsBytes = /* @__PURE__ */ new Uint8Array(9);
+					tsBytes[0] = 8;
+					tsBytes.set(Int64.fromNumber(header.value.valueOf()).bytes, 1);
+					return tsBytes;
+				case "uuid":
+					if (!UUID_PATTERN.test(header.value)) throw new Error(`Invalid UUID received: ${header.value}`);
+					const uuidBytes = /* @__PURE__ */ new Uint8Array(17);
+					uuidBytes[0] = 9;
+					uuidBytes.set(fromHex(header.value.replace(/\-/g, "")), 1);
+					return uuidBytes;
+			}
+		}
+		parse(headers) {
+			const out = {};
+			let position = 0;
+			while (position < headers.byteLength) {
+				const nameLength = headers.getUint8(position++);
+				const name = this.toUtf8(new Uint8Array(headers.buffer, headers.byteOffset + position, nameLength));
+				position += nameLength;
+				switch (headers.getUint8(position++)) {
+					case 0:
+						out[name] = {
+							type: BOOLEAN_TAG,
+							value: true
+						};
+						break;
+					case 1:
+						out[name] = {
+							type: BOOLEAN_TAG,
+							value: false
+						};
+						break;
+					case 2:
+						out[name] = {
+							type: BYTE_TAG,
+							value: headers.getInt8(position++)
+						};
+						break;
+					case 3:
+						out[name] = {
+							type: SHORT_TAG,
+							value: headers.getInt16(position, false)
+						};
+						position += 2;
+						break;
+					case 4:
+						out[name] = {
+							type: INT_TAG,
+							value: headers.getInt32(position, false)
+						};
+						position += 4;
+						break;
+					case 5:
+						out[name] = {
+							type: LONG_TAG,
+							value: new Int64(new Uint8Array(headers.buffer, headers.byteOffset + position, 8))
+						};
+						position += 8;
+						break;
+					case 6:
+						const binaryLength = headers.getUint16(position, false);
+						position += 2;
+						out[name] = {
+							type: BINARY_TAG,
+							value: new Uint8Array(headers.buffer, headers.byteOffset + position, binaryLength)
+						};
+						position += binaryLength;
+						break;
+					case 7:
+						const stringLength = headers.getUint16(position, false);
+						position += 2;
+						out[name] = {
+							type: STRING_TAG,
+							value: this.toUtf8(new Uint8Array(headers.buffer, headers.byteOffset + position, stringLength))
+						};
+						position += stringLength;
+						break;
+					case 8:
+						out[name] = {
+							type: TIMESTAMP_TAG,
+							value: new Date(new Int64(new Uint8Array(headers.buffer, headers.byteOffset + position, 8)).valueOf())
+						};
+						position += 8;
+						break;
+					case 9:
+						const uuidBytes = new Uint8Array(headers.buffer, headers.byteOffset + position, 16);
+						position += 16;
+						out[name] = {
+							type: UUID_TAG,
+							value: `${toHex(uuidBytes.subarray(0, 4))}-${toHex(uuidBytes.subarray(4, 6))}-${toHex(uuidBytes.subarray(6, 8))}-${toHex(uuidBytes.subarray(8, 10))}-${toHex(uuidBytes.subarray(10))}`
+						};
+						break;
+					default: throw new Error(`Unrecognized header type tag`);
+				}
+			}
+			return out;
+		}
+	};
+	(function(HEADER_VALUE_TYPE) {
+		HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["boolTrue"] = 0] = "boolTrue";
+		HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["boolFalse"] = 1] = "boolFalse";
+		HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["byte"] = 2] = "byte";
+		HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["short"] = 3] = "short";
+		HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["integer"] = 4] = "integer";
+		HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["long"] = 5] = "long";
+		HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["byteArray"] = 6] = "byteArray";
+		HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["string"] = 7] = "string";
+		HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["timestamp"] = 8] = "timestamp";
+		HEADER_VALUE_TYPE[HEADER_VALUE_TYPE["uuid"] = 9] = "uuid";
+	})(HEADER_VALUE_TYPE || (HEADER_VALUE_TYPE = {}));
+	BOOLEAN_TAG = "boolean";
+	BYTE_TAG = "byte";
+	SHORT_TAG = "short";
+	INT_TAG = "integer";
+	LONG_TAG = "long";
+	BINARY_TAG = "binary";
+	STRING_TAG = "string";
+	TIMESTAMP_TAG = "timestamp";
+	UUID_TAG = "uuid";
+	UUID_PATTERN = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.29.1/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-codec/splitMessage.js
+function splitMessage({ byteLength, byteOffset, buffer }) {
+	if (byteLength < MINIMUM_MESSAGE_LENGTH) throw new Error("Provided message too short to accommodate event stream message overhead");
+	const view = new DataView(buffer, byteOffset, byteLength);
+	const messageLength = view.getUint32(0, false);
+	if (byteLength !== messageLength) throw new Error("Reported message length does not match received message length");
+	const headerLength = view.getUint32(PRELUDE_MEMBER_LENGTH, false);
+	const expectedPreludeChecksum = view.getUint32(PRELUDE_LENGTH, false);
+	const expectedMessageChecksum = view.getUint32(byteLength - CHECKSUM_LENGTH, false);
+	const checksummer = new Crc32Node();
+	checksummer.update(new Uint8Array(buffer, byteOffset, PRELUDE_LENGTH));
+	if (expectedPreludeChecksum !== checksummer.digestSync()) throw new Error(`The prelude checksum specified in the message (${expectedPreludeChecksum}) does not match the calculated CRC32 checksum (${checksummer.digestSync()})`);
+	checksummer.update(new Uint8Array(buffer, byteOffset + PRELUDE_LENGTH, byteLength - 12));
+	if (expectedMessageChecksum !== checksummer.digestSync()) throw new Error(`The message checksum (${checksummer.digestSync()}) did not match the expected value of ${expectedMessageChecksum}`);
+	return {
+		headers: new DataView(buffer, byteOffset + PRELUDE_LENGTH + CHECKSUM_LENGTH, headerLength),
+		body: new Uint8Array(buffer, byteOffset + PRELUDE_LENGTH + CHECKSUM_LENGTH + headerLength, messageLength - headerLength - 16)
+	};
+}
+var PRELUDE_MEMBER_LENGTH, PRELUDE_LENGTH, CHECKSUM_LENGTH, MINIMUM_MESSAGE_LENGTH;
+var init_splitMessage = __esmMin((() => {
+	init_checksum();
+	PRELUDE_MEMBER_LENGTH = 4;
+	PRELUDE_LENGTH = PRELUDE_MEMBER_LENGTH * 2;
+	CHECKSUM_LENGTH = 4;
+	MINIMUM_MESSAGE_LENGTH = 16;
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.29.1/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-codec/EventStreamCodec.js
+var EventStreamCodec;
+var init_EventStreamCodec = __esmMin((() => {
+	init_checksum();
+	init_HeaderMarshaller();
+	init_splitMessage();
+	EventStreamCodec = class {
+		headerMarshaller;
+		messageBuffer;
+		isEndOfStream;
+		constructor(toUtf8, fromUtf8) {
+			this.headerMarshaller = new HeaderMarshaller(toUtf8, fromUtf8);
+			this.messageBuffer = [];
+			this.isEndOfStream = false;
+		}
+		feed(message) {
+			this.messageBuffer.push(this.decode(message));
+		}
+		endOfStream() {
+			this.isEndOfStream = true;
+		}
+		getMessage() {
+			const message = this.messageBuffer.pop();
+			const isEndOfStream = this.isEndOfStream;
+			return {
+				getMessage() {
+					return message;
+				},
+				isEndOfStream() {
+					return isEndOfStream;
+				}
+			};
+		}
+		getAvailableMessages() {
+			const messages = this.messageBuffer;
+			this.messageBuffer = [];
+			const isEndOfStream = this.isEndOfStream;
+			return {
+				getMessages() {
+					return messages;
+				},
+				isEndOfStream() {
+					return isEndOfStream;
+				}
+			};
+		}
+		encode({ headers: rawHeaders, body }) {
+			const headers = this.headerMarshaller.format(rawHeaders);
+			const length = headers.byteLength + body.byteLength + 16;
+			const out = new Uint8Array(length);
+			const view = new DataView(out.buffer, out.byteOffset, out.byteLength);
+			const checksum = new Crc32Node();
+			view.setUint32(0, length, false);
+			view.setUint32(4, headers.byteLength, false);
+			checksum.update(out.subarray(0, 8));
+			view.setUint32(8, checksum.digestSync(), false);
+			out.set(headers, 12);
+			out.set(body, headers.byteLength + 12);
+			checksum.update(out.subarray(8, length - 4));
+			view.setUint32(length - 4, checksum.digestSync(), false);
+			return out;
+		}
+		decode(message) {
+			const { headers, body } = splitMessage(message);
+			return {
+				headers: this.headerMarshaller.parse(headers),
+				body
+			};
+		}
+		formatHeaders(rawHeaders) {
+			return this.headerMarshaller.format(rawHeaders);
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.29.1/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-codec/MessageDecoderStream.js
+var MessageDecoderStream;
+var init_MessageDecoderStream = __esmMin((() => {
+	MessageDecoderStream = class {
+		options;
+		constructor(options) {
+			this.options = options;
+		}
+		[Symbol.asyncIterator]() {
+			return this.asyncIterator();
+		}
+		async *asyncIterator() {
+			for await (const bytes of this.options.inputStream) yield this.options.decoder.decode(bytes);
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.29.1/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-codec/MessageEncoderStream.js
+var MessageEncoderStream;
+var init_MessageEncoderStream = __esmMin((() => {
+	MessageEncoderStream = class {
+		options;
+		constructor(options) {
+			this.options = options;
+		}
+		[Symbol.asyncIterator]() {
+			return this.asyncIterator();
+		}
+		async *asyncIterator() {
+			for await (const msg of this.options.messageStream) yield this.options.encoder.encode(msg);
+			if (this.options.includeEndFrame) yield /* @__PURE__ */ new Uint8Array(0);
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.29.1/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-codec/SmithyMessageDecoderStream.js
+var SmithyMessageDecoderStream;
+var init_SmithyMessageDecoderStream = __esmMin((() => {
+	SmithyMessageDecoderStream = class {
+		options;
+		constructor(options) {
+			this.options = options;
+		}
+		[Symbol.asyncIterator]() {
+			return this.asyncIterator();
+		}
+		async *asyncIterator() {
+			for await (const message of this.options.messageStream) {
+				const deserialized = await this.options.deserializer(message);
+				if (deserialized === void 0) continue;
+				yield deserialized;
+			}
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.29.1/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-codec/SmithyMessageEncoderStream.js
+var SmithyMessageEncoderStream;
+var init_SmithyMessageEncoderStream = __esmMin((() => {
+	SmithyMessageEncoderStream = class {
+		options;
+		constructor(options) {
+			this.options = options;
+		}
+		[Symbol.asyncIterator]() {
+			return this.asyncIterator();
+		}
+		async *asyncIterator() {
+			for await (const chunk of this.options.inputStream) yield this.options.serializer(chunk);
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.29.1/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-serde-universal/getChunkedStream.js
+function getChunkedStream(source) {
+	let currentMessageTotalLength = 0;
+	let currentMessagePendingLength = 0;
+	let currentMessage = null;
+	let messageLengthBuffer = null;
+	const allocateMessage = (size) => {
+		if (typeof size !== "number") throw new Error("Attempted to allocate an event message where size was not a number: " + size);
+		currentMessageTotalLength = size;
+		currentMessagePendingLength = 4;
+		currentMessage = new Uint8Array(size);
+		new DataView(currentMessage.buffer).setUint32(0, size, false);
+	};
+	const iterator = async function* () {
+		const sourceIterator = source[Symbol.asyncIterator]();
+		while (true) {
+			const { value, done } = await sourceIterator.next();
+			if (done) {
+				if (!currentMessageTotalLength) return;
+				else if (currentMessageTotalLength === currentMessagePendingLength) yield currentMessage;
+				else throw new Error("Truncated event message received.");
+				return;
+			}
+			const chunkLength = value.length;
+			let currentOffset = 0;
+			while (currentOffset < chunkLength) {
+				if (!currentMessage) {
+					const bytesRemaining = chunkLength - currentOffset;
+					if (!messageLengthBuffer) messageLengthBuffer = /* @__PURE__ */ new Uint8Array(4);
+					const numBytesForTotal = Math.min(4 - currentMessagePendingLength, bytesRemaining);
+					messageLengthBuffer.set(value.slice(currentOffset, currentOffset + numBytesForTotal), currentMessagePendingLength);
+					currentMessagePendingLength += numBytesForTotal;
+					currentOffset += numBytesForTotal;
+					if (currentMessagePendingLength < 4) break;
+					allocateMessage(new DataView(messageLengthBuffer.buffer).getUint32(0, false));
+					messageLengthBuffer = null;
+				}
+				const numBytesToWrite = Math.min(currentMessageTotalLength - currentMessagePendingLength, chunkLength - currentOffset);
+				currentMessage.set(value.slice(currentOffset, currentOffset + numBytesToWrite), currentMessagePendingLength);
+				currentMessagePendingLength += numBytesToWrite;
+				currentOffset += numBytesToWrite;
+				if (currentMessageTotalLength && currentMessageTotalLength === currentMessagePendingLength) {
+					yield currentMessage;
+					currentMessage = null;
+					currentMessageTotalLength = 0;
+					currentMessagePendingLength = 0;
+				}
+			}
+		}
+	};
+	return { [Symbol.asyncIterator]: iterator };
+}
+var init_getChunkedStream = __esmMin((() => {}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.29.1/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-serde-universal/getUnmarshalledStream.js
+function getMessageUnmarshaller(deserializer, toUtf8) {
+	return async function(message) {
+		const { value: messageType } = message.headers[":message-type"];
+		if (messageType === "error") {
+			const unmodeledError = new Error(message.headers[":error-message"].value || "UnknownError");
+			unmodeledError.name = message.headers[":error-code"].value;
+			throw unmodeledError;
+		} else if (messageType === "exception") {
+			const code = message.headers[":exception-type"].value;
+			const deserializedException = await deserializer({ [code]: message });
+			if (deserializedException.$unknown) {
+				const error = new Error(toUtf8(message.body));
+				error.name = code;
+				throw error;
+			}
+			throw deserializedException[code];
+		} else if (messageType === "event") {
+			const deserialized = await deserializer({ [message.headers[":event-type"].value]: message });
+			if (deserialized.$unknown) return;
+			return deserialized;
+		} else throw Error(`Unrecognizable event type: ${message.headers[":event-type"].value}`);
+	};
+}
+var init_getUnmarshalledStream = __esmMin((() => {}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.29.1/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-serde-universal/EventStreamMarshaller.js
+var EventStreamMarshaller$1;
+var init_EventStreamMarshaller$1 = __esmMin((() => {
+	init_EventStreamCodec();
+	init_MessageDecoderStream();
+	init_MessageEncoderStream();
+	init_SmithyMessageDecoderStream();
+	init_SmithyMessageEncoderStream();
+	init_getChunkedStream();
+	init_getUnmarshalledStream();
+	EventStreamMarshaller$1 = class {
+		eventStreamCodec;
+		utfEncoder;
+		constructor({ utf8Encoder, utf8Decoder }) {
+			this.eventStreamCodec = new EventStreamCodec(utf8Encoder, utf8Decoder);
+			this.utfEncoder = utf8Encoder;
+		}
+		deserialize(body, deserializer) {
+			return new SmithyMessageDecoderStream({
+				messageStream: new MessageDecoderStream({
+					inputStream: getChunkedStream(body),
+					decoder: this.eventStreamCodec
+				}),
+				deserializer: getMessageUnmarshaller(deserializer, this.utfEncoder)
+			});
+		}
+		serialize(inputStream, serializer) {
+			return new MessageEncoderStream({
+				messageStream: new SmithyMessageEncoderStream({
+					inputStream,
+					serializer
+				}),
+				encoder: this.eventStreamCodec,
+				includeEndFrame: true
+			});
+		}
+	};
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.29.1/node_modules/@smithy/core/dist-es/submodules/event-streams/eventstream-serde/EventStreamMarshaller.js
+async function* readableToIterable(readStream) {
+	let streamEnded = false;
+	let generationEnded = false;
+	const records = new Array();
+	readStream.on("error", (err) => {
+		if (!streamEnded) streamEnded = true;
+		if (err) throw err;
+	});
+	readStream.on("data", (data) => {
+		records.push(data);
+	});
+	readStream.on("end", () => {
+		streamEnded = true;
+	});
+	while (!generationEnded) {
+		const value = await new Promise((resolve) => setTimeout(() => resolve(records.shift()), 0));
+		if (value) yield value;
+		generationEnded = streamEnded && records.length === 0;
+	}
+}
+var EventStreamMarshaller, eventStreamSerdeProvider;
+var init_EventStreamMarshaller = __esmMin((() => {
+	init_EventStreamMarshaller$1();
+	EventStreamMarshaller = class {
+		universalMarshaller;
+		constructor({ utf8Encoder, utf8Decoder }) {
+			this.universalMarshaller = new EventStreamMarshaller$1({
+				utf8Decoder,
+				utf8Encoder
+			});
+		}
+		deserialize(body, deserializer) {
+			const bodyIterable = typeof body[Symbol.asyncIterator] === "function" ? body : readableToIterable(body);
+			return this.universalMarshaller.deserialize(bodyIterable, deserializer);
+		}
+		serialize(input, serializer) {
+			return Readable.from(this.universalMarshaller.serialize(input, serializer));
+		}
+	};
+	eventStreamSerdeProvider = (options) => new EventStreamMarshaller(options);
+}));
+//#endregion
+//#region ../../node_modules/.pnpm/@smithy+core@3.29.1/node_modules/@smithy/core/dist-es/submodules/event-streams/EventStreamSerde.js
 var EventStreamSerde;
 var init_EventStreamSerde = __esmMin((() => {
 	init_serde();
@@ -186,7 +744,7 @@ var init_EventStreamSerde = __esmMin((() => {
 				} else if (eventSchema.isUnitSchema()) serializer.write(eventSchema, {});
 				else throw new Error("@smithy/core/event-streams - non-struct member not supported in event stream union.");
 			}
-			const messageSerialization = serializer.flush() ?? new Uint8Array();
+			const messageSerialization = serializer.flush() ?? /* @__PURE__ */ new Uint8Array();
 			return {
 				body: typeof messageSerialization === "string" ? (this.serdeContext?.utf8Decoder ?? fromUtf8)(messageSerialization) : messageSerialization,
 				eventType,
@@ -198,6 +756,15 @@ var init_EventStreamSerde = __esmMin((() => {
 }));
 //#endregion
 __esmMin((() => {
+	init_EventStreamCodec();
+	init_HeaderMarshaller();
+	init_Int64();
+	init_MessageDecoderStream();
+	init_MessageEncoderStream();
+	init_SmithyMessageDecoderStream();
+	init_SmithyMessageEncoderStream();
+	init_EventStreamMarshaller();
+	init_EventStreamMarshaller$1();
 	init_EventStreamSerde();
 }))();
-export { EventStreamSerde };
+export { EventStreamSerde, eventStreamSerdeProvider };

package/dist/generated/artifact_registry.d.ts

@@ -192,63 +192,63 @@ export declare const ArtifactRegistryServiceDefinition: {
         /** Create a repository within the artifact registry */
         readonly createRepository: {
             readonly name: "CreateRepository";
-            readonly requestType: MessageFns<CreateRepositoryRequest>;
+            readonly requestType: typeof CreateRepositoryRequest;
             readonly requestStream: false;
-            readonly responseType: MessageFns<CreateRepositoryResponse>;
+            readonly responseType: typeof CreateRepositoryResponse;
             readonly responseStream: false;
             readonly options: {};
         };
         /** Get repository details including name, URI, and creation time */
         readonly getRepository: {
             readonly name: "GetRepository";
-            readonly requestType: MessageFns<GetRepositoryRequest>;
+            readonly requestType: typeof GetRepositoryRequest;
             readonly requestStream: false;
-            readonly responseType: MessageFns<GetRepositoryResponse>;
+            readonly responseType: typeof GetRepositoryResponse;
             readonly responseStream: false;
             readonly options: {};
         };
         /** Add cross-account access permissions for a repository */
         readonly addCrossAccountAccess: {
             readonly name: "AddCrossAccountAccess";
-            readonly requestType: MessageFns<AddCrossAccountAccessRequest>;
+            readonly requestType: typeof AddCrossAccountAccessRequest;
             readonly requestStream: false;
-            readonly responseType: MessageFns<AddCrossAccountAccessResponse>;
+            readonly responseType: typeof AddCrossAccountAccessResponse;
             readonly responseStream: false;
             readonly options: {};
         };
         /** Remove cross-account access permissions for a repository */
         readonly removeCrossAccountAccess: {
             readonly name: "RemoveCrossAccountAccess";
-            readonly requestType: MessageFns<RemoveCrossAccountAccessRequest>;
+            readonly requestType: typeof RemoveCrossAccountAccessRequest;
             readonly requestStream: false;
-            readonly responseType: MessageFns<RemoveCrossAccountAccessResponse>;
+            readonly responseType: typeof RemoveCrossAccountAccessResponse;
             readonly responseStream: false;
             readonly options: {};
         };
         /** Get the current cross-account access permissions for a repository */
         readonly getCrossAccountAccess: {
             readonly name: "GetCrossAccountAccess";
-            readonly requestType: MessageFns<GetCrossAccountAccessRequest>;
+            readonly requestType: typeof GetCrossAccountAccessRequest;
             readonly requestStream: false;
-            readonly responseType: MessageFns<GetCrossAccountAccessResponse>;
+            readonly responseType: typeof GetCrossAccountAccessResponse;
             readonly responseStream: false;
             readonly options: {};
         };
         /** Generate credentials for accessing a repository */
         readonly generateCredentials: {
             readonly name: "GenerateCredentials";
-            readonly requestType: MessageFns<GenerateCredentialsRequest>;
+            readonly requestType: typeof GenerateCredentialsRequest;
             readonly requestStream: false;
-            readonly responseType: MessageFns<GenerateCredentialsResponse>;
+            readonly responseType: typeof GenerateCredentialsResponse;
             readonly responseStream: false;
             readonly options: {};
         };
         /** Delete a repository and all contained images */
         readonly deleteRepository: {
             readonly name: "DeleteRepository";
-            readonly requestType: MessageFns<DeleteRepositoryRequest>;
+            readonly requestType: typeof DeleteRepositoryRequest;
             readonly requestStream: false;
-            readonly responseType: MessageFns<DeleteRepositoryResponse>;
+            readonly responseType: typeof DeleteRepositoryResponse;
             readonly responseStream: false;
             readonly options: {};
         };