lambda-live-debugger 1.8.2 → 1.8.3

package/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-es/submodules/cbor/CborCodec.js

@@ -0,0 +1,136 @@
+import { NormalizedSchema } from "@smithy/core/schema";
+import { copyDocumentWithTransform, parseEpochTimestamp } from "@smithy/core/serde";
+import { cbor } from "./cbor";
+import { dateToTag } from "./parseCborBody";
+export class CborCodec {
+    createSerializer() {
+        const serializer = new CborShapeSerializer();
+        serializer.setSerdeContext(this.serdeContext);
+        return serializer;
+    }
+    createDeserializer() {
+        const deserializer = new CborShapeDeserializer();
+        deserializer.setSerdeContext(this.serdeContext);
+        return deserializer;
+    }
+    setSerdeContext(serdeContext) {
+        this.serdeContext = serdeContext;
+    }
+}
+export class CborShapeSerializer {
+    setSerdeContext(serdeContext) {
+        this.serdeContext = serdeContext;
+    }
+    write(schema, value) {
+        this.value = copyDocumentWithTransform(value, schema, (_, schemaRef) => {
+            if (_ instanceof Date) {
+                return dateToTag(_);
+            }
+            if (_ instanceof Uint8Array) {
+                return _;
+            }
+            const ns = NormalizedSchema.of(schemaRef);
+            const sparse = !!ns.getMergedTraits().sparse;
+            if (ns.isListSchema() && Array.isArray(_)) {
+                if (!sparse) {
+                    return _.filter((item) => item != null);
+                }
+            }
+            else if (_ && typeof _ === "object") {
+                const members = ns.getMemberSchemas();
+                const isStruct = ns.isStructSchema();
+                if (!sparse || isStruct) {
+                    for (const [k, v] of Object.entries(_)) {
+                        const filteredOutByNonSparse = !sparse && v == null;
+                        const filteredOutByUnrecognizedMember = isStruct && !(k in members);
+                        if (filteredOutByNonSparse || filteredOutByUnrecognizedMember) {
+                            delete _[k];
+                        }
+                    }
+                    return _;
+                }
+            }
+            return _;
+        });
+    }
+    flush() {
+        const buffer = cbor.serialize(this.value);
+        this.value = undefined;
+        return buffer;
+    }
+}
+export class CborShapeDeserializer {
+    setSerdeContext(serdeContext) {
+        this.serdeContext = serdeContext;
+    }
+    read(schema, bytes) {
+        const data = cbor.deserialize(bytes);
+        return this.readValue(schema, data);
+    }
+    readValue(_schema, value) {
+        const ns = NormalizedSchema.of(_schema);
+        const schema = ns.getSchema();
+        if (typeof schema === "number") {
+            if (ns.isTimestampSchema()) {
+                return parseEpochTimestamp(value);
+            }
+            if (ns.isBlobSchema()) {
+                return value;
+            }
+        }
+        if (typeof value === "undefined" ||
+            typeof value === "boolean" ||
+            typeof value === "number" ||
+            typeof value === "string" ||
+            typeof value === "bigint" ||
+            typeof value === "symbol") {
+            return value;
+        }
+        else if (typeof value === "function" || typeof value === "object") {
+            if (value === null) {
+                return null;
+            }
+            if ("byteLength" in value) {
+                return value;
+            }
+            if (value instanceof Date) {
+                return value;
+            }
+            if (ns.isDocumentSchema()) {
+                return value;
+            }
+            if (ns.isListSchema()) {
+                const newArray = [];
+                const memberSchema = ns.getValueSchema();
+                const sparse = ns.isListSchema() && !!ns.getMergedTraits().sparse;
+                for (const item of value) {
+                    newArray.push(this.readValue(memberSchema, item));
+                    if (!sparse && newArray[newArray.length - 1] == null) {
+                        newArray.pop();
+                    }
+                }
+                return newArray;
+            }
+            const newObject = {};
+            if (ns.isMapSchema()) {
+                const sparse = ns.getMergedTraits().sparse;
+                const targetSchema = ns.getValueSchema();
+                for (const key of Object.keys(value)) {
+                    newObject[key] = this.readValue(targetSchema, value[key]);
+                    if (newObject[key] == null && !sparse) {
+                        delete newObject[key];
+                    }
+                }
+            }
+            else if (ns.isStructSchema()) {
+                for (const [key, memberSchema] of ns.structIterator()) {
+                    newObject[key] = this.readValue(memberSchema, value[key]);
+                }
+            }
+            return newObject;
+        }
+        else {
+            return value;
+        }
+    }
+}

package/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-es/submodules/cbor/SmithyRpcV2CborProtocol.js

@@ -0,0 +1,74 @@
+import { RpcProtocol } from "@smithy/core/protocols";
+import { deref, TypeRegistry } from "@smithy/core/schema";
+import { getSmithyContext } from "@smithy/util-middleware";
+import { CborCodec } from "./CborCodec";
+import { loadSmithyRpcV2CborErrorCode } from "./parseCborBody";
+export class SmithyRpcV2CborProtocol extends RpcProtocol {
+    constructor({ defaultNamespace }) {
+        super({ defaultNamespace });
+        this.codec = new CborCodec();
+        this.serializer = this.codec.createSerializer();
+        this.deserializer = this.codec.createDeserializer();
+    }
+    getShapeId() {
+        return "smithy.protocols#rpcv2Cbor";
+    }
+    getPayloadCodec() {
+        return this.codec;
+    }
+    async serializeRequest(operationSchema, input, context) {
+        const request = await super.serializeRequest(operationSchema, input, context);
+        Object.assign(request.headers, {
+            "content-type": "application/cbor",
+            "smithy-protocol": "rpc-v2-cbor",
+            accept: "application/cbor",
+        });
+        if (deref(operationSchema.input) === "unit") {
+            delete request.body;
+            delete request.headers["content-type"];
+        }
+        else {
+            if (!request.body) {
+                this.serializer.write(15, {});
+                request.body = this.serializer.flush();
+            }
+            try {
+                request.headers["content-length"] = String(request.body.byteLength);
+            }
+            catch (e) { }
+        }
+        const { service, operation } = getSmithyContext(context);
+        const path = `/service/${service}/operation/${operation}`;
+        if (request.path.endsWith("/")) {
+            request.path += path.slice(1);
+        }
+        else {
+            request.path += path;
+        }
+        return request;
+    }
+    async deserializeResponse(operationSchema, context, response) {
+        return super.deserializeResponse(operationSchema, context, response);
+    }
+    async handleError(operationSchema, context, response, dataObject, metadata) {
+        const error = loadSmithyRpcV2CborErrorCode(response, dataObject) ?? "Unknown";
+        let namespace = this.options.defaultNamespace;
+        if (error.includes("#")) {
+            [namespace] = error.split("#");
+        }
+        const registry = TypeRegistry.for(namespace);
+        const errorSchema = registry.getSchema(error);
+        if (!errorSchema) {
+            throw new Error("schema not found for " + error);
+        }
+        const message = dataObject.message ?? dataObject.Message ?? "Unknown";
+        const exception = new errorSchema.ctor(message);
+        Object.assign(exception, {
+            $metadata: metadata,
+            $response: response,
+            message,
+            ...dataObject,
+        });
+        throw exception;
+    }
+}

package/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-es/submodules/cbor/index.js

@@ -1,3 +1,5 @@
 export { cbor } from "./cbor";
+export { tag, tagSymbol } from "./cbor-types";
 export * from "./parseCborBody";
-export { tagSymbol, tag } from "./cbor-types";
+export * from "./SmithyRpcV2CborProtocol";
+export * from "./CborCodec";

package/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-es/submodules/cbor/parseCborBody.js

@@ -50,8 +50,9 @@ export const loadSmithyRpcV2CborErrorCode = (output, data) => {
     if (data["__type"] !== undefined) {
         return sanitizeErrorCode(data["__type"]);
     }
-    if (data.code !== undefined) {
-        return sanitizeErrorCode(data.code);
+    const codeKey = Object.keys(data).find((key) => key.toLowerCase() === "code");
+    if (codeKey && data[codeKey] !== undefined) {
+        return sanitizeErrorCode(data[codeKey]);
     }
 };
 export const checkCborResponse = (response) => {

package/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-es/submodules/protocols/HttpBindingProtocol.js

@@ -0,0 +1,183 @@
+import { NormalizedSchema, SCHEMA } from "@smithy/core/schema";
+import { HttpRequest } from "@smithy/protocol-http";
+import { collectBody } from "./collect-stream-body";
+import { extendedEncodeURIComponent } from "./extended-encode-uri-component";
+import { HttpProtocol } from "./HttpProtocol";
+export class HttpBindingProtocol extends HttpProtocol {
+    async serializeRequest(operationSchema, input, context) {
+        const serializer = this.serializer;
+        const query = {};
+        const headers = {};
+        const endpoint = await context.endpoint();
+        const ns = NormalizedSchema.of(operationSchema?.input);
+        const schema = ns.getSchema();
+        let hasNonHttpBindingMember = false;
+        let payload;
+        const request = new HttpRequest({
+            protocol: "",
+            hostname: "",
+            port: undefined,
+            path: "",
+            fragment: undefined,
+            query: query,
+            headers: headers,
+            body: undefined,
+        });
+        if (endpoint) {
+            this.updateServiceEndpoint(request, endpoint);
+            this.setHostPrefix(request, operationSchema, input);
+            const opTraits = NormalizedSchema.translateTraits(operationSchema.traits);
+            if (opTraits.http) {
+                request.method = opTraits.http[0];
+                const [path, search] = opTraits.http[1].split("?");
+                if (request.path == "/") {
+                    request.path = path;
+                }
+                else {
+                    request.path += path;
+                }
+                const traitSearchParams = new URLSearchParams(search ?? "");
+                Object.assign(query, Object.fromEntries(traitSearchParams));
+            }
+        }
+        const _input = {
+            ...input,
+        };
+        for (const memberName of Object.keys(_input)) {
+            const memberNs = ns.getMemberSchema(memberName);
+            if (memberNs === undefined) {
+                continue;
+            }
+            const memberTraits = memberNs.getMergedTraits();
+            const inputMember = _input[memberName];
+            if (memberTraits.httpPayload) {
+                const isStreaming = memberNs.isStreaming();
+                if (isStreaming) {
+                    const isEventStream = memberNs.isStructSchema();
+                    if (isEventStream) {
+                        throw new Error("serialization of event streams is not yet implemented");
+                    }
+                    else {
+                        payload = inputMember;
+                    }
+                }
+                else {
+                    serializer.write(memberNs, inputMember);
+                    payload = serializer.flush();
+                }
+            }
+            else if (memberTraits.httpLabel) {
+                serializer.write(memberNs, inputMember);
+                const replacement = serializer.flush();
+                if (request.path.includes(`{${memberName}+}`)) {
+                    request.path = request.path.replace(`{${memberName}+}`, replacement.split("/").map(extendedEncodeURIComponent).join("/"));
+                }
+                else if (request.path.includes(`{${memberName}}`)) {
+                    request.path = request.path.replace(`{${memberName}}`, extendedEncodeURIComponent(replacement));
+                }
+                delete _input[memberName];
+            }
+            else if (memberTraits.httpHeader) {
+                serializer.write(memberNs, inputMember);
+                headers[memberTraits.httpHeader.toLowerCase()] = String(serializer.flush());
+                delete _input[memberName];
+            }
+            else if (typeof memberTraits.httpPrefixHeaders === "string") {
+                for (const [key, val] of Object.entries(inputMember)) {
+                    const amalgam = memberTraits.httpPrefixHeaders + key;
+                    serializer.write([memberNs.getValueSchema(), { httpHeader: amalgam }], val);
+                    headers[amalgam.toLowerCase()] = serializer.flush();
+                }
+                delete _input[memberName];
+            }
+            else if (memberTraits.httpQuery || memberTraits.httpQueryParams) {
+                this.serializeQuery(memberNs, inputMember, query);
+                delete _input[memberName];
+            }
+            else {
+                hasNonHttpBindingMember = true;
+            }
+        }
+        if (hasNonHttpBindingMember && input) {
+            serializer.write(schema, _input);
+            payload = serializer.flush();
+        }
+        request.headers = headers;
+        request.query = query;
+        request.body = payload;
+        return request;
+    }
+    serializeQuery(ns, data, query) {
+        const serializer = this.serializer;
+        const traits = ns.getMergedTraits();
+        if (traits.httpQueryParams) {
+            for (const [key, val] of Object.entries(data)) {
+                if (!(key in query)) {
+                    this.serializeQuery(NormalizedSchema.of([
+                        ns.getValueSchema(),
+                        {
+                            ...traits,
+                            httpQuery: key,
+                            httpQueryParams: undefined,
+                        },
+                    ]), val, query);
+                }
+            }
+            return;
+        }
+        if (ns.isListSchema()) {
+            const sparse = !!ns.getMergedTraits().sparse;
+            const buffer = [];
+            for (const item of data) {
+                serializer.write([ns.getValueSchema(), traits], item);
+                const serializable = serializer.flush();
+                if (sparse || serializable !== undefined) {
+                    buffer.push(serializable);
+                }
+            }
+            query[traits.httpQuery] = buffer;
+        }
+        else {
+            serializer.write([ns, traits], data);
+            query[traits.httpQuery] = serializer.flush();
+        }
+    }
+    async deserializeResponse(operationSchema, context, response) {
+        const deserializer = this.deserializer;
+        const ns = NormalizedSchema.of(operationSchema.output);
+        const dataObject = {};
+        if (response.statusCode >= 300) {
+            const bytes = await collectBody(response.body, context);
+            if (bytes.byteLength > 0) {
+                Object.assign(dataObject, await deserializer.read(SCHEMA.DOCUMENT, bytes));
+            }
+            await this.handleError(operationSchema, context, response, dataObject, this.deserializeMetadata(response));
+            throw new Error("@smithy/core/protocols - HTTP Protocol error handler failed to throw.");
+        }
+        for (const header in response.headers) {
+            const value = response.headers[header];
+            delete response.headers[header];
+            response.headers[header.toLowerCase()] = value;
+        }
+        const headerBindings = new Set(Object.values(ns.getMemberSchemas())
+            .map((schema) => {
+            return schema.getMergedTraits().httpHeader;
+        })
+            .filter(Boolean));
+        const nonHttpBindingMembers = await this.deserializeHttpMessage(ns, context, response, headerBindings, dataObject);
+        if (nonHttpBindingMembers.length) {
+            const bytes = await collectBody(response.body, context);
+            if (bytes.byteLength > 0) {
+                const dataFromBody = await deserializer.read(ns, bytes);
+                for (const member of nonHttpBindingMembers) {
+                    dataObject[member] = dataFromBody[member];
+                }
+            }
+        }
+        const output = {
+            $metadata: this.deserializeMetadata(response),
+            ...dataObject,
+        };
+        return output;
+    }
+}

package/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-es/submodules/protocols/HttpProtocol.js

@@ -0,0 +1,164 @@
+import { NormalizedSchema, SCHEMA } from "@smithy/core/schema";
+import { splitEvery, splitHeader } from "@smithy/core/serde";
+import { HttpRequest, HttpResponse } from "@smithy/protocol-http";
+import { sdkStreamMixin } from "@smithy/util-stream";
+import { collectBody } from "./collect-stream-body";
+export class HttpProtocol {
+    constructor(options) {
+        this.options = options;
+    }
+    getRequestType() {
+        return HttpRequest;
+    }
+    getResponseType() {
+        return HttpResponse;
+    }
+    setSerdeContext(serdeContext) {
+        this.serdeContext = serdeContext;
+        this.serializer.setSerdeContext(serdeContext);
+        this.deserializer.setSerdeContext(serdeContext);
+        if (this.getPayloadCodec()) {
+            this.getPayloadCodec().setSerdeContext(serdeContext);
+        }
+    }
+    updateServiceEndpoint(request, endpoint) {
+        if ("url" in endpoint) {
+            request.protocol = endpoint.url.protocol;
+            request.hostname = endpoint.url.hostname;
+            request.port = endpoint.url.port ? Number(endpoint.url.port) : undefined;
+            request.path = endpoint.url.pathname;
+            request.fragment = endpoint.url.hash || void 0;
+            request.username = endpoint.url.username || void 0;
+            request.password = endpoint.url.password || void 0;
+            for (const [k, v] of endpoint.url.searchParams.entries()) {
+                if (!request.query) {
+                    request.query = {};
+                }
+                request.query[k] = v;
+            }
+            return request;
+        }
+        else {
+            request.protocol = endpoint.protocol;
+            request.hostname = endpoint.hostname;
+            request.port = endpoint.port ? Number(endpoint.port) : undefined;
+            request.path = endpoint.path;
+            request.query = {
+                ...endpoint.query,
+            };
+            return request;
+        }
+    }
+    setHostPrefix(request, operationSchema, input) {
+        const operationNs = NormalizedSchema.of(operationSchema);
+        const inputNs = NormalizedSchema.of(operationSchema.input);
+        if (operationNs.getMergedTraits().endpoint) {
+            let hostPrefix = operationNs.getMergedTraits().endpoint?.[0];
+            if (typeof hostPrefix === "string") {
+                const hostLabelInputs = [...inputNs.structIterator()].filter(([, member]) => member.getMergedTraits().hostLabel);
+                for (const [name] of hostLabelInputs) {
+                    const replacement = input[name];
+                    if (typeof replacement !== "string") {
+                        throw new Error(`@smithy/core/schema - ${name} in input must be a string as hostLabel.`);
+                    }
+                    hostPrefix = hostPrefix.replace(`{${name}}`, replacement);
+                }
+                request.hostname = hostPrefix + request.hostname;
+            }
+        }
+    }
+    deserializeMetadata(output) {
+        return {
+            httpStatusCode: output.statusCode,
+            requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
+            extendedRequestId: output.headers["x-amz-id-2"],
+            cfId: output.headers["x-amz-cf-id"],
+        };
+    }
+    async deserializeHttpMessage(schema, context, response, headerBindings, dataObject) {
+        const deserializer = this.deserializer;
+        const ns = NormalizedSchema.of(schema);
+        const nonHttpBindingMembers = [];
+        for (const [memberName, memberSchema] of ns.structIterator()) {
+            const memberTraits = memberSchema.getMemberTraits();
+            if (memberTraits.httpPayload) {
+                const isStreaming = memberSchema.isStreaming();
+                if (isStreaming) {
+                    const isEventStream = memberSchema.isStructSchema();
+                    if (isEventStream) {
+                        const context = this.serdeContext;
+                        if (!context.eventStreamMarshaller) {
+                            throw new Error("@smithy/core - HttpProtocol: eventStreamMarshaller missing in serdeContext.");
+                        }
+                        const memberSchemas = memberSchema.getMemberSchemas();
+                        dataObject[memberName] = context.eventStreamMarshaller.deserialize(response.body, async (event) => {
+                            const unionMember = Object.keys(event).find((key) => {
+                                return key !== "__type";
+                            }) ?? "";
+                            if (unionMember in memberSchemas) {
+                                const eventStreamSchema = memberSchemas[unionMember];
+                                return {
+                                    [unionMember]: await deserializer.read(eventStreamSchema, event[unionMember].body),
+                                };
+                            }
+                            else {
+                                return {
+                                    $unknown: event,
+                                };
+                            }
+                        });
+                    }
+                    else {
+                        dataObject[memberName] = sdkStreamMixin(response.body);
+                    }
+                }
+                else if (response.body) {
+                    const bytes = await collectBody(response.body, context);
+                    if (bytes.byteLength > 0) {
+                        dataObject[memberName] = await deserializer.read(memberSchema, bytes);
+                    }
+                }
+            }
+            else if (memberTraits.httpHeader) {
+                const key = String(memberTraits.httpHeader).toLowerCase();
+                const value = response.headers[key];
+                if (null != value) {
+                    if (memberSchema.isListSchema()) {
+                        const headerListValueSchema = memberSchema.getValueSchema();
+                        let sections;
+                        if (headerListValueSchema.isTimestampSchema() &&
+                            headerListValueSchema.getSchema() === SCHEMA.TIMESTAMP_DEFAULT) {
+                            sections = splitEvery(value, ",", 2);
+                        }
+                        else {
+                            sections = splitHeader(value);
+                        }
+                        const list = [];
+                        for (const section of sections) {
+                            list.push(await deserializer.read([headerListValueSchema, { httpHeader: key }], section.trim()));
+                        }
+                        dataObject[memberName] = list;
+                    }
+                    else {
+                        dataObject[memberName] = await deserializer.read(memberSchema, value);
+                    }
+                }
+            }
+            else if (memberTraits.httpPrefixHeaders !== undefined) {
+                dataObject[memberName] = {};
+                for (const [header, value] of Object.entries(response.headers)) {
+                    if (!headerBindings.has(header) && header.startsWith(memberTraits.httpPrefixHeaders)) {
+                        dataObject[memberName][header.slice(memberTraits.httpPrefixHeaders.length)] = await deserializer.read([memberSchema.getValueSchema(), { httpHeader: header }], value);
+                    }
+                }
+            }
+            else if (memberTraits.httpResponseCode) {
+                dataObject[memberName] = response.statusCode;
+            }
+            else {
+                nonHttpBindingMembers.push(memberName);
+            }
+        }
+        return nonHttpBindingMembers;
+    }
+}

package/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-es/submodules/protocols/RpcProtocol.js

@@ -0,0 +1,68 @@
+import { NormalizedSchema, SCHEMA } from "@smithy/core/schema";
+import { HttpRequest } from "@smithy/protocol-http";
+import { collectBody } from "./collect-stream-body";
+import { HttpProtocol } from "./HttpProtocol";
+export class RpcProtocol extends HttpProtocol {
+    async serializeRequest(operationSchema, input, context) {
+        const serializer = this.serializer;
+        const query = {};
+        const headers = {};
+        const endpoint = await context.endpoint();
+        const ns = NormalizedSchema.of(operationSchema?.input);
+        const schema = ns.getSchema();
+        let payload;
+        const request = new HttpRequest({
+            protocol: "",
+            hostname: "",
+            port: undefined,
+            path: "/",
+            fragment: undefined,
+            query: query,
+            headers: headers,
+            body: undefined,
+        });
+        if (endpoint) {
+            this.updateServiceEndpoint(request, endpoint);
+            this.setHostPrefix(request, operationSchema, input);
+        }
+        const _input = {
+            ...input,
+        };
+        if (input) {
+            serializer.write(schema, _input);
+            payload = serializer.flush();
+        }
+        request.headers = headers;
+        request.query = query;
+        request.body = payload;
+        request.method = "POST";
+        return request;
+    }
+    async deserializeResponse(operationSchema, context, response) {
+        const deserializer = this.deserializer;
+        const ns = NormalizedSchema.of(operationSchema.output);
+        const dataObject = {};
+        if (response.statusCode >= 300) {
+            const bytes = await collectBody(response.body, context);
+            if (bytes.byteLength > 0) {
+                Object.assign(dataObject, await deserializer.read(SCHEMA.DOCUMENT, bytes));
+            }
+            await this.handleError(operationSchema, context, response, dataObject, this.deserializeMetadata(response));
+            throw new Error("@smithy/core/protocols - RPC Protocol error handler failed to throw.");
+        }
+        for (const header in response.headers) {
+            const value = response.headers[header];
+            delete response.headers[header];
+            response.headers[header.toLowerCase()] = value;
+        }
+        const bytes = await collectBody(response.body, context);
+        if (bytes.byteLength > 0) {
+            Object.assign(dataObject, await deserializer.read(ns, bytes));
+        }
+        const output = {
+            $metadata: this.deserializeMetadata(response),
+            ...dataObject,
+        };
+        return output;
+    }
+}

package/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-es/submodules/protocols/index.js

@@ -1,4 +1,11 @@
 export * from "./collect-stream-body";
 export * from "./extended-encode-uri-component";
+export * from "./HttpBindingProtocol";
+export * from "./RpcProtocol";
 export * from "./requestBuilder";
 export * from "./resolve-path";
+export * from "./serde/FromStringShapeDeserializer";
+export * from "./serde/HttpInterceptingShapeDeserializer";
+export * from "./serde/HttpInterceptingShapeSerializer";
+export * from "./serde/ToStringShapeSerializer";
+export * from "./serde/determineTimestampFormat";