@hasna/domains
Version:
Domain portfolio, registrar, marketplace, and DNS management for AI agents — CLI + MCP + HTTP API + SDK, shared account API and PostgreSQL
40,392 lines • 1.41 MB
JavaScript
#!/usr/bin/env bun
// @bun
var __create = Object.create;
var __getProtoOf = Object.getPrototypeOf;
var __defProp = Object.defineProperty;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
function __accessProp(key) {
return this[key];
}
var __toESMCache_node;
var __toESMCache_esm;
var __toESM = (mod, isNodeMode, target) => {
var canCache = mod != null && typeof mod === "object";
if (canCache) {
var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
var cached = cache.get(mod);
if (cached)
return cached;
}
target = mod != null ? __create(__getProtoOf(mod)) : {};
const to = isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
if (mod && typeof mod === "object" || typeof mod === "function") {
for (let key of __getOwnPropNames(mod))
if (!__hasOwnProp.call(to, key))
__defProp(to, key, {
get: __accessProp.bind(mod, key),
enumerable: true
});
}
if (canCache)
cache.set(mod, to);
return to;
};
var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
var __returnValue = (v) => v;
function __exportSetter(name, newValue) {
this[name] = __returnValue.bind(null, newValue);
}
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, {
get: all[name],
enumerable: true,
configurable: true,
set: __exportSetter.bind(all, name)
});
};
var __esm = (fn, res, err) => () => {
if (fn)
try {
res = fn(fn = 0);
} catch (e) {
err = [e];
}
if (err)
throw err[0];
return res;
};
var __require = import.meta.require;
// ../../node_modules/.bun/@smithy+types@4.18.0/node_modules/@smithy/types/dist-cjs/index.js
var require_dist_cjs = __commonJS(function(exports) {
var HttpAuthLocation;
(function(HttpAuthLocation) {
HttpAuthLocation["HEADER"] = "header";
HttpAuthLocation["QUERY"] = "query";
})(HttpAuthLocation || (HttpAuthLocation = {}));
var HttpApiKeyAuthLocation;
(function(HttpApiKeyAuthLocation) {
HttpApiKeyAuthLocation["HEADER"] = "header";
HttpApiKeyAuthLocation["QUERY"] = "query";
})(HttpApiKeyAuthLocation || (HttpApiKeyAuthLocation = {}));
var EndpointURLScheme;
(function(EndpointURLScheme) {
EndpointURLScheme["HTTP"] = "http";
EndpointURLScheme["HTTPS"] = "https";
})(EndpointURLScheme || (EndpointURLScheme = {}));
var AlgorithmId;
(function(AlgorithmId) {
AlgorithmId["MD5"] = "md5";
AlgorithmId["CRC32"] = "crc32";
AlgorithmId["CRC32C"] = "crc32c";
AlgorithmId["SHA1"] = "sha1";
AlgorithmId["SHA256"] = "sha256";
})(AlgorithmId || (AlgorithmId = {}));
var getChecksumConfiguration = (runtimeConfig) => {
const checksumAlgorithms = [];
if (runtimeConfig.sha256 !== undefined) {
checksumAlgorithms.push({
algorithmId: () => AlgorithmId.SHA256,
checksumConstructor: () => runtimeConfig.sha256
});
}
if (runtimeConfig.md5 != null) {
checksumAlgorithms.push({
algorithmId: () => AlgorithmId.MD5,
checksumConstructor: () => runtimeConfig.md5
});
}
return {
addChecksumAlgorithm(algo) {
checksumAlgorithms.push(algo);
},
checksumAlgorithms() {
return checksumAlgorithms;
}
};
};
var resolveChecksumRuntimeConfig = (clientConfig) => {
const runtimeConfig = {};
clientConfig.checksumAlgorithms().forEach((checksumAlgorithm) => {
runtimeConfig[checksumAlgorithm.algorithmId()] = checksumAlgorithm.checksumConstructor();
});
return runtimeConfig;
};
var getDefaultClientConfiguration = (runtimeConfig) => {
return getChecksumConfiguration(runtimeConfig);
};
var resolveDefaultRuntimeConfig = (config) => {
return resolveChecksumRuntimeConfig(config);
};
var FieldPosition;
(function(FieldPosition) {
FieldPosition[FieldPosition["HEADER"] = 0] = "HEADER";
FieldPosition[FieldPosition["TRAILER"] = 1] = "TRAILER";
})(FieldPosition || (FieldPosition = {}));
var SMITHY_CONTEXT_KEY = "__smithy_context";
var IniSectionType;
(function(IniSectionType) {
IniSectionType["PROFILE"] = "profile";
IniSectionType["SSO_SESSION"] = "sso-session";
IniSectionType["SERVICES"] = "services";
})(IniSectionType || (IniSectionType = {}));
var RequestHandlerProtocol;
(function(RequestHandlerProtocol) {
RequestHandlerProtocol["HTTP_0_9"] = "http/0.9";
RequestHandlerProtocol["HTTP_1_0"] = "http/1.0";
RequestHandlerProtocol["TDS_8_0"] = "tds/8.0";
})(RequestHandlerProtocol || (RequestHandlerProtocol = {}));
exports.AlgorithmId = AlgorithmId;
exports.EndpointURLScheme = EndpointURLScheme;
exports.FieldPosition = FieldPosition;
exports.HttpApiKeyAuthLocation = HttpApiKeyAuthLocation;
exports.HttpAuthLocation = HttpAuthLocation;
exports.IniSectionType = IniSectionType;
exports.RequestHandlerProtocol = RequestHandlerProtocol;
exports.SMITHY_CONTEXT_KEY = SMITHY_CONTEXT_KEY;
exports.getDefaultClientConfiguration = getDefaultClientConfiguration;
exports.resolveDefaultRuntimeConfig = resolveDefaultRuntimeConfig;
});
// ../../node_modules/.bun/@smithy+core@3.33.3/node_modules/@smithy/core/dist-cjs/submodules/transport/index.js
var require_transport = __commonJS(function(exports) {
var { SMITHY_CONTEXT_KEY } = require_dist_cjs();
var getSmithyContext = (context) => context[SMITHY_CONTEXT_KEY] || (context[SMITHY_CONTEXT_KEY] = {});
function hasOwn(o, k) {
return Object.prototype.hasOwnProperty.call(o, k);
}
class HttpRequest {
method;
protocol;
hostname;
port;
path;
query;
headers;
username;
password;
fragment;
body;
constructor(options) {
this.method = options.method || "GET";
this.hostname = options.hostname || "localhost";
this.port = options.port;
this.query = options.query || {};
this.headers = options.headers || {};
this.body = options.body;
this.protocol = options.protocol ? options.protocol.slice(-1) !== ":" ? `${options.protocol}:` : options.protocol : "https:";
this.path = options.path ? options.path.charAt(0) !== "/" ? `/${options.path}` : options.path : "/";
this.username = options.username;
this.password = options.password;
this.fragment = options.fragment;
}
static clone(request) {
const cloned = new HttpRequest({
...request,
headers: { ...request.headers }
});
if (cloned.query) {
cloned.query = cloneQuery(cloned.query);
}
return cloned;
}
static isInstance(request) {
if (!request) {
return false;
}
const req = request;
return "method" in req && "protocol" in req && "hostname" in req && "path" in req && typeof req["query"] === "object" && typeof req["headers"] === "object";
}
clone() {
return HttpRequest.clone(this);
}
}
function cloneQuery(query) {
return Object.keys(query).reduce((carry, paramName) => {
const param = query[paramName];
return {
...carry,
[paramName]: Array.isArray(param) ? [...param] : param
};
}, {});
}
class HttpResponse {
statusCode;
reason;
headers;
body;
constructor(options) {
this.statusCode = options.statusCode;
this.reason = options.reason;
this.headers = options.headers || {};
this.body = options.body;
}
static isInstance(response) {
if (!response)
return false;
const resp = response;
return typeof resp.statusCode === "number" && typeof resp.headers === "object";
}
}
var VALID_HOST_LABEL_REGEX = new RegExp(`^(?!.*-$)(?!-)[a-zA-Z0-9-]{1,63}$`);
var isValidHostLabel = (value, allowSubDomains = false) => {
if (!allowSubDomains) {
return VALID_HOST_LABEL_REGEX.test(value);
}
const labels = value.split(".");
for (const label of labels) {
if (!isValidHostLabel(label)) {
return false;
}
}
return true;
};
function isValidHostname(hostname) {
const hostPattern = /^[a-z0-9][a-z0-9.-]*[a-z0-9]$/;
return hostPattern.test(hostname);
}
var normalizeProvider = (input) => {
if (typeof input === "function")
return input;
const promisified = Promise.resolve(input);
return () => promisified;
};
function parseQueryString(querystring) {
const query = {};
querystring = querystring.replace(/^\?/, "");
if (querystring) {
for (const pair of querystring.split("&")) {
let [key, value = null] = pair.split("=");
key = decodeURIComponent(key);
if (value) {
value = decodeURIComponent(value);
}
if (!(key in query)) {
query[key] = value;
} else if (Array.isArray(query[key])) {
query[key].push(value);
} else {
query[key] = [query[key], value];
}
}
}
return query;
}
var parseUrl = (url) => {
if (typeof url === "string") {
return parseUrl(new URL(url));
}
const { hostname, pathname, port, protocol, search } = url;
let query;
if (search) {
query = parseQueryString(search);
}
return {
hostname,
port: port ? parseInt(port) : undefined,
protocol,
path: pathname,
query
};
};
var toEndpointV1 = (endpoint) => {
if (typeof endpoint === "object") {
if ("url" in endpoint) {
const v1Endpoint = parseUrl(endpoint.url);
if (endpoint.headers) {
v1Endpoint.headers = {};
for (const name in endpoint.headers) {
if (!hasOwn(endpoint.headers, name))
continue;
v1Endpoint.headers[name.toLowerCase()] = endpoint.headers[name].join(", ");
}
}
return v1Endpoint;
}
return endpoint;
}
return parseUrl(endpoint);
};
exports.HttpRequest = HttpRequest;
exports.HttpResponse = HttpResponse;
exports.getSmithyContext = getSmithyContext;
exports.hasOwn = hasOwn;
exports.isValidHostLabel = isValidHostLabel;
exports.isValidHostname = isValidHostname;
exports.normalizeProvider = normalizeProvider;
exports.parseQueryString = parseQueryString;
exports.parseUrl = parseUrl;
exports.toEndpointV1 = toEndpointV1;
});
// ../../node_modules/.bun/@smithy+core@3.33.3/node_modules/@smithy/core/dist-cjs/submodules/schema/index.js
var require_schema = __commonJS(function(exports) {
var { getSmithyContext, HttpResponse, toEndpointV1 } = require_transport();
var deref = (schemaRef) => {
if (typeof schemaRef === "function") {
return schemaRef();
}
return schemaRef;
};
var operation = (namespace, name, traits, input, output) => ({
name,
namespace,
traits,
input,
output
});
var schemaDeserializationMiddleware = (config) => (next, context) => async (args) => {
const { response } = await next(args);
const { operationSchema } = getSmithyContext(context);
const [, ns, n, t, i, o] = operationSchema ?? [];
try {
const parsed = await config.protocol.deserializeResponse(operation(ns, n, t, i, o), {
...config,
...context
}, response);
return {
response,
output: parsed
};
} catch (error) {
Object.defineProperty(error, "$response", {
value: response,
enumerable: false,
writable: false,
configurable: false
});
if (!("$metadata" in error)) {
const hint = `Deserialization error: to see the raw response, inspect the hidden field {error}.$response on this object.`;
try {
error.message += `
` + hint;
} catch (ignored) {
if (!context.logger || context.logger?.constructor?.name === "NoOpLogger") {
console.warn(hint);
} else {
context.logger?.warn?.(hint);
}
}
if (typeof error.$responseBodyText !== "undefined") {
if (error.$response) {
error.$response.body = error.$responseBodyText;
}
}
try {
if (HttpResponse.isInstance(response)) {
const { headers = {}, statusCode } = response;
const headerEntries = Object.entries(headers);
error.$metadata = {
httpStatusCode: statusCode,
requestId: findHeader(/^x-[\w-]+-request-?id$/, headerEntries),
extendedRequestId: findHeader(/^x-[\w-]+-id-2$/, headerEntries),
cfId: findHeader(/^x-[\w-]+-cf-id$/, headerEntries)
};
}
} catch (ignored) {}
}
throw error;
}
};
var findHeader = (pattern, headers) => {
return (headers.find(([k]) => {
return k.match(pattern);
}) || [undefined, undefined])[1];
};
var schemaSerializationMiddleware = (config) => (next, context) => async (args) => {
const { operationSchema } = getSmithyContext(context);
const [, ns, n, t, i, o] = operationSchema ?? [];
const endpoint = context.endpointV2 ? async () => toEndpointV1(context.endpointV2) : config.endpoint;
const request = await config.protocol.serializeRequest(operation(ns, n, t, i, o), args.input, {
...config,
...context,
endpoint
});
return next({
...args,
request
});
};
var deserializerMiddlewareOption = {
name: "deserializerMiddleware",
step: "deserialize",
tags: ["DESERIALIZER"],
override: true
};
var serializerMiddlewareOption = {
name: "serializerMiddleware",
step: "serialize",
tags: ["SERIALIZER"],
override: true
};
function getSchemaSerdePlugin(config) {
return {
applyToStack: (commandStack) => {
commandStack.add(schemaSerializationMiddleware(config), serializerMiddlewareOption);
commandStack.add(schemaDeserializationMiddleware(config), deserializerMiddlewareOption);
config.protocol.setSerdeContext(config);
}
};
}
class Schema {
name;
namespace;
traits;
static assign(instance, values) {
const schema = Object.assign(instance, values);
return schema;
}
static [Symbol.hasInstance](lhs) {
const isPrototype = this.prototype.isPrototypeOf(lhs);
if (!isPrototype && typeof lhs === "object" && lhs !== null) {
const list = lhs;
return list.symbol === this.symbol;
}
return isPrototype;
}
getName() {
return this.namespace + "#" + this.name;
}
}
class ListSchema extends Schema {
static symbol = Symbol.for("@smithy/lis");
valueSchema;
symbol = ListSchema.symbol;
}
var list = (namespace, name, traits, valueSchema) => Schema.assign(new ListSchema, {
name,
namespace,
traits,
valueSchema
});
class MapSchema extends Schema {
static symbol = Symbol.for("@smithy/map");
keySchema;
valueSchema;
symbol = MapSchema.symbol;
}
var map = (namespace, name, traits, keySchema, valueSchema) => Schema.assign(new MapSchema, {
name,
namespace,
traits,
keySchema,
valueSchema
});
class OperationSchema extends Schema {
static symbol = Symbol.for("@smithy/ope");
input;
output;
symbol = OperationSchema.symbol;
}
var op = (namespace, name, traits, input, output) => Schema.assign(new OperationSchema, {
name,
namespace,
traits,
input,
output
});
class StructureSchema extends Schema {
static symbol = Symbol.for("@smithy/str");
memberNames;
memberList;
symbol = StructureSchema.symbol;
}
var struct = (namespace, name, traits, memberNames, memberList) => Schema.assign(new StructureSchema, {
name,
namespace,
traits,
memberNames,
memberList
});
class ErrorSchema extends StructureSchema {
static symbol = Symbol.for("@smithy/err");
ctor;
symbol = ErrorSchema.symbol;
}
var error = (namespace, name, traits, memberNames, memberList, _ctor) => Schema.assign(new ErrorSchema, {
name,
namespace,
traits,
memberNames,
memberList,
ctor: null
});
var traitsCache = [];
function translateTraits(indicator) {
if (typeof indicator === "object") {
return indicator;
}
indicator = indicator | 0;
if (traitsCache[indicator]) {
return traitsCache[indicator];
}
const traits = {};
let i = 0;
for (const trait of [
"httpLabel",
"idempotent",
"idempotencyToken",
"sensitive",
"httpPayload",
"httpResponseCode",
"httpQueryParams"
]) {
if ((indicator >> i++ & 1) === 1) {
traits[trait] = 1;
}
}
return traitsCache[indicator] = traits;
}
var anno = {
it: Symbol.for("@smithy/nor-struct-it"),
ns: Symbol.for("@smithy/ns")
};
var simpleSchemaCacheN = [];
var simpleSchemaCacheS = {};
class NormalizedSchema {
ref;
memberName;
static symbol = Symbol.for("@smithy/nor");
symbol = NormalizedSchema.symbol;
name;
schema;
_isMemberSchema;
traits;
memberTraits;
normalizedTraits;
constructor(ref, memberName) {
this.ref = ref;
this.memberName = memberName;
const traitStack = [];
let _ref = ref;
let schema = ref;
this._isMemberSchema = false;
while (isMemberSchema(_ref)) {
traitStack.push(_ref[1]);
_ref = _ref[0];
schema = deref(_ref);
this._isMemberSchema = true;
}
if (traitStack.length > 0) {
this.memberTraits = {};
for (let i = traitStack.length - 1;i >= 0; --i) {
const traitSet = traitStack[i];
Object.assign(this.memberTraits, translateTraits(traitSet));
}
} else {
this.memberTraits = 0;
}
if (schema instanceof NormalizedSchema) {
const computedMemberTraits = this.memberTraits;
Object.assign(this, schema);
this.memberTraits = Object.assign({}, computedMemberTraits, schema.getMemberTraits(), this.getMemberTraits());
this.normalizedTraits = undefined;
this.memberName = memberName ?? schema.memberName;
return;
}
this.schema = deref(schema);
if (isStaticSchema(this.schema)) {
this.name = `${this.schema[1]}#${this.schema[2]}`;
this.traits = this.schema[3];
} else {
this.name = this.memberName ?? String(schema);
this.traits = 0;
}
if (this._isMemberSchema && !memberName) {
throw new Error(`@smithy/core/schema - NormalizedSchema member init ${this.getName(true)} missing member name.`);
}
}
static [Symbol.hasInstance](lhs) {
const isPrototype = this.prototype.isPrototypeOf(lhs);
if (!isPrototype && typeof lhs === "object" && lhs !== null) {
const ns = lhs;
return ns.symbol === this.symbol;
}
return isPrototype;
}
static of(ref) {
const keyAble = typeof ref === "function" || typeof ref === "object" && ref !== null;
if (typeof ref === "number") {
if (simpleSchemaCacheN[ref]) {
return simpleSchemaCacheN[ref];
}
} else if (typeof ref === "string") {
if (simpleSchemaCacheS[ref]) {
return simpleSchemaCacheS[ref];
}
} else if (keyAble) {
if (ref[anno.ns]) {
return ref[anno.ns];
}
}
const sc = deref(ref);
if (sc instanceof NormalizedSchema) {
return sc;
}
if (isMemberSchema(sc)) {
const [ns, traits] = sc;
if (ns instanceof NormalizedSchema) {
Object.assign(ns.getMergedTraits(), translateTraits(traits));
return ns;
}
throw new Error(`@smithy/core/schema - may not init unwrapped member schema=${JSON.stringify(ref, null, 2)}.`);
}
const ns = new NormalizedSchema(sc);
if (keyAble) {
return ref[anno.ns] = ns;
}
if (typeof sc === "string") {
return simpleSchemaCacheS[sc] = ns;
}
if (typeof sc === "number") {
return simpleSchemaCacheN[sc] = ns;
}
return ns;
}
getSchema() {
const sc = this.schema;
if (Array.isArray(sc) && sc[0] === 0) {
return sc[4];
}
return sc;
}
getName(withNamespace = false) {
const { name } = this;
const short = !withNamespace && name && name.includes("#");
return short ? name.split("#")[1] : name || undefined;
}
getMemberName() {
return this.memberName;
}
isMemberSchema() {
return this._isMemberSchema;
}
isListSchema() {
const sc = this.getSchema();
return typeof sc === "number" ? sc >= 64 && sc < 128 : sc[0] === 1;
}
isMapSchema() {
const sc = this.getSchema();
return typeof sc === "number" ? sc >= 128 && sc <= 255 : sc[0] === 2;
}
isStructSchema() {
const sc = this.getSchema();
if (typeof sc !== "object") {
return false;
}
const id = sc[0];
return id === 3 || id === -3 || id === 4;
}
isUnionSchema() {
const sc = this.getSchema();
if (typeof sc !== "object") {
return false;
}
return sc[0] === 4;
}
isBlobSchema() {
const sc = this.getSchema();
return sc === 21 || sc === 42;
}
isTimestampSchema() {
const sc = this.getSchema();
return typeof sc === "number" && sc >= 4 && sc <= 7;
}
isUnitSchema() {
return this.getSchema() === "unit";
}
isDocumentSchema() {
return this.getSchema() === 15;
}
isStringSchema() {
return this.getSchema() === 0;
}
isBooleanSchema() {
return this.getSchema() === 2;
}
isNumericSchema() {
return this.getSchema() === 1;
}
isBigIntegerSchema() {
return this.getSchema() === 17;
}
isBigDecimalSchema() {
return this.getSchema() === 19;
}
isStreaming() {
const { streaming } = this.getMergedTraits();
return !!streaming || this.getSchema() === 42;
}
isIdempotencyToken() {
return !!this.getMergedTraits().idempotencyToken;
}
getMergedTraits() {
return this.normalizedTraits ?? (this.normalizedTraits = {
...this.getOwnTraits(),
...this.getMemberTraits()
});
}
getMemberTraits() {
return translateTraits(this.memberTraits);
}
getOwnTraits() {
return translateTraits(this.traits);
}
getKeySchema() {
const [isDoc, isMap] = [this.isDocumentSchema(), this.isMapSchema()];
if (!isDoc && !isMap) {
throw new Error(`@smithy/core/schema - cannot get key for non-map: ${this.getName(true)}`);
}
const schema = this.getSchema();
const memberSchema = isDoc ? 15 : schema[4] ?? 0;
return member([memberSchema, 0], "key");
}
getValueSchema() {
const sc = this.getSchema();
const [isDoc, isMap, isList] = [this.isDocumentSchema(), this.isMapSchema(), this.isListSchema()];
const memberSchema = typeof sc === "number" ? 63 & sc : sc && typeof sc === "object" && (isMap || isList) ? sc[3 + sc[0]] : isDoc ? 15 : undefined;
if (memberSchema != null) {
return member([memberSchema, 0], isMap ? "value" : "member");
}
throw new Error(`@smithy/core/schema - ${this.getName(true)} has no value member.`);
}
getMemberSchema(memberName) {
const struct = this.getSchema();
if (this.isStructSchema() && struct[4].includes(memberName)) {
const i = struct[4].indexOf(memberName);
const memberSchema = struct[5][i];
return member(isMemberSchema(memberSchema) ? memberSchema : [memberSchema, 0], memberName);
}
if (this.isDocumentSchema()) {
return member([15, 0], memberName);
}
throw new Error(`@smithy/core/schema - ${this.getName(true)} has no member=${memberName}.`);
}
getMemberSchemas() {
const buffer = {};
try {
for (const [k, v] of this.structIterator()) {
buffer[k] = v;
}
} catch (ignored) {}
return buffer;
}
getEventStreamMember() {
if (this.isStructSchema()) {
for (const [memberName, memberSchema] of this.structIterator()) {
if (memberSchema.isStreaming() && memberSchema.isStructSchema()) {
return memberName;
}
}
}
return "";
}
*structIterator() {
if (this.isUnitSchema()) {
return;
}
if (!this.isStructSchema()) {
throw new Error("@smithy/core/schema - cannot iterate non-struct schema.");
}
const struct = this.getSchema();
const z = struct[4].length;
let it = struct[anno.it];
if (it && z === it.length) {
yield* it;
return;
}
it = Array(z);
for (let i = 0;i < z; ++i) {
const k = struct[4][i];
const v = member([struct[5][i], 0], k);
yield it[i] = [k, v];
}
struct[anno.it] = it;
}
}
function member(memberSchema, memberName) {
if (memberSchema instanceof NormalizedSchema) {
return Object.assign(memberSchema, {
memberName,
_isMemberSchema: true
});
}
const internalCtorAccess = NormalizedSchema;
return new internalCtorAccess(memberSchema, memberName);
}
var isMemberSchema = (sc) => Array.isArray(sc) && sc.length === 2;
var isStaticSchema = (sc) => Array.isArray(sc) && sc.length >= 5;
class SimpleSchema extends Schema {
static symbol = Symbol.for("@smithy/sim");
schemaRef;
symbol = SimpleSchema.symbol;
}
var sim = (namespace, name, schemaRef, traits) => Schema.assign(new SimpleSchema, {
name,
namespace,
traits,
schemaRef
});
var simAdapter = (namespace, name, traits, schemaRef) => Schema.assign(new SimpleSchema, {
name,
namespace,
traits,
schemaRef
});
var SCHEMA = {
BLOB: 21,
STREAMING_BLOB: 42,
BOOLEAN: 2,
STRING: 0,
NUMERIC: 1,
BIG_INTEGER: 17,
BIG_DECIMAL: 19,
DOCUMENT: 15,
TIMESTAMP_DEFAULT: 4,
TIMESTAMP_DATE_TIME: 5,
TIMESTAMP_HTTP_DATE: 6,
TIMESTAMP_EPOCH_SECONDS: 7,
LIST_MODIFIER: 64,
MAP_MODIFIER: 128
};
class TypeRegistry {
namespace;
schemas;
exceptions;
static registries = new Map;
constructor(namespace, schemas = new Map, exceptions = new Map) {
this.namespace = namespace;
this.schemas = schemas;
this.exceptions = exceptions;
}
static for(namespace) {
if (!TypeRegistry.registries.has(namespace)) {
TypeRegistry.registries.set(namespace, new TypeRegistry(namespace));
}
return TypeRegistry.registries.get(namespace);
}
copyFrom(other) {
const { schemas, exceptions } = this;
for (const [k, v] of other.schemas) {
if (!schemas.has(k)) {
schemas.set(k, v);
}
}
for (const [k, v] of other.exceptions) {
if (!exceptions.has(k)) {
exceptions.set(k, v);
}
}
}
register(shapeId, schema) {
const qualifiedName = this.normalizeShapeId(shapeId);
for (const r of [this, TypeRegistry.for(qualifiedName.split("#")[0])]) {
r.schemas.set(qualifiedName, schema);
}
}
getSchema(shapeId) {
const id = this.normalizeShapeId(shapeId);
if (!this.schemas.has(id)) {
if (!shapeId.includes("#")) {
const suffix = "#" + shapeId;
const candidates = [];
for (const [shapeId, schema] of this.schemas.entries()) {
if (shapeId.endsWith(suffix)) {
candidates.push(schema);
}
}
if (candidates.length === 1) {
return candidates[0];
}
}
throw new Error(`@smithy/core/schema - schema not found for ${id}`);
}
return this.schemas.get(id);
}
registerError(es, ctor) {
const $error2 = es;
const ns = $error2[1];
for (const r of [this, TypeRegistry.for(ns)]) {
r.schemas.set(ns + "#" + $error2[2], $error2);
r.exceptions.set($error2, ctor);
}
}
getErrorCtor(es) {
const $error2 = es;
if (this.exceptions.has($error2)) {
return this.exceptions.get($error2);
}
const registry = TypeRegistry.for($error2[1]);
return registry.exceptions.get($error2);
}
getBaseException() {
for (const exceptionKey of this.exceptions.keys()) {
if (Array.isArray(exceptionKey)) {
const [, ns, name] = exceptionKey;
const id = ns + "#" + name;
if (id.startsWith("smithy.ts.sdk.synthetic.") && id.endsWith("ServiceException")) {
return exceptionKey;
}
}
}
return;
}
find(predicate) {
for (const schema of this.schemas.values()) {
if (predicate(schema)) {
return schema;
}
}
return;
}
clear() {
this.schemas.clear();
this.exceptions.clear();
}
normalizeShapeId(shapeId) {
if (shapeId.includes("#")) {
return shapeId;
}
return this.namespace + "#" + shapeId;
}
}
exports.ErrorSchema = ErrorSchema;
exports.ListSchema = ListSchema;
exports.MapSchema = MapSchema;
exports.NormalizedSchema = NormalizedSchema;
exports.OperationSchema = OperationSchema;
exports.SCHEMA = SCHEMA;
exports.Schema = Schema;
exports.SimpleSchema = SimpleSchema;
exports.StructureSchema = StructureSchema;
exports.TypeRegistry = TypeRegistry;
exports.deref = deref;
exports.deserializerMiddlewareOption = deserializerMiddlewareOption;
exports.error = error;
exports.getSchemaSerdePlugin = getSchemaSerdePlugin;
exports.isStaticSchema = isStaticSchema;
exports.list = list;
exports.map = map;
exports.op = op;
exports.operation = operation;
exports.serializerMiddlewareOption = serializerMiddlewareOption;
exports.sim = sim;
exports.simAdapter = simAdapter;
exports.simpleSchemaCacheN = simpleSchemaCacheN;
exports.simpleSchemaCacheS = simpleSchemaCacheS;
exports.struct = struct;
exports.traitsCache = traitsCache;
exports.translateTraits = translateTraits;
});
// ../../node_modules/.bun/@smithy+core@3.33.3/node_modules/@smithy/core/dist-cjs/submodules/client/index.js
var require_client = __commonJS(function(exports) {
var { hasOwn } = require_transport();
var { getSmithyContext, normalizeProvider } = require_transport();
exports.getSmithyContext = getSmithyContext;
exports.normalizeProvider = normalizeProvider;
var { SMITHY_CONTEXT_KEY, AlgorithmId } = require_dist_cjs();
exports.AlgorithmId = AlgorithmId;
var { NormalizedSchema } = require_schema();
var getAllAliases = (name, aliases) => {
const _aliases = [];
if (name) {
_aliases.push(name);
}
if (aliases) {
for (const alias of aliases) {
_aliases.push(alias);
}
}
return _aliases;
};
var getMiddlewareNameWithAliases = (name, aliases) => {
return `${name || "anonymous"}${aliases && aliases.length > 0 ? ` (a.k.a. ${aliases.join(",")})` : ""}`;
};
var constructStack = () => {
let absoluteEntries = [];
let relativeEntries = [];
let identifyOnResolve = false;
const entriesNameSet = new Set;
const sort = (entries) => entries.sort((a, b) => stepWeights[b.step] - stepWeights[a.step] || priorityWeights[b.priority || "normal"] - priorityWeights[a.priority || "normal"]);
const removeByName = (toRemove) => {
let isRemoved = false;
const filterCb = (entry) => {
const aliases = getAllAliases(entry.name, entry.aliases);
if (aliases.includes(toRemove)) {
isRemoved = true;
for (const alias of aliases) {
entriesNameSet.delete(alias);
}
return false;
}
return true;
};
absoluteEntries = absoluteEntries.filter(filterCb);
relativeEntries = relativeEntries.filter(filterCb);
return isRemoved;
};
const removeByReference = (toRemove) => {
let isRemoved = false;
const filterCb = (entry) => {
if (entry.middleware === toRemove) {
isRemoved = true;
for (const alias of getAllAliases(entry.name, entry.aliases)) {
entriesNameSet.delete(alias);
}
return false;
}
return true;
};
absoluteEntries = absoluteEntries.filter(filterCb);
relativeEntries = relativeEntries.filter(filterCb);
return isRemoved;
};
const cloneTo = (toStack) => {
absoluteEntries.forEach((entry) => {
toStack.add(entry.middleware, { ...entry });
});
relativeEntries.forEach((entry) => {
toStack.addRelativeTo(entry.middleware, { ...entry });
});
toStack.identifyOnResolve?.(stack.identifyOnResolve());
return toStack;
};
const expandRelativeMiddlewareList = (from) => {
const expandedMiddlewareList = [];
from.before.forEach((entry) => {
if (entry.before.length === 0 && entry.after.length === 0) {
expandedMiddlewareList.push(entry);
} else {
expandedMiddlewareList.push(...expandRelativeMiddlewareList(entry));
}
});
expandedMiddlewareList.push(from);
from.after.reverse().forEach((entry) => {
if (entry.before.length === 0 && entry.after.length === 0) {
expandedMiddlewareList.push(entry);
} else {
expandedMiddlewareList.push(...expandRelativeMiddlewareList(entry));
}
});
return expandedMiddlewareList;
};
const getMiddlewareList = (debug = false) => {
const normalizedAbsoluteEntries = [];
const normalizedRelativeEntries = [];
const normalizedEntriesNameMap = {};
absoluteEntries.forEach((entry) => {
const normalizedEntry = {
...entry,
before: [],
after: []
};
for (const alias of getAllAliases(normalizedEntry.name, normalizedEntry.aliases)) {
normalizedEntriesNameMap[alias] = normalizedEntry;
}
normalizedAbsoluteEntries.push(normalizedEntry);
});
relativeEntries.forEach((entry) => {
const normalizedEntry = {
...entry,
before: [],
after: []
};
for (const alias of getAllAliases(normalizedEntry.name, normalizedEntry.aliases)) {
normalizedEntriesNameMap[alias] = normalizedEntry;
}
normalizedRelativeEntries.push(normalizedEntry);
});
normalizedRelativeEntries.forEach((entry) => {
if (entry.toMiddleware) {
const toMiddleware = normalizedEntriesNameMap[entry.toMiddleware];
if (toMiddleware === undefined) {
if (debug) {
return;
}
throw new Error(`${entry.toMiddleware} is not found when adding ` + `${getMiddlewareNameWithAliases(entry.name, entry.aliases)} ` + `middleware ${entry.relation} ${entry.toMiddleware}`);
}
if (entry.relation === "after") {
toMiddleware.after.push(entry);
}
if (entry.relation === "before") {
toMiddleware.before.push(entry);
}
}
});
const mainChain = sort(normalizedAbsoluteEntries).map(expandRelativeMiddlewareList).reduce((wholeList, expandedMiddlewareList) => {
wholeList.push(...expandedMiddlewareList);
return wholeList;
}, []);
return mainChain;
};
const stack = {
add: (middleware, options = {}) => {
const { name, override, aliases: _aliases } = options;
const entry = {
step: "initialize",
priority: "normal",
middleware,
...options
};
const aliases = getAllAliases(name, _aliases);
if (aliases.length > 0) {
if (aliases.some((alias) => entriesNameSet.has(alias))) {
if (!override)
throw new Error(`Duplicate middleware name '${getMiddlewareNameWithAliases(name, _aliases)}'`);
for (const alias of aliases) {
const toOverrideIndex = absoluteEntries.findIndex((entry) => entry.name === alias || entry.aliases?.some((a) => a === alias));
if (toOverrideIndex === -1) {
continue;
}
const toOverride = absoluteEntries[toOverrideIndex];
if (toOverride.step !== entry.step || entry.priority !== toOverride.priority) {
throw new Error(`"${getMiddlewareNameWithAliases(toOverride.name, toOverride.aliases)}" middleware with ` + `${toOverride.priority} priority in ${toOverride.step} step cannot ` + `be overridden by "${getMiddlewareNameWithAliases(name, _aliases)}" middleware with ` + `${entry.priority} priority in ${entry.step} step.`);
}
absoluteEntries.splice(toOverrideIndex, 1);
}
}
for (const alias of aliases) {
entriesNameSet.add(alias);
}
}
absoluteEntries.push(entry);
},
addRelativeTo: (middleware, options) => {
const { name, override, aliases: _aliases } = options;
const entry = {
middleware,
...options
};
const aliases = getAllAliases(name, _aliases);
if (aliases.length > 0) {
if (aliases.some((alias) => entriesNameSet.has(alias))) {
if (!override)
throw new Error(`Duplicate middleware name '${getMiddlewareNameWithAliases(name, _aliases)}'`);
for (const alias of aliases) {
const toOverrideIndex = relativeEntries.findIndex((entry) => entry.name === alias || entry.aliases?.some((a) => a === alias));
if (toOverrideIndex === -1) {
continue;
}
const toOverride = relativeEntries[toOverrideIndex];
if (toOverride.toMiddleware !== entry.toMiddleware || toOverride.relation !== entry.relation) {
throw new Error(`"${getMiddlewareNameWithAliases(toOverride.name, toOverride.aliases)}" middleware ` + `${toOverride.relation} "${toOverride.toMiddleware}" middleware cannot be overridden ` + `by "${getMiddlewareNameWithAliases(name, _aliases)}" middleware ${entry.relation} ` + `"${entry.toMiddleware}" middleware.`);
}
relativeEntries.splice(toOverrideIndex, 1);
}
}
for (const alias of aliases) {
entriesNameSet.add(alias);
}
}
relativeEntries.push(entry);
},
clone: () => cloneTo(constructStack()),
use: (plugin) => {
plugin.applyToStack(stack);
},
remove: (toRemove) => {
if (typeof toRemove === "string")
return removeByName(toRemove);
else
return removeByReference(toRemove);
},
removeByTag: (toRemove) => {
let isRemoved = false;
const filterCb = (entry) => {
const { tags, name, aliases: _aliases } = entry;
if (tags && tags.includes(toRemove)) {
const aliases = getAllAliases(name, _aliases);
for (const alias of aliases) {
entriesNameSet.delete(alias);
}
isRemoved = true;
return false;
}
return true;
};
absoluteEntries = absoluteEntries.filter(filterCb);
relativeEntries = relativeEntries.filter(filterCb);
return isRemoved;
},
concat: (from) => {
const cloned = cloneTo(constructStack());
cloned.use(from);
cloned.identifyOnResolve(identifyOnResolve || cloned.identifyOnResolve() || (from.identifyOnResolve?.() ?? false));
return cloned;
},
applyToStack: cloneTo,
identify: () => {
return getMiddlewareList(true).map((mw) => {
const step = mw.step ?? mw.relation + " " + mw.toMiddleware;
return getMiddlewareNameWithAliases(mw.name, mw.aliases) + " - " + step;
});
},
identifyOnResolve(toggle) {
if (typeof toggle === "boolean")
identifyOnResolve = toggle;
return identifyOnResolve;
},
resolve: (handler, context) => {
for (const middleware of getMiddlewareList().map((entry) => entry.middleware).reverse()) {
handler = middleware(handler, context);
}
if (identifyOnResolve) {
console.log(stack.identify());
}
return handler;
}
};
return stack;
};
var stepWeights = {
initialize: 5,
serialize: 4,
build: 3,
finalizeRequest: 2,
deserialize: 1
};
var priorityWeights = {
high: 3,
normal: 2,
low: 1
};
var invalidFunction = (message) => () => {
throw new Error(message);
};
var invalidProvider = (message) => () => Promise.reject(message);
var getCircularReplacer = () => {
const seen = new WeakSet;
return (key, value) => {
if (typeof value === "object" && value !== null) {
if (seen.has(value)) {
return "[Circular]";
}
seen.add(value);
}
return value;
};
};
var sleep = (seconds) => {
return new Promise((resolve) => setTimeout(resolve, seconds * 1000));
};
var waiterServiceDefaults = {
minDelay: 2,
maxDelay: 120
};
var WaiterState;
(function(WaiterState) {
WaiterState["ABORTED"] = "ABORTED";
WaiterState["FAILURE"] = "FAILURE";
WaiterState["SUCCESS"] = "SUCCESS";
WaiterState["RETRY"] = "RETRY";
WaiterState["TIMEOUT"] = "TIMEOUT";
})(WaiterState || (WaiterState = {}));
var checkExceptions = (result) => {
if (result.state === WaiterState.ABORTED) {
const abortError = new Error(`${JSON.stringify({
...result,
reason: "Request was aborted"
}, getCircularReplacer())}`);
abortError.name = "AbortError";
throw abortError;
} else if (result.state === WaiterState.TIMEOUT) {
const timeoutError = new Error(`${JSON.stringify({
...result,
reason: "Waiter has timed out"
}, getCircularReplacer())}`);
timeoutError.name = "TimeoutError";
throw timeoutError;
} else if (result.state !== WaiterState.SUCCESS) {
throw new Error(`${JSON.stringify(result, getCircularReplacer())}`);
}
return result;
};
var runPolling = async ({ minDelay, maxDelay, maxWaitTime, abortController, client, abortSignal }, input, acceptorChecks) => {
const observedResponses = {};
const [minDelayMs, maxDelayMs] = [minDelay * 1000, maxDelay * 1000];
let currentAttempt = 0;
const waitUntil = Date.now() + maxWaitTime * 1000;
const warn403Time = Date.now() + 60000;
let didWarn403 = false;
while (true) {
if (currentAttempt > 0) {
const delayMs = exponentialBackoffWithJitter(minDelayMs, maxDelayMs, currentAttempt, waitUntil);
if (abortController?.signal?.aborted || abortSignal?.aborted) {
const message = "AbortController signal aborted.";
observedResponses[message] |= 0;
observedResponses[message] += 1;
return { state: WaiterState.ABORTED, observedResponses };
}
if (Date.now() + delayMs > waitUntil) {
return { state: WaiterState.TIMEOUT, observedResponses };
}
await sleep(delayMs / 1000);
}
const { state, reason } = await acceptorChecks(client, input);
if (reason) {
const message = createMessageFromResponse(reason);
observedResponses[message] |= 0;
observedResponses[message] += 1;
}
if (state !== WaiterState.RETRY) {
return { state, reason, final: reason, observedResponses };
}
currentAttempt += 1;
if (!didWarn403 && Date.now() >= warn403Time) {
checkWarn403(observedResponses, client);
didWarn403 = true;
}
}
};
var checkWarn403 = (observedResponses = {}, client) => {
const orderedErrors = Object.keys(observedResponses);
let count403 = 0;
for (const response of orderedErrors) {
const n = observedResponses[response] | 0;
if (response.startsWith("403:")) {
count403 += n;
}
}
const clientLogger = client?.config?.logger;
const warningLogger = typeof clientLogger?.warn === "function" && !clientLogger.constructor?.name?.includes?.("NoOpLogger") ? clientLogger : console;
if (count403 >= 3 || orderedErrors[orderedErrors.length - 1]?.startsWith("403:")) {
warningLogger.warn(`@smithy/util-waiter WARN - 403 status code encountered during waiter polling.`);
}
};
var createMessageFromResponse = (reason) => {
const status = reason?.$response?.statusCode ?? reason?.$metadata?.httpStatusCode;
if (reason?.$responseBodyText) {
return `${status ? status + ": " : ""}Deserialization error for body: ${reason.$responseBodyText}`;
}
if (status) {
if (reason?.$response || reason?.message) {
return `${status ?? "Unknown"}: ${reason?.message}`;
}
return `${status}: OK`;
}
return String(reason?.message ?? JSON.stringify(reason, getCircularReplacer()) ?? "Unknown");
};
var exponentialBackoffWithJitter = (minDelayMs, maxDelayMs, attempt, waitUntil) => {
const attemptCountCeiling = Math.log(maxDelayMs / minDelayMs) / Math.log(2) + 1;
if (attempt > attemptCountCeiling) {
return maxDelayMs;
}
const delay = minDelayMs * 2 ** (attempt - 1);
const capped = Math.min(delay, maxDelayMs);
const waitFor = randomInRange(minDelayMs, capped);
if (Date.now() + waitFor > waitUntil) {
const timeRemaining = waitUntil - Date.now();
return Math.max(0, timeRemaining - 500);
}
return waitFor;
};
var randomInRange = (min, max) => min + Math.random() * (max - min);
var validateWaiterOptions = (options) => {
if (options.maxWaitTime <= 0) {
throw new Error(`WaiterConfiguration.maxWaitTime must be greater than 0`);
} else if (options.minDelay <= 0) {
throw new Error(`WaiterConfiguration.minDelay must be greater than 0`);
} else if (options.maxDelay <= 0) {
throw new Error(`WaiterConfiguration.maxDelay must be greater than 0`);
} else if (options.maxWaitTime <= options.minDelay) {
throw new Error(`WaiterConfiguration.maxWaitTime [${options.maxWaitTime}] must be greater than WaiterConfiguration.minDelay [${options.minDelay}] for this waiter`);
} else if (options.maxDelay < options.minDelay) {
throw new Error(`WaiterConfiguration.maxDelay [${options.maxDelay}] must be greater than WaiterConfiguration.minDelay [${options.minDelay}] for this waiter`);
}
};
var abortTimeout = (abortSignal) => {
let onAbort;
const promise = new Promise((resolve) => {
onAbort = () => resolve({ state: WaiterState.ABORTED });
if (typeof abortSignal.addEventListener === "function") {
abortSignal.addEventListener("abort", onAbort);
} else {
abortSignal.onabort = onAbort;
}
});
return {
clearListener() {
if (typeof abortSignal.removeEventListener === "function") {
abortSignal.removeEventListener("abort", onAbort);
}
},
aborted: promise
};
};
var createWaiter = async (options, input, acceptorChecks) => {
const params = {
...waiterServiceDefaults,
...options
};
validateWaiterOptions(params);
const exitConditions = [runPolling(params, input, acceptorChecks)];
const finalize = [];
if (options.abortSignal) {
const { aborted, clearListener } = abortTimeout(options.abortSignal);
finalize.push(clearListener);
exitConditions.push(aborted);
}
if (options.abortController?.signal) {
const { aborted, clearListener } = abortTimeout(options.abortController.signal);
finalize.push(clearListener);
exitConditions.push(aborted);
}
return Promise.race(exitConditions).then((result) => {
for (const fn of finalize) {
fn();
}
return result;
});
};
class Client {
config;
middlewareStack = constructStack();
initConfig;
handlers;
constructor(config) {
this.config = config;
const { protocol, protocolSettings } = config;
if (protocolSettings) {
if (typeof protocol === "function") {
config.protocol = new protocol(protocolSettings);
}
}
}
send(command, optionsOrCb, cb) {
const options = typeof optionsOrCb !== "function" ? optionsOrCb : undefined;
const callback = typeof optionsOrCb === "function" ? optionsOrCb : cb;
const useHandlerCache = options === undefined && this.config.cacheMiddleware === true;
let handler;
if (useHandlerCache) {
if (!this.handlers) {
this.handlers = new WeakMap;
}
const handlers = this.handlers;
if (handlers.has(command.constructor)) {
handler = handlers.get(command.constructor);
} else {
handler = command.resolveMiddleware(this.middlewareStack, this.config, options);
handlers.set(command.constructor, handler);
}
} else {
delete this.handlers;
handler = command.resolveMiddleware(this.middlewareStack, this.config, options);
}
if (callback) {
handler(command).then((result) => callback(null, result.output), (err) => callback(err)).catch(() => {});
} else {
return handler(command).then((result) => result.output);
}
}
destroy() {
this.config?.requestHandler?.destroy?.();
delete this.handlers;
}
}
var SENSITIVE_STRING$1 = "***SensitiveInformation***";
function schemaLogFilter(schema, data) {
if (data == null) {
return data;
}
const ns = NormalizedSchema.of(schema);
if (ns.getMergedTraits().sensitive) {
return SENSITIVE_STRING$1;
}
if (ns.isListSchema()) {
const isSensitive = !!ns.getValueSchema().getMergedTraits().sensitive;
if (isSensitive) {
return SENSITIVE_STRING$1;
}
} else if (ns.isMapSchema()) {
const isSensitive = !!ns.getKeySchema().getMergedTraits().sensitive || !!ns.getValueSchema().getMergedTraits().sensitive;
if (isSensitive) {
return SENSITIVE_STRING$1;
}
} else if (ns.isStructSchema() && typeof data === "object") {
const object = data;
const newObject = {};
for (const [member, memberNs] of ns.structIterator()) {
if (object[member] != null) {
newObject[member] = schemaLogFilter(memberNs, object[member]);
}
}
return newObject;
}
return data;
}
class Command {
middlewareStack = constructStack();
schema;
static classBuilder() {
return new ClassBuilder;
}
resolveMiddlewareWithContext(clientStack, configuration, options, { middlewareFn, clientName, commandName, inputFilterSensitiveLog, outputFilterSensitiveLog, smithyContext, additionalContext, CommandCtor }) {
for (const mw of middlewareFn.bind(this)(CommandCtor, clientStack, configuration, options)) {
this.middlewareStack.use(mw);
}
const stack = clientStack.concat(this.middlewareStack);
const { logger } = configuration;
const handlerExecutionContext = {
logger,
clientName,
commandName,
inputFilterSensitiveLog,
outputFilterSensitiveLog,
[SMITHY_CONTEXT_KEY]: {
commandInstance: this,
...smithyContext
},
...additionalContext
};
const { requestHandler } = configuration;
let requestOptions = options ?? {};
if (smithyContext.eventStream) {
requestOptions = {
isEventStream: true,
...requestOptions
};
}
return stack.resolve((request) => requestHandler.handle(request.request, requestOptions), handlerExecutionContext);
}
}
class ClassBuilder {
_init = () => {};
_ep = {};
_middlewareFn = () => [];
_commandName = "";
_clientName = "";
_additionalContext = {};
_smithyContext = {};
_inputFilterSensitiveLog = undefined;
_outputFilterSensitiveLog = undefined;
_serializer = null;
_deserializer = null;
_operationSchema;
init(cb) {
this._init = cb;
}
ep(endpointParameterInstructions) {
this._ep = endpointParameterInstructions;
return this;
}
m(middlewareSupplier) {
this._middlewareFn = middlewareSupplier;
return this;
}
s(service, operation, smithyContext = {}) {
this._smithyContext = {
service,
operation,
...smithyContext
};
return this;
}
c(additionalContext = {}) {
this._additionalContext = additionalContext;
return this;
}
n(clientName, commandName) {
this._clientName = clientName;
this._commandName = commandName;
return this;
}
f(inputFilter = (_) => _, outputFilter = (_) => _) {
this._inputFilterSensitiveLog = inputFilter;
this._outputFilterSensitiveLog = outputFilter;
return this;
}
ser(serializer) {
this._serializer = serializer;
return this;
}
de(deserializer) {
this._deserializer = deserializer;
return this;
}
sc(operation) {
this._operationSchema = operation;
this._smithyContext.operationSchema = operation;
return this;
}
build() {
const closure = this;
let CommandRef;
return CommandRef = class extends Command {
input;
static getEndpointParameterInstructions() {
return closure._ep;
}
constructor(...[input]) {
super();
this.input = input ?? {};
closure._init(this);
this.schema = closure._operationSchema;
}
resolveMiddleware(stack, configuration, options) {
const op = closure._operationSchema;
const input = op?.[4] ?? op?.input;
const output = op?.[5] ?? op?.output;
return this.resolveMiddlewareWithContext(stack, configuration, options, {
CommandCtor: CommandRef,
middlewareFn: closure._middlewareFn,
clientName: closure._clientName,
commandName: closure._commandName,
inputFilterSensitiveLog: closure._inputFilterSensitiveLog ?? (op ? schemaLogFilter.bind(null, input) : (_) => _),
outputFilterSensitiveLog: closure._outputFilterSensitiveLog ?? (op ? schemaLogFilter.bind(null, output) : (_) => _),
smithyContext: closure._smithyContext,
additionalContext: closure._additionalContext
});
}
serialize = closure._serializer;
deserialize = closure._deserializer;
};
}
}
var SENSITIVE_STRING = "***SensitiveInformation***";
var createAggregatedClient = (commands, Client, options) => {
for (const [command, CommandCtor] of Object.entries(commands)) {
const methodImpl = async function(args, optionsOrCb, cb) {
const command = new CommandCtor(args);
if (typeof optionsOrCb === "function") {
this.send(command, optionsOrCb);
} else if (typeof cb === "function") {
if (typeof optionsOrCb !== "object")
throw new Error(`Expected http options but got ${typeof optionsOrCb}`);
this.send(command, optionsOrCb || {}, cb);
} else {
return this.send(command, optionsOrCb);
}
};
const methodName = (command[0].toLowerCase() + command.slice(1)).replace(/Command$/, "");
Client.prototype[methodName] = methodImpl;
}
const { paginators = {}, waiters = {} } = options ?? {};
for (const [paginatorName, paginatorFn] of Object.entries(paginators)) {
if (Client.prototype[paginatorName] === undefined) {
Client.prototype[paginatorName] = function(commandInput = {}, paginationConfiguration, ...rest) {
return paginatorFn({
...paginationConfiguration,
client: this
}, commandInput, ...rest);
};
}
}
for (const [waiterName, waiterFn] of Object.entries(waiters)) {
if (Client.prototype[waiterName] === undefined) {
Client.prototype[waiterName] = async function(commandInput = {}, waiterConfiguration, ...rest) {
let config = waiterConfiguration;
if (typeof waiterConfiguration === "number") {
config = {
maxWaitTime: waiterConfiguration
};
}
return waiterFn({
...config,
client: this
}, commandInput, ...rest);
};
}
}
};
class ServiceException extends Error {
$fault;
$response;
$retryable;
$metadata;
constructor(options) {
super(options.message);
Object.setPrototypeOf(this, Object.getPrototypeOf(this).constructor.prototype);
this.name = options.name;
this.$fault = options.$fault;
this.$metadata = options.$metadata;
}
static isInstance(value) {
if (!value)
return false;
const candidate = value;
return ServiceException.prototype.isPrototypeOf(candidate) || Boolean(candidate.$fault) && Boolean(candidate.$metadata) && (candidate.$fault === "client" || candidate.$fault === "server");
}
static [Symbol.hasInstance](instance) {
if (!instance)
return false;
const candidate = instance;
if (this === ServiceException) {
return ServiceException.isInstance(instance);
}
if (ServiceException.isInstance(instance)) {
if (candidate.name && this.name) {
return this.prototype.isPrototypeOf(instance) || candidate.name === this.name;
}
return this.prototype.isPrototypeOf(instance);
}
return false;
}
}
var decorateServiceException = (exception, additions = {}) => {
Object.entries(additions).filter(([, v]) => v !== undefined).forEach(([k, v]) => {
if (exception[k] == undefined || exception[k] === "") {
exception[k] = v;
}
});
const message = exception.message || exception.Message || "UnknownError";
exception.message = message;
delete exception.Message;
return exception;
};
var throwDefaultError = ({ output, parsedBody, exceptionCtor, errorCode }) => {
const $metadata = deserializeMetadata(output);
const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : undefined;
const response = new exceptionCtor({
name: parsedBody?.code || parsedBody?.Code || errorCode || statusCode || "UnknownError",
$fault: "client",
$metadata
});
throw decorateServiceException(response, parsedBody);
};
var withBaseException = (ExceptionCtor) => {
return ({ output, parsedBody, errorCode }) => {
throwDefaultError({ output, parsedBody, exceptionCtor: ExceptionCtor, errorCode });
};
};
var deserializeMetadata = (output) => ({
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"]
});
var loadConfigsForDefaultMode = (mode) => {
switch (mode) {
case "standard":
return {
retryMode: "standard",
connectionTimeout: 3100
};
case "in-region":
return {
retryMode: "standard",
connectionTimeout: 1100
};
case "cross-region":
return {
retryMode: "standard",
connectionTimeout: 3100
};
case "mobile":
return {
retryMode: "standard",
connectionTimeout: 30000
};
default:
return {};
}
};
var warningEmitted = false;
var emitWarningIfUnsupportedVersion = (version) => {
if (version && !warningEmitted && parseInt(version.substring(1, version.indexOf("."))) < 16) {
warningEmitted = true;
}
};
var knownAlgorithms = Object.values(AlgorithmId);
var getChecksumConfiguration = (runtimeConfig) => {
const checksumAlgorithms = [];
for (const id in AlgorithmId) {
if (!hasOwn(AlgorithmId, id))
continue;
const algorithmId = AlgorithmId[id];
if (runtimeConfig[algorithmId] === undefined) {
continue;
}
checksumAlgorithms.push({
algorithmId: () => algorithmId,
checksumConstructor: () => runtimeConfig[algorithmId]
});
}
for (const [id, ChecksumCtor] of Object.entries(runtimeConfig.checksumAlgorithms ?? {})) {
checksumAlgorithms.push({
algorithmId: () => id,
checksumConstructor: () => ChecksumCtor
});
}
return {
addChecksumAlgorithm(algo) {
runtimeConfig.checksumAlgorithms = runtimeConfig.checksumAlgorithms ?? {};
const id = algo.algorithmId();
const ctor = algo.checksumConstructor();
if (knownAlgorithms.includes(id)) {
runtimeConfig.checksumAlgorithms[id.toUpperCase()] = ctor;
} else {
runtimeConfig.checksumAlgorithms[id] = ctor;
}
checksumAlgorithms.push(algo);
},
checksumAlgorithms() {
return checksumAlgorithms;
}
};
};
var resolveChecksumRuntimeConfig = (clientConfig) => {
const runtimeConfig = {};
clientConfig.checksumAlgorithms().forEach((checksumAlgorithm) => {
const id = checksumAlgorithm.algorithmId();
if (knownAlgorithms.includes(id)) {
runtimeConfig[id] = checksumAlgorithm.checksumConstructor();
}
});
return runtimeConfig;
};
var getRetryConfiguration = (runtimeConfig) => {
return {
setRetryStrategy(retryStrategy) {
runtimeConfig.retryStrategy = retryStrategy;
},
retryStrategy() {
return runtimeConfig.retryStrategy;
}
};
};
var resolveRetryRuntimeConfig = (retryStrategyConfiguration) => {
const runtimeConfig = {};
runtimeConfig.retryStrategy = retryStrategyConfiguration.retryStrategy();
return runtimeConfig;
};
var getDefaultExtensionConfiguration = (runtimeConfig) => {
return Object.assign(getChecksumConfiguration(runtimeConfig), getRetryConfiguration(runtimeConfig));
};
var getDefaultClientConfiguration = getDefaultExtensionConfiguration;
var resolveDefaultRuntimeConfig = (config) => {
return Object.assign(resolveChecksumRuntimeConfig(config), resolveRetryRuntimeConfig(config));
};
var getArrayIfSingleItem = (mayBeArray) => Array.isArray(mayBeArray) ? mayBeArray : [mayBeArray];
var getValueFromTextNode = (obj) => {
const textNodeName = "#text";
for (const key in obj) {
if (!hasOwn(obj, key))
continue;
if (obj[key][textNodeName] !== undefined) {
obj[key] = obj[key][textNodeName];
} else if (typeof obj[key] === "object" && obj[key] !== null) {
obj[key] = getValueFromTextNode(obj[key]);
}
}
return obj;
};
var isSerializableHeaderValue = (value) => {
return value != null;
};
class NoOpLogger {
trace() {}
debug() {}
info() {}
warn() {}
error() {}
}
function map(arg0, arg1, arg2) {
let target;
let filter;
let instructions;
if (typeof arg1 === "undefined" && typeof arg2 === "undefined") {
target = {};
instructions = arg0;
} else {
target = arg0;
if (typeof arg1 === "function") {
filter = arg1;
instructions = arg2;
return mapWithFilter(target, filter, instructions);
} else {
instructions = arg1;
}
}
for (const key in instructions) {
if (!hasOwn(instructions, key))
continue;
if (!Array.isArray(instructions[key])) {
target[key] = instructions[key];
continue;
}
applyInstruction(target, null, instructions, key);
}
return target;
}
var convertMap = (target) => {
const output = {};
for (const [k, v] of Object.entries(target || {})) {
output[k] = [, v];
}
return output;
};
var take = (source, instructions) => {
const out = {};
for (const key in instructions) {
if (!hasOwn(instructions, key))
continue;
applyInstruction(out, source, instructions, key);
}
return out;
};
var mapWithFilter = (target, filter, instructions) => {
return map(target, Object.entries(instructions).reduce((_instructions, [key, value]) => {
if (Array.isArray(value)) {
_instructions[key] = value;
} else {
if (typeof value === "function") {
_instructions[key] = [filter, value()];
} else {
_instructions[key] = [filter, value];
}
}
return _instructions;
}, {}));
};
var applyInstruction = (target, source, instructions, targetKey) => {
if (source !== null) {
let instruction = instructions[targetKey];
if (typeof instruction === "function") {
instruction = [, instruction];
}
const [filter = nonNullish, valueFn = pass, sourceKey = targetKey] = instruction;
if (typeof filter === "function" && filter(source[sourceKey]) || typeof filter !== "function" && !!filter) {
target[targetKey] = valueFn(source[sourceKey]);
}
return;
}
let [filter, value] = instructions[targetKey];
if (typeof value === "function") {
let _value;
const defaultFilterPassed = filter === undefined && (_value = value()) != null;
const customFilterPassed = typeof filter === "function" && !!filter(undefined) || typeof filter !== "function" && !!filter;
if (defaultFilterPassed) {
target[targetKey] = _value;
} else if (customFilterPassed) {
target[targetKey] = value();
}
} else {
const defaultFilterPassed = filter === undefined && value != null;
const customFilterPassed = typeof filter === "function" && !!filter(value) || typeof filter !== "function" && !!filter;
if (defaultFilterPassed || customFilterPassed) {
target[targetKey] = value;
}
}
};
var nonNullish = (_) => _ != null;
var pass = (_) => _;
var serializeFloat = (value) => {
if (value !== value) {
return "NaN";
}
switch (value) {
case Infinity:
return "Infinity";
case -Infinity:
return "-Infinity";
default:
return value;
}
};
var serializeDateTime = (date) => date.toISOString().replace(".000Z", "Z");
var _json = (obj) => {
if (obj == null) {
return {};
}
if (Array.isArray(obj)) {
return obj.filter((_) => _ != null).map(_json);
}
if (typeof obj === "object") {
const target = {};
for (const key in obj) {
if (!hasOwn(obj, key))
continue;
if (obj[key] == null) {
continue;
}
target[key] = _json(obj[key]);
}
return target;
}
return obj;
};
function makeBuilder(common, service, name, ep) {
return function makeCommand(added, plugins, op, $, smithyContext = {}) {
const epMerged = Object.assign({}, common, added);
return Command.classBuilder().ep(epMerged).m(function(CommandCtor, clientStack, config, options) {
const list = plugins.call(this, CommandCtor, clientStack, config, options);
list.unshift(ep(config, CommandCtor.getEndpointParameterInstructions()));
return list;
}).s(service, op, smithyContext).n(name, op.charAt(0).toUpperCase() + op.slice(1) + "Command").sc($).build();
};
}
exports.Client = Client;
exports.Command = Command;
exports.NoOpLogger = NoOpLogger;
exports.SENSITIVE_STRING = SENSITIVE_STRING;
exports.ServiceException = ServiceException;
exports.WaiterState = WaiterState;
exports._json = _json;
exports.checkExceptions = checkExceptions;
exports.constructStack = constructStack;
exports.convertMap = convertMap;
exports.createAggregatedClient = createAggregatedClient;
exports.createWaiter = createWaiter;
exports.decorateServiceException = decorateServiceException;
exports.emitWarningIfUnsupportedVersion = emitWarningIfUnsupportedVersion;
exports.getArrayIfSingleItem = getArrayIfSingleItem;
exports.getChecksumConfiguration = getChecksumConfiguration;
exports.getDefaultClientConfiguration = getDefaultClientConfiguration;
exports.getDefaultExtensionConfiguration = getDefaultExtensionConfiguration;
exports.getRetryConfiguration = getRetryConfiguration;
exports.getValueFromTextNode = getValueFromTextNode;
exports.invalidFunction = invalidFunction;
exports.invalidProvider = invalidProvider;
exports.isSerializableHeaderValue = isSerializableHeaderValue;
exports.loadConfigsForDefaultMode = loadConfigsForDefaultMode;
exports.makeBuilder = makeBuilder;
exports.map = map;
exports.resolveChecksumRuntimeConfig = resolveChecksumRuntimeConfig;
exports.resolveDefaultRuntimeConfig = resolveDefaultRuntimeConfig;
exports.resolveRetryRuntimeConfig = resolveRetryRuntimeConfig;
exports.schemaLogFilter = schemaLogFilter;
exports.serializeDateTime = serializeDateTime;
exports.serializeFloat = serializeFloat;
exports.take = take;
exports.throwDefaultError = throwDefaultError;
exports.waiterServiceDefaults = waiterServiceDefaults;
exports.withBaseException = withBaseException;
});
// ../../node_modules/.bun/@smithy+core@3.33.3/node_modules/@smithy/core/dist-cjs/submodules/config/index.js
var require_config = __commonJS(function(exports) {
var { homedir } = __require("os");
var { sep, join } = __require("path");
var { createHash } = __require("crypto");
var { readFile: readFile$1 } = __require("fs/promises");
var { IniSectionType } = require_dist_cjs();
var { normalizeProvider } = require_client();
var { isValidHostLabel } = require_transport();
class ProviderError extends Error {
name = "ProviderError";
tryNextLink;
constructor(message, options = true) {
let logger;
let tryNextLink = true;
if (typeof options === "boolean") {
logger = undefined;
tryNextLink = options;
} else if (options != null && typeof options === "object") {
logger = options.logger;
tryNextLink = options.tryNextLink ?? true;
}
super(message);
this.tryNextLink = tryNextLink;
Object.setPrototypeOf(this, ProviderError.prototype);
logger?.debug?.(`@smithy/property-provider ${tryNextLink ? "->" : "(!)"} ${message}`);
}
static from(error, options = true) {
return Object.assign(new this(error.message, options), error);
}
}
class CredentialsProviderError extends ProviderError {
name = "CredentialsProviderError";
constructor(message, options = true) {
super(message, options);
Object.setPrototypeOf(this, CredentialsProviderError.prototype);
}
}
class TokenProviderError extends ProviderError {
name = "TokenProviderError";
constructor(message, options = true) {
super(message, options);
Object.setPrototypeOf(this, TokenProviderError.prototype);
}
}
var chain = (...providers) => async () => {
if (providers.length === 0) {
throw new ProviderError("No providers in chain");
}
let lastProviderError;
for (const provider of providers) {
try {
const credentials = await provider();
return credentials;
} catch (err) {
lastProviderError = err;
if (err?.tryNextLink) {
continue;
}
throw err;
}
}
throw lastProviderError;
};
var fromValue = (staticValue) => () => Promise.resolve(staticValue);
var memoize = (provider, isExpired, requiresRefresh) => {
let resolved;
let pending;
let hasResult;
let isConstant = false;
const coalesceProvider = async () => {
if (!pending) {
pending = provider();
}
try {
resolved = await pending;
hasResult = true;
isConstant = false;
} finally {
pending = undefined;
}
return resolved;
};
if (isExpired === undefined) {
return async (options) => {
if (!hasResult || options?.forceRefresh) {
resolved = await coalesceProvider();
}
return resolved;
};
}
return async (options) => {
if (!hasResult || options?.forceRefresh) {
resolved = await coalesceProvider();
}
if (isConstant) {
return resolved;
}
if (requiresRefresh && !requiresRefresh(resolved)) {
isConstant = true;
return resolved;
}
if (isExpired(resolved)) {
await coalesceProvider();
return resolved;
}
return resolved;
};
};
var booleanSelector = (obj, key, type) => {
if (!(key in obj))
return;
if (obj[key] === "true")
return true;
if (obj[key] === "false")
return false;
throw new Error(`Cannot load ${type} "${key}". Expected "true" or "false", got ${obj[key]}.`);
};
var numberSelector = (obj, key, type) => {
if (!(key in obj))
return;
const numberValue = parseInt(obj[key], 10);
if (Number.isNaN(numberValue)) {
throw new TypeError(`Cannot load ${type} '${key}'. Expected number, got '${obj[key]}'.`);
}
return numberValue;
};
var SelectorType;
(function(SelectorType) {
SelectorType["ENV"] = "env";
SelectorType["CONFIG"] = "shared config entry";
})(SelectorType || (SelectorType = {}));
var homeDirCache = {};
var getHomeDirCacheKey = () => {
if (process && process.geteuid) {
return `${process.geteuid()}`;
}
return "DEFAULT";
};
var getHomeDir = () => {
const { HOME, USERPROFILE, HOMEPATH, HOMEDRIVE = `C:${sep}` } = process.env;
if (HOME)
return HOME;
if (USERPROFILE)
return USERPROFILE;
if (HOMEPATH)
return `${HOMEDRIVE}${HOMEPATH}`;
const homeDirCacheKey = getHomeDirCacheKey();
if (!homeDirCache[homeDirCacheKey])
homeDirCache[homeDirCacheKey] = homedir();
return homeDirCache[homeDirCacheKey];
};
var ENV_PROFILE = "AWS_PROFILE";
var DEFAULT_PROFILE = "default";
var getProfileName = (init) => init.profile || process.env[ENV_PROFILE] || DEFAULT_PROFILE;
var getSSOTokenFilepath = (id) => {
const hasher = createHash("sha1");
const cacheName = hasher.update(id).digest("hex");
return join(getHomeDir(), ".aws", "sso", "cache", `${cacheName}.json`);
};
var tokenIntercept = {};
var getSSOTokenFromFile = async (id) => {
if (tokenIntercept[id]) {
return tokenIntercept[id];
}
const ssoTokenFilepath = getSSOTokenFilepath(id);
const ssoTokenText = await readFile$1(ssoTokenFilepath, "utf8");
return JSON.parse(ssoTokenText);
};
var CONFIG_PREFIX_SEPARATOR = ".";
var getConfigData = (data) => Object.entries(data).filter(([key]) => {
const indexOfSeparator = key.indexOf(CONFIG_PREFIX_SEPARATOR);
if (indexOfSeparator === -1) {
return false;
}
return Object.values(IniSectionType).includes(key.substring(0, indexOfSeparator));
}).reduce((acc, [key, value]) => {
const indexOfSeparator = key.indexOf(CONFIG_PREFIX_SEPARATOR);
const updatedKey = key.substring(0, indexOfSeparator) === IniSectionType.PROFILE ? key.substring(indexOfSeparator + 1) : key;
acc[updatedKey] = value;
return acc;
}, {
...data.default && { default: data.default }
});
var ENV_CONFIG_PATH = "AWS_CONFIG_FILE";
var getConfigFilepath = () => process.env[ENV_CONFIG_PATH] || join(getHomeDir(), ".aws", "config");
var ENV_CREDENTIALS_PATH = "AWS_SHARED_CREDENTIALS_FILE";
var getCredentialsFilepath = () => process.env[ENV_CREDENTIALS_PATH] || join(getHomeDir(), ".aws", "credentials");
var prefixKeyRegex = /^([\w-]+)\s(["'])?([\w-@+.%:/]+)\2$/;
var profileNameBlockList = ["__proto__", "profile __proto__"];
var parseIni = (iniData) => {
const map = {};
let currentSection;
let currentSubSection;
for (const iniLine of iniData.split(/\r?\n/)) {
const trimmedLine = iniLine.split(/(^|\s)[;#]/)[0].trim();
const isSection = trimmedLine[0] === "[" && trimmedLine[trimmedLine.length - 1] === "]";
if (isSection) {
currentSection = undefined;
currentSubSection = undefined;
const sectionName = trimmedLine.substring(1, trimmedLine.length - 1);
const matches = prefixKeyRegex.exec(sectionName);
if (matches) {
const [, prefix, , name] = matches;
if (Object.values(IniSectionType).includes(prefix)) {
currentSection = [prefix, name].join(CONFIG_PREFIX_SEPARATOR);
}
} else {
currentSection = sectionName;
}
if (profileNameBlockList.includes(sectionName)) {
throw new Error(`Found invalid profile name "${sectionName}"`);
}
} else if (currentSection) {
const indexOfEqualsSign = trimmedLine.indexOf("=");
if (![0, -1].includes(indexOfEqualsSign)) {
const [name, value] = [
trimmedLine.substring(0, indexOfEqualsSign).trim(),
trimmedLine.substring(indexOfEqualsSign + 1).trim()
];
if (value === "") {
currentSubSection = name;
} else {
if (currentSubSection && iniLine.trimStart() === iniLine) {
currentSubSection = undefined;
}
map[currentSection] = map[currentSection] || {};
const key = currentSubSection ? [currentSubSection, name].join(CONFIG_PREFIX_SEPARATOR) : name;
map[currentSection][key] = value;
}
}
}
}
return map;
};
var filePromises = {};
var fileIntercept = {};
var readFile = (path, options) => {
if (fileIntercept[path] !== undefined) {
return fileIntercept[path];
}
if (!filePromises[path] || options?.ignoreCache) {
filePromises[path] = readFile$1(path, "utf8");
}
return filePromises[path];
};
var swallowError$1 = () => ({});
var loadSharedConfigFiles = async (init = {}) => {
const { filepath = getCredentialsFilepath(), configFilepath = getConfigFilepath() } = init;
const homeDir = getHomeDir();
const relativeHomeDirPrefix = "~/";
let resolvedFilepath = filepath;
if (filepath.startsWith(relativeHomeDirPrefix)) {
resolvedFilepath = join(homeDir, filepath.slice(2));
}
let resolvedConfigFilepath = configFilepath;
if (configFilepath.startsWith(relativeHomeDirPrefix)) {
resolvedConfigFilepath = join(homeDir, configFilepath.slice(2));
}
const parsedFiles = await Promise.all([
readFile(resolvedConfigFilepath, {
ignoreCache: init.ignoreCache
}).then(parseIni).then(getConfigData).catch(swallowError$1),
readFile(resolvedFilepath, {
ignoreCache: init.ignoreCache
}).then(parseIni).catch(swallowError$1)
]);
return {
configFile: parsedFiles[0],
credentialsFile: parsedFiles[1]
};
};
var getSsoSessionData = (data) => Object.entries(data).filter(([key]) => key.startsWith(IniSectionType.SSO_SESSION + CONFIG_PREFIX_SEPARATOR)).reduce((acc, [key, value]) => ({ ...acc, [key.substring(key.indexOf(CONFIG_PREFIX_SEPARATOR) + 1)]: value }), {});
var swallowError = () => ({});
var loadSsoSessionData = async (init = {}) => readFile(init.configFilepath ?? getConfigFilepath()).then(parseIni).then(getSsoSessionData).catch(swallowError);
var mergeConfigFiles = (...files) => {
const merged = {};
for (const file of files) {
for (const [key, values] of Object.entries(file)) {
if (merged[key] !== undefined) {
Object.assign(merged[key], values);
} else {
merged[key] = values;
}
}
}
return merged;
};
var parseKnownFiles = async (init) => {
const parsedFiles = await loadSharedConfigFiles(init);
return mergeConfigFiles(parsedFiles.configFile, parsedFiles.credentialsFile);
};
var externalDataInterceptor = {
getFileRecord() {
return fileIntercept;
},
interceptFile(path, contents) {
fileIntercept[path] = Promise.resolve(contents);
},
getTokenRecord() {
return tokenIntercept;
},
interceptToken(id, contents) {
tokenIntercept[id] = contents;
}
};
function getSelectorName(functionString) {
try {
const constants = new Set(Array.from(functionString.match(/([A-Z_]){3,}/g) ?? []));
constants.delete("CONFIG");
constants.delete("CONFIG_PREFIX_SEPARATOR");
constants.delete("ENV");
return [...constants].join(", ");
} catch (ignored) {
return functionString;
}
}
var fromEnv = (envVarSelector, options) => async () => {
try {
const config = envVarSelector(process.env, options);
if (config === undefined) {
throw new Error;
}
return config;
} catch (e) {
throw new CredentialsProviderError(e.message || `Not found in ENV: ${getSelectorName(envVarSelector.toString())}`, { logger: options?.logger });
}
};
var fromSharedConfigFiles = (configSelector, { preferredFile = "config", ...init } = {}) => async () => {
const profile = getProfileName(init);
const { configFile, credentialsFile } = await loadSharedConfigFiles(init);
const profileFromCredentials = credentialsFile[profile] || {};
const profileFromConfig = configFile[profile] || {};
const mergedProfile = preferredFile === "config" ? { ...profileFromCredentials, ...profileFromConfig } : { ...profileFromConfig, ...profileFromCredentials };
try {
const cfgFile = preferredFile === "config" ? configFile : credentialsFile;
const configValue = configSelector(mergedProfile, cfgFile);
if (configValue === undefined) {
throw new Error;
}
return configValue;
} catch (e) {
throw new CredentialsProviderError(e.message || `Not found in config files w/ profile [${profile}]: ${getSelectorName(configSelector.toString())}`, { logger: init.logger });
}
};
var isFunction = (func) => typeof func === "function";
var fromStatic = (defaultValue) => isFunction(defaultValue) ? async () => await defaultValue() : fromValue(defaultValue);
var loadConfig = ({ environmentVariableSelector, configFileSelector, default: defaultValue }, configuration = {}) => {
const { signingName, logger } = configuration;
const envOptions = { signingName, logger };
return memoize(chain(fromEnv(environmentVariableSelector, envOptions), fromSharedConfigFiles(configFileSelector, configuration), fromStatic(defaultValue)));
};
var ENV_USE_DUALSTACK_ENDPOINT = "AWS_USE_DUALSTACK_ENDPOINT";
var CONFIG_USE_DUALSTACK_ENDPOINT = "use_dualstack_endpoint";
var DEFAULT_USE_DUALSTACK_ENDPOINT = false;
var NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS = {
environmentVariableSelector: (env) => booleanSelector(env, ENV_USE_DUALSTACK_ENDPOINT, SelectorType.ENV),
configFileSelector: (profile) => booleanSelector(profile, CONFIG_USE_DUALSTACK_ENDPOINT, SelectorType.CONFIG),
default: false
};
var nodeDualstackConfigSelectors = {
environmentVariableSelector: (env) => booleanSelector(env, ENV_USE_DUALSTACK_ENDPOINT, SelectorType.ENV),
configFileSelector: (profile) => booleanSelector(profile, CONFIG_USE_DUALSTACK_ENDPOINT, SelectorType.CONFIG),
default: undefined
};
var ENV_USE_FIPS_ENDPOINT = "AWS_USE_FIPS_ENDPOINT";
var CONFIG_USE_FIPS_ENDPOINT = "use_fips_endpoint";
var DEFAULT_USE_FIPS_ENDPOINT = false;
var NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS = {
environmentVariableSelector: (env) => booleanSelector(env, ENV_USE_FIPS_ENDPOINT, SelectorType.ENV),
configFileSelector: (profile) => booleanSelector(profile, CONFIG_USE_FIPS_ENDPOINT, SelectorType.CONFIG),
default: false
};
var nodeFipsConfigSelectors = {
environmentVariableSelector: (env) => booleanSelector(env, ENV_USE_FIPS_ENDPOINT, SelectorType.ENV),
configFileSelector: (profile) => booleanSelector(profile, CONFIG_USE_FIPS_ENDPOINT, SelectorType.CONFIG),
default: undefined
};
var resolveCustomEndpointsConfig = (input) => {
const { tls, endpoint, urlParser, useDualstackEndpoint } = input;
return Object.assign(input, {
tls: tls ?? true,
endpoint: normalizeProvider(typeof endpoint === "string" ? urlParser(endpoint) : endpoint),
isCustomEndpoint: true,
useDualstackEndpoint: normalizeProvider(useDualstackEndpoint ?? false)
});
};
var getEndpointFromRegion = async (input) => {
const { tls = true } = input;
const region = await input.region();
const dnsHostRegex = new RegExp(/^([a-zA-Z0-9]|[a-zA-Z0-9][a-zA-Z0-9-]{0,61}[a-zA-Z0-9])$/);
if (!dnsHostRegex.test(region)) {
throw new Error("Invalid region in client config");
}
const useDualstackEndpoint = await input.useDualstackEndpoint();
const useFipsEndpoint = await input.useFipsEndpoint();
const { hostname } = await input.regionInfoProvider(region, { useDualstackEndpoint, useFipsEndpoint }) ?? {};
if (!hostname) {
throw new Error("Cannot resolve hostname from client config");
}
return input.urlParser(`${tls ? "https:" : "http:"}//${hostname}`);
};
var resolveEndpointsConfig = (input) => {
const useDualstackEndpoint = normalizeProvider(input.useDualstackEndpoint ?? false);
const { endpoint, useFipsEndpoint, urlParser, tls } = input;
return Object.assign(input, {
tls: tls ?? true,
endpoint: endpoint ? normalizeProvider(typeof endpoint === "string" ? urlParser(endpoint) : endpoint) : () => getEndpointFromRegion({ ...input, useDualstackEndpoint, useFipsEndpoint }),
isCustomEndpoint: !!endpoint,
useDualstackEndpoint
});
};
var AWS_EXECUTION_ENV = "AWS_EXECUTION_ENV";
var AWS_REGION_ENV = "AWS_REGION";
var AWS_DEFAULT_REGION_ENV = "AWS_DEFAULT_REGION";
var ENV_IMDS_DISABLED = "AWS_EC2_METADATA_DISABLED";
var DEFAULTS_MODE_OPTIONS = ["in-region", "cross-region", "mobile", "standard", "legacy"];
var IMDS_REGION_PATH = "/latest/meta-data/placement/region";
var IMDS_TOKEN_PATH = "/latest/api/token";
var X_AWS_EC2_METADATA_TOKEN = "x-aws-ec2-metadata-token";
var X_AWS_EC2_METADATA_TOKEN_TTL = "x-aws-ec2-metadata-token-ttl-seconds";
var TIMEOUT_MS = 1000;
var NEG_CACHE_TTL_MS = 60000;
var negativeCacheUntil = 0;
var getInstanceMetadataRegion = async () => {
if (process.env[ENV_IMDS_DISABLED]) {
return;
}
if (Date.now() < negativeCacheUntil) {
return;
}
try {
const endpoint = resolveImdsEndpoint();
const token = (await imdsRequest({
...endpoint,
path: IMDS_TOKEN_PATH,
method: "PUT",
headers: {
[X_AWS_EC2_METADATA_TOKEN_TTL]: "21600"
}
})).toString();
const region = (await imdsRequest({
...endpoint,
path: IMDS_REGION_PATH,
method: "GET",
headers: {
[X_AWS_EC2_METADATA_TOKEN]: token
}
})).toString().trim();
return region || cacheNegativeAndReturnUndefined();
} catch {
return cacheNegativeAndReturnUndefined();
}
};
var cacheNegativeAndReturnUndefined = () => {
negativeCacheUntil = Date.now() + NEG_CACHE_TTL_MS;
return;
};
var resolveImdsEndpoint = () => {
const envEndpoint = process.env.AWS_EC2_METADATA_SERVICE_ENDPOINT;
if (envEndpoint) {
const url = new URL(envEndpoint);
return {
hostname: url.hostname.replace(/^\[(.+)]$/, "$1"),
port: url.port ? Number(url.port) : undefined
};
}
if (process.env.AWS_EC2_METADATA_SERVICE_ENDPOINT_MODE === "IPv6") {
return { hostname: "fd00:ec2::254" };
}
return { hostname: "169.254.169.254" };
};
var imdsRequest = async (options) => {
const { request } = __require("http");
return new Promise((resolve, reject) => {
const req = request({
hostname: options.hostname,
port: options.port,
path: options.path,
method: options.method,
headers: options.headers,
timeout: TIMEOUT_MS,
signal: AbortSignal.timeout(TIMEOUT_MS)
});
req.on("error", (err) => {
reject(err);
req.destroy();
});
req.on("timeout", () => {
reject(new Error("TimeoutError from instance metadata service"));
req.destroy();
});
req.on("response", (res) => {
const { statusCode = 400 } = res;
if (statusCode < 200 || statusCode >= 300) {
reject(Object.assign(new Error("Error response received from instance metadata service"), { statusCode }));
req.destroy();
return;
}
const chunks = [];
res.on("data", (chunk) => chunks.push(chunk));
res.on("end", () => {
resolve(Buffer.concat(chunks));
req.destroy();
});
});
req.end();
});
};
var REGION_ENV_NAME = "AWS_REGION";
var REGION_INI_NAME = "region";
var NODE_REGION_CONFIG_OPTIONS = {
environmentVariableSelector: (env) => env[REGION_ENV_NAME],
configFileSelector: (profile) => profile[REGION_INI_NAME],
default: async () => {
const region = await getInstanceMetadataRegion();
if (region) {
return region;
}
throw new Error("Region is missing");
}
};
var NODE_REGION_CONFIG_FILE_OPTIONS = {
preferredFile: "credentials"
};
var validRegions = new Set;
var checkRegion = (region, check = isValidHostLabel) => {
if (!validRegions.has(region) && !check(region)) {
if (region === "*") {
console.warn(`@smithy/config-resolver WARN - Please use the caller region instead of "*". See "sigv4a" in https://github.com/aws/aws-sdk-js-v3/blob/main/supplemental-docs/CLIENTS.md.`);
} else {
throw new Error(`Region not accepted: region="${region}" is not a valid hostname component.`);
}
} else {
validRegions.add(region);
}
};
var isFipsRegion = (region) => typeof region === "string" && (region.startsWith("fips-") || region.endsWith("-fips"));
var getRealRegion = (region) => isFipsRegion(region) ? ["fips-aws-global", "aws-fips"].includes(region) ? "us-east-1" : region.replace(/fips-(dkr-|prod-)?|-fips/, "") : region;
var resolveRegionConfig = (input) => {
const { region, useFipsEndpoint } = input;
if (!region) {
throw new Error("Region is missing");
}
return Object.assign(input, {
region: async () => {
const providedRegion = typeof region === "function" ? await region() : region;
const realRegion = getRealRegion(providedRegion);
checkRegion(realRegion);
return realRegion;
},
useFipsEndpoint: async () => {
const providedRegion = typeof region === "string" ? region : await region();
if (isFipsRegion(providedRegion)) {
return true;
}
return typeof useFipsEndpoint !== "function" ? Promise.resolve(!!useFipsEndpoint) : useFipsEndpoint();
}
});
};
var getHostnameFromVariants = (variants = [], { useFipsEndpoint, useDualstackEndpoint }) => variants.find(({ tags }) => useFipsEndpoint === tags.includes("fips") && useDualstackEndpoint === tags.includes("dualstack"))?.hostname;
var getResolvedHostname = (resolvedRegion, { regionHostname, partitionHostname }) => regionHostname ? regionHostname : partitionHostname ? partitionHostname.replace("{region}", resolvedRegion) : undefined;
var getResolvedPartition = (region, { partitionHash }) => Object.keys(partitionHash || {}).find((key) => partitionHash[key].regions.includes(region)) ?? "aws";
var getResolvedSigningRegion = (hostname, { signingRegion, regionRegex, useFipsEndpoint }) => {
if (signingRegion) {
return signingRegion;
} else if (useFipsEndpoint) {
const regionRegexJs = regionRegex.replace("\\\\", "\\").replace(/^\^/g, "\\.").replace(/\$$/g, "\\.");
const regionRegexmatchArray = hostname.match(regionRegexJs);
if (regionRegexmatchArray) {
return regionRegexmatchArray[0].slice(1, -1);
}
}
};
var getRegionInfo = (region, { useFipsEndpoint = false, useDualstackEndpoint = false, signingService, regionHash, partitionHash }) => {
const partition = getResolvedPartition(region, { partitionHash });
const resolvedRegion = region in regionHash ? region : partitionHash[partition]?.endpoint ?? region;
const hostnameOptions = { useFipsEndpoint, useDualstackEndpoint };
const regionHostname = getHostnameFromVariants(regionHash[resolvedRegion]?.variants, hostnameOptions);
const partitionHostname = getHostnameFromVariants(partitionHash[partition]?.variants, hostnameOptions);
const hostname = getResolvedHostname(resolvedRegion, { regionHostname, partitionHostname });
if (hostname === undefined) {
throw new Error(`Endpoint resolution failed for: ${{ resolvedRegion, useFipsEndpoint, useDualstackEndpoint }}`);
}
const signingRegion = getResolvedSigningRegion(hostname, {
signingRegion: regionHash[resolvedRegion]?.signingRegion,
regionRegex: partitionHash[partition].regionRegex,
useFipsEndpoint
});
return {
partition,
signingService,
hostname,
...signingRegion && { signingRegion },
...regionHash[resolvedRegion]?.signingService && {
signingService: regionHash[resolvedRegion].signingService
}
};
};
var AWS_DEFAULTS_MODE_ENV = "AWS_DEFAULTS_MODE";
var AWS_DEFAULTS_MODE_CONFIG = "defaults_mode";
var NODE_DEFAULTS_MODE_CONFIG_OPTIONS = {
environmentVariableSelector: (env) => {
return env[AWS_DEFAULTS_MODE_ENV];
},
configFileSelector: (profile) => {
return profile[AWS_DEFAULTS_MODE_CONFIG];
},
default: "legacy"
};
var resolveDefaultsModeConfig = ({ region = loadConfig(NODE_REGION_CONFIG_OPTIONS), defaultsMode = loadConfig(NODE_DEFAULTS_MODE_CONFIG_OPTIONS) } = {}) => memoize(async () => {
const mode = typeof defaultsMode === "function" ? await defaultsMode() : defaultsMode;
switch (mode?.toLowerCase()) {
case "auto":
return resolveNodeDefaultsModeAuto(region);
case "in-region":
case "cross-region":
case "mobile":
case "standard":
case "legacy":
return Promise.resolve(mode?.toLocaleLowerCase());
case undefined:
return Promise.resolve("legacy");
default:
throw new Error(`Invalid parameter for "defaultsMode", expect ${DEFAULTS_MODE_OPTIONS.join(", ")}, got ${mode}`);
}
});
var resolveNodeDefaultsModeAuto = async (clientRegion) => {
if (clientRegion) {
const resolvedRegion = typeof clientRegion === "function" ? await clientRegion() : clientRegion;
const inferredRegion = await inferPhysicalRegion();
if (!inferredRegion) {
return "standard";
}
if (resolvedRegion === inferredRegion) {
return "in-region";
} else {
return "cross-region";
}
}
return "standard";
};
var inferPhysicalRegion = async () => {
if (process.env[AWS_EXECUTION_ENV] && (process.env[AWS_REGION_ENV] || process.env[AWS_DEFAULT_REGION_ENV])) {
return process.env[AWS_REGION_ENV] ?? process.env[AWS_DEFAULT_REGION_ENV];
}
return getInstanceMetadataRegion();
};
exports.CONFIG_PREFIX_SEPARATOR = CONFIG_PREFIX_SEPARATOR;
exports.CONFIG_USE_DUALSTACK_ENDPOINT = CONFIG_USE_DUALSTACK_ENDPOINT;
exports.CONFIG_USE_FIPS_ENDPOINT = CONFIG_USE_FIPS_ENDPOINT;
exports.CredentialsProviderError = CredentialsProviderError;
exports.DEFAULT_PROFILE = DEFAULT_PROFILE;
exports.DEFAULT_USE_DUALSTACK_ENDPOINT = DEFAULT_USE_DUALSTACK_ENDPOINT;
exports.DEFAULT_USE_FIPS_ENDPOINT = DEFAULT_USE_FIPS_ENDPOINT;
exports.ENV_PROFILE = ENV_PROFILE;
exports.ENV_USE_DUALSTACK_ENDPOINT = ENV_USE_DUALSTACK_ENDPOINT;
exports.ENV_USE_FIPS_ENDPOINT = ENV_USE_FIPS_ENDPOINT;
exports.NODE_REGION_CONFIG_FILE_OPTIONS = NODE_REGION_CONFIG_FILE_OPTIONS;
exports.NODE_REGION_CONFIG_OPTIONS = NODE_REGION_CONFIG_OPTIONS;
exports.NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS = NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS;
exports.NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS = NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS;
exports.ProviderError = ProviderError;
exports.REGION_ENV_NAME = REGION_ENV_NAME;
exports.REGION_INI_NAME = REGION_INI_NAME;
exports.SelectorType = SelectorType;
exports.TokenProviderError = TokenProviderError;
exports.booleanSelector = booleanSelector;
exports.chain = chain;
exports.externalDataInterceptor = externalDataInterceptor;
exports.fromStatic = fromStatic;
exports.fromValue = fromValue;
exports.getHomeDir = getHomeDir;
exports.getProfileName = getProfileName;
exports.getRegionInfo = getRegionInfo;
exports.getSSOTokenFilepath = getSSOTokenFilepath;
exports.getSSOTokenFromFile = getSSOTokenFromFile;
exports.loadConfig = loadConfig;
exports.loadSharedConfigFiles = loadSharedConfigFiles;
exports.loadSsoSessionData = loadSsoSessionData;
exports.memoize = memoize;
exports.nodeDualstackConfigSelectors = nodeDualstackConfigSelectors;
exports.nodeFipsConfigSelectors = nodeFipsConfigSelectors;
exports.numberSelector = numberSelector;
exports.parseKnownFiles = parseKnownFiles;
exports.readFile = readFile;
exports.resolveCustomEndpointsConfig = resolveCustomEndpointsConfig;
exports.resolveDefaultsModeConfig = resolveDefaultsModeConfig;
exports.resolveEndpointsConfig = resolveEndpointsConfig;
exports.resolveRegionConfig = resolveRegionConfig;
});
// ../../node_modules/.bun/@smithy+core@3.33.3/node_modules/@smithy/core/dist-cjs/submodules/endpoints/index.js
var require_endpoints = __commonJS(function(exports) {
var { CONFIG_PREFIX_SEPARATOR, booleanSelector, SelectorType, loadConfig } = require_config();
var { toEndpointV1, getSmithyContext, normalizeProvider, isValidHostLabel, hasOwn } = require_transport();
exports.isValidHostLabel = isValidHostLabel;
exports.middlewareEndpointToEndpointV1 = toEndpointV1;
exports.toEndpointV1 = toEndpointV1;
var { EndpointURLScheme } = require_dist_cjs();
var ENV_ENDPOINT_URL = "AWS_ENDPOINT_URL";
var CONFIG_ENDPOINT_URL = "endpoint_url";
var getEndpointUrlConfig = (serviceId) => ({
environmentVariableSelector: (env) => {
const serviceSuffixParts = serviceId.split(" ").map((w) => w.toUpperCase());
const serviceEndpointUrl = env[[ENV_ENDPOINT_URL, ...serviceSuffixParts].join("_")];
if (serviceEndpointUrl)
return serviceEndpointUrl;
const endpointUrl = env[ENV_ENDPOINT_URL];
if (endpointUrl)
return endpointUrl;
return;
},
configFileSelector: (profile, config) => {
if (profile.services) {
const servicesSectionKey = ["services", profile.services].join(CONFIG_PREFIX_SEPARATOR);
if (!config || !config[servicesSectionKey]) {
throw new Error(`The services section "${profile.services}" specified in the profile is not present in the shared configuration file.`);
}
const servicesSection = config[servicesSectionKey];
const servicePrefixParts = serviceId.split(" ").map((w) => w.toLowerCase());
const endpointUrl = servicesSection[[servicePrefixParts.join("_"), CONFIG_ENDPOINT_URL].join(CONFIG_PREFIX_SEPARATOR)];
if (endpointUrl)
return endpointUrl;
}
const endpointUrl = profile[CONFIG_ENDPOINT_URL];
if (endpointUrl)
return endpointUrl;
return;
},
default: undefined
});
var ENV_IGNORE_CONFIGURED_ENDPOINT_URLS = "AWS_IGNORE_CONFIGURED_ENDPOINT_URLS";
var CONFIG_IGNORE_CONFIGURED_ENDPOINT_URLS = "ignore_configured_endpoint_urls";
var ignoreConfiguredEndpointUrlsConfigSelectors = {
environmentVariableSelector: (env) => booleanSelector(env, ENV_IGNORE_CONFIGURED_ENDPOINT_URLS, SelectorType.ENV),
configFileSelector: (profile) => booleanSelector(profile, CONFIG_IGNORE_CONFIGURED_ENDPOINT_URLS, SelectorType.CONFIG),
default: false
};
var getEndpointFromConfig = async (serviceId) => {
const ignore = await loadConfig(ignoreConfiguredEndpointUrlsConfigSelectors)();
if (ignore) {
return;
}
return loadConfig(getEndpointUrlConfig(serviceId ?? ""))();
};
var resolveParamsForS3 = async (endpointParams) => {
const bucket = endpointParams?.Bucket || "";
if (typeof endpointParams.Bucket === "string") {
endpointParams.Bucket = bucket.replace(/#/g, encodeURIComponent("#")).replace(/\?/g, encodeURIComponent("?"));
}
if (isArnBucketName(bucket)) {
if (endpointParams.ForcePathStyle === true) {
throw new Error("Path-style addressing cannot be used with ARN buckets");
}
} else if (!isDnsCompatibleBucketName(bucket) || bucket.indexOf(".") !== -1 && !String(endpointParams.Endpoint).startsWith("http:") || bucket.toLowerCase() !== bucket || bucket.length < 3) {
endpointParams.ForcePathStyle = true;
}
if (endpointParams.DisableMultiRegionAccessPoints) {
endpointParams.disableMultiRegionAccessPoints = true;
endpointParams.DisableMRAP = true;
}
return endpointParams;
};
var DOMAIN_PATTERN = /^[a-z0-9][a-z0-9.-]{1,61}[a-z0-9]$/;
var IP_ADDRESS_PATTERN = /(\d+\.){3}\d+/;
var DOTS_PATTERN = /\.\./;
var isDnsCompatibleBucketName = (bucketName) => DOMAIN_PATTERN.test(bucketName) && !IP_ADDRESS_PATTERN.test(bucketName) && !DOTS_PATTERN.test(bucketName);
var isArnBucketName = (bucketName) => {
const [arn, partition, service, , , bucket] = bucketName.split(":");
const isArn = arn === "arn" && bucketName.split(":").length >= 6;
const isValidArn = Boolean(isArn && partition && service && bucket);
if (isArn && !isValidArn) {
throw new Error(`Invalid ARN: ${bucketName} was an invalid ARN.`);
}
return isValidArn;
};
var createConfigValueProvider = (configKey, canonicalEndpointParamKey, config, isClientContextParam = false) => {
const configProvider = async () => {
let configValue;
if (isClientContextParam) {
const clientContextParams = config.clientContextParams;
const nestedValue = clientContextParams?.[configKey];
configValue = nestedValue ?? config[configKey] ?? config[canonicalEndpointParamKey];
} else {
configValue = config[configKey] ?? config[canonicalEndpointParamKey];
}
if (typeof configValue === "function") {
return configValue();
}
return configValue;
};
if (configKey === "credentialScope" || canonicalEndpointParamKey === "CredentialScope") {
return async () => {
const credentials = typeof config.credentials === "function" ? await config.credentials() : config.credentials;
const configValue = credentials?.credentialScope ?? credentials?.CredentialScope;
return configValue;
};
}
if (configKey === "accountId" || canonicalEndpointParamKey === "AccountId") {
return async () => {
const credentials = typeof config.credentials === "function" ? await config.credentials() : config.credentials;
const configValue = credentials?.accountId ?? credentials?.AccountId;
return configValue;
};
}
if (configKey === "endpoint" || canonicalEndpointParamKey === "endpoint") {
return async () => {
if (config.isCustomEndpoint === false) {
return;
}
const endpoint = await configProvider();
if (endpoint && typeof endpoint === "object") {
if ("url" in endpoint) {
return endpoint.url.href;
}
if ("hostname" in endpoint) {
const { protocol, hostname, port, path } = endpoint;
return `${protocol}//${hostname}${port ? ":" + port : ""}${path}`;
}
}
return endpoint;
};
}
return configProvider;
};
function bindGetEndpointFromInstructions(getEndpointFromConfig) {
return async (commandInput, instructionsSupplier, clientConfig, context) => {
if (!clientConfig.isCustomEndpoint && !clientConfig.ignoreConfiguredEndpointUrls) {
let endpointFromConfig;
if (clientConfig.serviceConfiguredEndpoint) {
endpointFromConfig = await clientConfig.serviceConfiguredEndpoint();
} else {
endpointFromConfig = await getEndpointFromConfig(clientConfig.serviceId);
}
if (endpointFromConfig) {
clientConfig.endpoint = () => Promise.resolve(toEndpointV1(endpointFromConfig));
clientConfig.isCustomEndpoint = true;
context?.logger?.debug?.(`@smithy/core/endpoints - resolved endpoint from config: ${endpointFromConfig}`);
}
}
const endpointParams = await resolveParams(commandInput, instructionsSupplier, clientConfig);
if (typeof clientConfig.endpointProvider !== "function") {
throw new Error("config.endpointProvider is not set.");
}
const endpoint = clientConfig.endpointProvider(endpointParams, context);
if (clientConfig.isCustomEndpoint && clientConfig.endpoint) {
const customEndpoint = await clientConfig.endpoint();
if (customEndpoint?.headers) {
endpoint.headers ??= {};
for (const [name, value] of Object.entries(customEndpoint.headers)) {
endpoint.headers[name] = Array.isArray(value) ? value : [value];
}
}
}
return endpoint;
};
}
var resolveParams = async (commandInput, instructionsSupplier, clientConfig) => {
const endpointParams = {};
const instructions = instructionsSupplier?.getEndpointParameterInstructions?.() || {};
for (const [name, instruction] of Object.entries(instructions)) {
switch (instruction.type) {
case "staticContextParams":
endpointParams[name] = instruction.value;
break;
case "contextParams":
endpointParams[name] = commandInput[instruction.name];
break;
case "clientContextParams":
case "builtInParams":
endpointParams[name] = await createConfigValueProvider(instruction.name, name, clientConfig, instruction.type !== "builtInParams")();
break;
case "operationContextParams":
endpointParams[name] = instruction.get(commandInput);
break;
default:
throw new Error("Unrecognized endpoint parameter instruction: " + JSON.stringify(instruction));
}
}
if (Object.keys(instructions).length === 0) {
Object.assign(endpointParams, clientConfig);
}
if (String(clientConfig.serviceId).toLowerCase() === "s3") {
await resolveParamsForS3(endpointParams);
}
return endpointParams;
};
function setFeature(context, feature, value) {
if (!context.__smithy_context) {
context.__smithy_context = { features: {} };
} else if (!context.__smithy_context.features) {
context.__smithy_context.features = {};
}
context.__smithy_context.features[feature] = value;
}
function bindEndpointMiddleware(getEndpointFromConfig) {
const getEndpointFromInstructions = bindGetEndpointFromInstructions(getEndpointFromConfig);
return ({ config, instructions }) => {
return (next, context) => async (args) => {
if (config.isCustomEndpoint) {
setFeature(context, "ENDPOINT_OVERRIDE", "N");
}
const endpoint = await getEndpointFromInstructions(args.input, {
getEndpointParameterInstructions() {
return instructions;
}
}, { ...config }, context);
context.endpointV2 = endpoint;
context.authSchemes = endpoint.properties?.authSchemes;
const authScheme = context.authSchemes?.[0];
if (authScheme) {
context["signing_region"] = authScheme.signingRegion;
context["signing_service"] = authScheme.signingName;
const smithyContext = getSmithyContext(context);
const httpAuthOption = smithyContext?.selectedHttpAuthScheme?.httpAuthOption;
if (httpAuthOption) {
httpAuthOption.signingProperties = Object.assign(httpAuthOption.signingProperties || {}, {
signing_region: authScheme.signingRegion,
signingRegion: authScheme.signingRegion,
signing_service: authScheme.signingName,
signingName: authScheme.signingName,
signingRegionSet: authScheme.signingRegionSet
}, authScheme.properties);
}
}
return next({
...args
});
};
};
}
var serializerMiddlewareOption = {
name: "serializerMiddleware"
};
var endpointMiddlewareOptions = {
step: "serialize",
tags: ["ENDPOINT_PARAMETERS", "ENDPOINT_V2", "ENDPOINT"],
name: "endpointV2Middleware",
override: true,
relation: "before",
toMiddleware: serializerMiddlewareOption.name
};
function bindGetEndpointPlugin(getEndpointFromConfig) {
const endpointMiddleware = bindEndpointMiddleware(getEndpointFromConfig);
return (config, instructions) => ({
applyToStack: (clientStack) => {
clientStack.addRelativeTo(endpointMiddleware({
config,
instructions
}), endpointMiddlewareOptions);
}
});
}
function bindResolveEndpointConfig(getEndpointFromConfig) {
return (input) => {
const tls = input.tls ?? true;
const { endpoint, useDualstackEndpoint, useFipsEndpoint } = input;
const customEndpointProvider = endpoint != null ? async () => toEndpointV1(await normalizeProvider(endpoint)()) : undefined;
const isCustomEndpoint = !!endpoint;
const resolvedConfig = Object.assign(input, {
endpoint: customEndpointProvider,
tls,
isCustomEndpoint,
useDualstackEndpoint: normalizeProvider(useDualstackEndpoint ?? false),
useFipsEndpoint: normalizeProvider(useFipsEndpoint ?? false),
ignoreConfiguredEndpointUrls: !!input.ignoreConfiguredEndpointUrls
});
let configuredEndpointPromise = undefined;
resolvedConfig.serviceConfiguredEndpoint = async () => {
if (input.serviceId && !configuredEndpointPromise) {
configuredEndpointPromise = getEndpointFromConfig(input.serviceId);
}
return configuredEndpointPromise;
};
return resolvedConfig;
};
}
class BinaryDecisionDiagram {
nodes;
root;
conditions;
results;
constructor(bdd, root, conditions, results) {
this.nodes = bdd;
this.root = root;
this.conditions = conditions;
this.results = results;
}
static from(bdd, root, conditions, results) {
return new BinaryDecisionDiagram(bdd, root, conditions, results);
}
}
class EndpointCache {
capacity;
data = new Map;
parameters = [];
constructor({ size, params }) {
this.capacity = size ?? 50;
if (params) {
this.parameters = params;
}
}
get(endpointParams, resolver) {
const key = this.hash(endpointParams);
if (key === false) {
return resolver();
}
if (!this.data.has(key)) {
if (this.data.size > this.capacity + 10) {
const keys = this.data.keys();
let i = 0;
while (true) {
const { value, done } = keys.next();
this.data.delete(value);
if (done || ++i > 10) {
break;
}
}
}
this.data.set(key, resolver());
}
return this.data.get(key);
}
size() {
return this.data.size;
}
hash(endpointParams) {
let buffer = "";
const { parameters } = this;
if (parameters.length === 0) {
return false;
}
for (const param of parameters) {
const val = String(endpointParams[param] ?? "");
if (val.includes("|;")) {
return false;
}
buffer += val + "|;";
}
return buffer;
}
}
class EndpointError extends Error {
constructor(message) {
super(message);
this.name = "EndpointError";
}
}
var debugId = "endpoints";
function toDebugString(input) {
if (typeof input !== "object" || input == null) {
return input;
}
if ("ref" in input) {
return `$${toDebugString(input.ref)}`;
}
if ("fn" in input) {
return `${input.fn}(${(input.argv || []).map(toDebugString).join(", ")})`;
}
return JSON.stringify(input, null, 2);
}
var customEndpointFunctions = {};
var booleanEquals = (value1, value2) => value1 === value2;
function coalesce(...args) {
for (const arg of args) {
if (arg != null) {
return arg;
}
}
return;
}
var getAttrPathList = (path) => {
const parts = path.split(".");
const pathList = [];
for (const part of parts) {
const squareBracketIndex = part.indexOf("[");
if (squareBracketIndex !== -1) {
if (part.indexOf("]") !== part.length - 1) {
throw new EndpointError(`Path: '${path}' does not end with ']'`);
}
const arrayIndex = part.slice(squareBracketIndex + 1, -1);
if (Number.isNaN(parseInt(arrayIndex))) {
throw new EndpointError(`Invalid array index: '${arrayIndex}' in path: '${path}'`);
}
if (squareBracketIndex !== 0) {
pathList.push(part.slice(0, squareBracketIndex));
}
pathList.push(arrayIndex);
} else {
pathList.push(part);
}
}
return pathList;
};
var getAttr = (value, path) => getAttrPathList(path).reduce((acc, index) => {
if (typeof acc !== "object") {
throw new EndpointError(`Index '${index}' in '${path}' not found in '${JSON.stringify(value)}'`);
} else if (Array.isArray(acc)) {
const i = parseInt(index);
return acc[i < 0 ? acc.length + i : i];
}
return acc[index];
}, value);
var isSet = (value) => value != null;
function ite(condition, trueValue, falseValue) {
return condition ? trueValue : falseValue;
}
var not = (value) => !value;
var IP_V4_REGEX = new RegExp(`^(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)(?:\\.(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]\\d|\\d)){3}$`);
var isIpAddress = (value) => IP_V4_REGEX.test(value) || value.startsWith("[") && value.endsWith("]");
var DEFAULT_PORTS = {
[EndpointURLScheme.HTTP]: 80,
[EndpointURLScheme.HTTPS]: 443
};
var parseURL = (value) => {
const whatwgURL = (() => {
try {
if (value instanceof URL) {
return value;
}
if (typeof value === "object" && "hostname" in value) {
const { hostname, port, protocol = "", path = "", query = {} } = value;
const url = new URL(`${protocol}//${hostname}${port ? `:${port}` : ""}${path}`);
url.search = Object.entries(query).map(([k, v]) => `${k}=${v}`).join("&");
return url;
}
return new URL(value);
} catch (ignored) {
return null;
}
})();
if (!whatwgURL) {
console.error(`Unable to parse ${JSON.stringify(value)} as a whatwg URL.`);
return null;
}
const urlString = whatwgURL.href;
const { host, hostname, pathname, protocol, search } = whatwgURL;
if (search) {
return null;
}
const scheme = protocol.slice(0, -1);
if (!Object.values(EndpointURLScheme).includes(scheme)) {
return null;
}
const isIp = isIpAddress(hostname);
const inputContainsDefaultPort = urlString.includes(`${host}:${DEFAULT_PORTS[scheme]}`) || typeof value === "string" && value.includes(`${host}:${DEFAULT_PORTS[scheme]}`);
const authority = `${host}${inputContainsDefaultPort ? `:${DEFAULT_PORTS[scheme]}` : ``}`;
return {
scheme,
authority,
path: pathname,
normalizedPath: pathname.endsWith("/") ? pathname : `${pathname}/`,
isIp
};
};
function split(value, delimiter, limit) {
if (limit === 1) {
return [value];
}
if (value === "") {
return [""];
}
const parts = value.split(delimiter);
if (limit === 0) {
return parts;
}
return parts.slice(0, limit - 1).concat(parts.slice(1).join(delimiter));
}
var stringEquals = (value1, value2) => value1 === value2;
var substring = (input, start, stop, reverse) => {
if (input == null || start >= stop || input.length < stop || /[^\u0000-\u007f]/.test(input)) {
return null;
}
if (!reverse) {
return input.substring(start, stop);
}
return input.substring(input.length - stop, input.length - start);
};
var uriEncode = (value) => encodeURIComponent(value).replace(/[!*'()]/g, (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
var endpointFunctions = {
booleanEquals,
coalesce,
getAttr,
isSet,
isValidHostLabel,
ite,
not,
parseURL,
split,
stringEquals,
substring,
uriEncode
};
var evaluateTemplate = (template, options) => {
const evaluatedTemplateArr = [];
const { referenceRecord, endpointParams } = options;
let currentIndex = 0;
while (currentIndex < template.length) {
const openingBraceIndex = template.indexOf("{", currentIndex);
if (openingBraceIndex === -1) {
evaluatedTemplateArr.push(template.slice(currentIndex));
break;
}
evaluatedTemplateArr.push(template.slice(currentIndex, openingBraceIndex));
const closingBraceIndex = template.indexOf("}", openingBraceIndex);
if (closingBraceIndex === -1) {
evaluatedTemplateArr.push(template.slice(openingBraceIndex));
break;
}
if (template[openingBraceIndex + 1] === "{" && template[closingBraceIndex + 1] === "}") {
evaluatedTemplateArr.push(template.slice(openingBraceIndex + 1, closingBraceIndex));
currentIndex = closingBraceIndex + 2;
}
const parameterName = template.substring(openingBraceIndex + 1, closingBraceIndex);
if (parameterName.includes("#")) {
const [refName, attrName] = parameterName.split("#");
evaluatedTemplateArr.push(getAttr(referenceRecord[refName] ?? endpointParams[refName], attrName));
} else {
evaluatedTemplateArr.push(referenceRecord[parameterName] ?? endpointParams[parameterName]);
}
currentIndex = closingBraceIndex + 1;
}
return evaluatedTemplateArr.join("");
};
var getReferenceValue = ({ ref }, options) => {
return options.referenceRecord[ref] ?? options.endpointParams[ref];
};
var evaluateExpression = (obj, keyName, options) => {
if (typeof obj === "string") {
return evaluateTemplate(obj, options);
} else if (obj["fn"]) {
return group$2.callFunction(obj, options);
} else if (obj["ref"]) {
return getReferenceValue(obj, options);
}
throw new EndpointError(`'${keyName}': ${String(obj)} is not a string, function or reference.`);
};
var callFunction = ({ fn, argv }, options) => {
const evaluatedArgs = Array(argv.length);
for (let i = 0;i < evaluatedArgs.length; ++i) {
const arg = argv[i];
if (typeof arg === "boolean" || typeof arg === "number") {
evaluatedArgs[i] = arg;
} else {
evaluatedArgs[i] = group$2.evaluateExpression(arg, "arg", options);
}
}
const namespaceSeparatorIndex = fn.indexOf(".");
if (namespaceSeparatorIndex !== -1) {
const namespaceFunctions = customEndpointFunctions[fn.slice(0, namespaceSeparatorIndex)];
const customFunction = namespaceFunctions?.[fn.slice(namespaceSeparatorIndex + 1)];
if (typeof customFunction === "function") {
return customFunction(...evaluatedArgs);
}
}
const callable = endpointFunctions[fn];
if (typeof callable === "function") {
return callable(...evaluatedArgs);
}
throw new Error(`function ${fn} not loaded in endpointFunctions.`);
};
var group$2 = {
evaluateExpression,
callFunction
};
var evaluateCondition = (condition, options) => {
const { assign } = condition;
if (assign && assign in options.referenceRecord) {
throw new EndpointError(`'${assign}' is already defined in Reference Record.`);
}
const value = callFunction(condition, options);
options.logger?.debug?.(`${debugId} evaluateCondition: ${toDebugString(condition)} = ${toDebugString(value)}`);
const result = value === "" ? true : !!value;
if (assign != null) {
return { result, toAssign: { name: assign, value } };
}
return { result };
};
var getEndpointHeaders = (headers, options) => Object.entries(headers ?? {}).reduce((acc, [headerKey, headerVal]) => {
acc[headerKey] = headerVal.map((headerValEntry) => {
const processedExpr = evaluateExpression(headerValEntry, "Header value entry", options);
if (typeof processedExpr !== "string") {
throw new EndpointError(`Header '${headerKey}' value '${processedExpr}' is not a string`);
}
return processedExpr;
});
return acc;
}, {});
var getEndpointProperties = (properties, options) => Object.entries(properties).reduce((acc, [propertyKey, propertyVal]) => {
acc[propertyKey] = group$1.getEndpointProperty(propertyVal, options);
return acc;
}, {});
var getEndpointProperty = (property, options) => {
if (Array.isArray(property)) {
return property.map((propertyEntry) => getEndpointProperty(propertyEntry, options));
}
switch (typeof property) {
case "string":
return evaluateTemplate(property, options);
case "object":
if (property === null) {
throw new EndpointError(`Unexpected endpoint property: ${property}`);
}
return group$1.getEndpointProperties(property, options);
case "boolean":
return property;
default:
throw new EndpointError(`Unexpected endpoint property type: ${typeof property}`);
}
};
var group$1 = {
getEndpointProperty,
getEndpointProperties
};
var getEndpointUrl = (endpointUrl, options) => {
const expression = evaluateExpression(endpointUrl, "Endpoint URL", options);
if (typeof expression === "string") {
try {
return new URL(expression);
} catch (error) {
console.error(`Failed to construct URL with ${expression}`, error);
throw error;
}
}
throw new EndpointError(`Endpoint URL must be a string, got ${typeof expression}`);
};
var RESULT = 1e8;
var decideEndpoint = (bdd, options) => {
const { nodes, root, results, conditions } = bdd;
let ref = root;
const referenceRecord = {};
const closure = {
referenceRecord,
endpointParams: options.endpointParams,
logger: options.logger
};
while (ref !== 1 && ref !== -1 && ref < RESULT) {
const node_i = 3 * (Math.abs(ref) - 1);
const [condition_i, highRef, lowRef] = [nodes[node_i], nodes[node_i + 1], nodes[node_i + 2]];
const [fn, argv, assign] = conditions[condition_i];
const evaluation = evaluateCondition({ fn, assign, argv }, closure);
if (evaluation.toAssign) {
const { name, value } = evaluation.toAssign;
referenceRecord[name] = value;
}
ref = ref >= 0 === evaluation.result ? highRef : lowRef;
}
if (ref >= RESULT) {
const result = results[ref - RESULT];
if (result[0] === -1) {
const [, errorExpression] = result;
throw new EndpointError(evaluateExpression(errorExpression, "Error", closure));
}
const [url, properties, headers] = result;
return {
url: getEndpointUrl(url, closure),
properties: getEndpointProperties(properties, closure),
headers: getEndpointHeaders(headers ?? {}, closure)
};
}
throw new EndpointError(`No matching endpoint.`);
};
var evaluateConditions = (conditions = [], options) => {
const conditionsReferenceRecord = {};
const conditionOptions = {
...options,
referenceRecord: { ...options.referenceRecord }
};
let didAssign = false;
for (const condition of conditions) {
const { result, toAssign } = evaluateCondition(condition, conditionOptions);
if (!result) {
return { result };
}
if (toAssign) {
didAssign = true;
conditionsReferenceRecord[toAssign.name] = toAssign.value;
conditionOptions.referenceRecord[toAssign.name] = toAssign.value;
options.logger?.debug?.(`${debugId} assign: ${toAssign.name} := ${toDebugString(toAssign.value)}`);
}
}
if (didAssign) {
return { result: true, referenceRecord: conditionsReferenceRecord };
}
return { result: true };
};
var evaluateEndpointRule = (endpointRule, options) => {
const { conditions, endpoint } = endpointRule;
const { result, referenceRecord } = evaluateConditions(conditions, options);
if (!result) {
return;
}
const endpointRuleOptions = referenceRecord ? {
...options,
referenceRecord: { ...options.referenceRecord, ...referenceRecord }
} : options;
const { url, properties, headers } = endpoint;
options.logger?.debug?.(`${debugId} Resolving endpoint from template: ${toDebugString(endpoint)}`);
const endpointToReturn = { url: getEndpointUrl(url, endpointRuleOptions) };
if (headers != null) {
endpointToReturn.headers = getEndpointHeaders(headers, endpointRuleOptions);
}
if (properties != null) {
endpointToReturn.properties = getEndpointProperties(properties, endpointRuleOptions);
}
return endpointToReturn;
};
var evaluateErrorRule = (errorRule, options) => {
const { conditions, error } = errorRule;
const { result, referenceRecord } = evaluateConditions(conditions, options);
if (!result) {
return;
}
const errorRuleOptions = referenceRecord ? {
...options,
referenceRecord: { ...options.referenceRecord, ...referenceRecord }
} : options;
throw new EndpointError(evaluateExpression(error, "Error", errorRuleOptions));
};
var evaluateRules = (rules, options) => {
for (const rule of rules) {
if (rule.type === "endpoint") {
const endpointOrUndefined = evaluateEndpointRule(rule, options);
if (endpointOrUndefined) {
return endpointOrUndefined;
}
} else if (rule.type === "error") {
evaluateErrorRule(rule, options);
} else if (rule.type === "tree") {
const endpointOrUndefined = group.evaluateTreeRule(rule, options);
if (endpointOrUndefined) {
return endpointOrUndefined;
}
} else {
throw new EndpointError(`Unknown endpoint rule: ${rule}`);
}
}
throw new EndpointError(`Rules evaluation failed`);
};
var evaluateTreeRule = (treeRule, options) => {
const { conditions, rules } = treeRule;
const { result, referenceRecord } = evaluateConditions(conditions, options);
if (!result) {
return;
}
const treeRuleOptions = referenceRecord ? { ...options, referenceRecord: { ...options.referenceRecord, ...referenceRecord } } : options;
return group.evaluateRules(rules, treeRuleOptions);
};
var group = {
evaluateRules,
evaluateTreeRule
};
var resolveEndpoint = (ruleSetObject, options) => {
const { endpointParams, logger } = options;
const { parameters, rules } = ruleSetObject;
options.logger?.debug?.(`${debugId} Initial EndpointParams: ${toDebugString(endpointParams)}`);
for (const paramKey in parameters) {
if (!hasOwn(parameters, paramKey))
continue;
const parameter = parameters[paramKey];
const endpointParam = endpointParams[paramKey];
if (endpointParam == null && parameter.default != null) {
endpointParams[paramKey] = parameter.default;
continue;
}
if (parameter.required && endpointParam == null) {
throw new EndpointError(`Missing required parameter: '${paramKey}'`);
}
}
const endpoint = evaluateRules(rules, { endpointParams, logger, referenceRecord: {} });
options.logger?.debug?.(`${debugId} Resolved endpoint: ${toDebugString(endpoint)}`);
return endpoint;
};
var resolveEndpointRequiredConfig = (input) => {
const { endpoint } = input;
if (endpoint === undefined) {
input.endpoint = async () => {
throw new Error("@smithy/middleware-endpoint: (default endpointRuleSet) endpoint is not set - you must configure an endpoint.");
};
}
return input;
};
var getEndpointFromInstructions = bindGetEndpointFromInstructions(getEndpointFromConfig);
var resolveEndpointConfig = bindResolveEndpointConfig(getEndpointFromConfig);
var endpointMiddleware = bindEndpointMiddleware(getEndpointFromConfig);
var getEndpointPlugin = bindGetEndpointPlugin(getEndpointFromConfig);
exports.BinaryDecisionDiagram = BinaryDecisionDiagram;
exports.EndpointCache = EndpointCache;
exports.EndpointError = EndpointError;
exports.customEndpointFunctions = customEndpointFunctions;
exports.decideEndpoint = decideEndpoint;
exports.endpointMiddleware = endpointMiddleware;
exports.endpointMiddlewareOptions = endpointMiddlewareOptions;
exports.getEndpointFromInstructions = getEndpointFromInstructions;
exports.getEndpointPlugin = getEndpointPlugin;
exports.isIpAddress = isIpAddress;
exports.resolveEndpoint = resolveEndpoint;
exports.resolveEndpointConfig = resolveEndpointConfig;
exports.resolveEndpointRequiredConfig = resolveEndpointRequiredConfig;
exports.resolveParams = resolveParams;
});
// ../../node_modules/.bun/@smithy+core@3.33.3/node_modules/@smithy/core/dist-cjs/submodules/serde/index.js
var require_serde = __commonJS(function(exports) {
var { createHmac, createHash, getRandomValues } = __require("crypto");
var { hasOwn, HttpResponse } = require_transport();
exports.hasOwn = hasOwn;
var { ReadStream, lstatSync, fstatSync } = __require("fs");
var { toEndpointV1 } = require_endpoints();
var { Readable, Writable, PassThrough } = __require("stream");
var isArrayBuffer = (arg) => typeof ArrayBuffer === "function" && arg instanceof ArrayBuffer || Object.prototype.toString.call(arg) === "[object ArrayBuffer]";
var fromArrayBuffer = (input, offset = 0, length = input.byteLength - offset) => {
if (!isArrayBuffer(input)) {
throw new TypeError(`The "input" argument must be ArrayBuffer. Received type ${typeof input} (${input})`);
}
return Buffer.from(input, offset, length);
};
var fromString = (input, encoding) => {
if (typeof input !== "string") {
throw new TypeError(`The "input" argument must be of type string. Received type ${typeof input} (${input})`);
}
return encoding ? Buffer.from(input, encoding) : Buffer.from(input);
};
var BASE64_REGEX = /^[A-Za-z0-9+/]*={0,2}$/;
var fromBase64 = (input) => {
if (input.length * 3 % 4 !== 0) {
throw new TypeError(`Incorrect padding on base64 string.`);
}
if (!BASE64_REGEX.exec(input)) {
throw new TypeError(`Invalid base64 string.`);
}
const buffer = fromString(input, "base64");
return new Uint8Array(buffer.buffer, buffer.byteOffset, buffer.byteLength);
};
var fromUtf8$1 = (input) => {
const buf = fromString(input, "utf8");
return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength / Uint8Array.BYTES_PER_ELEMENT);
};
var toBase64$1 = (_input) => {
let input;
if (typeof _input === "string") {
input = fromUtf8$1(_input);
} else {
input = _input;
}
if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
throw new Error("@smithy/util-base64: toBase64 encoder function only accepts string | Uint8Array.");
}
return fromArrayBuffer(input.buffer, input.byteOffset, input.byteLength).toString("base64");
};
function bindUint8ArrayBlobAdapter(toUtf8, fromUtf8, toBase64, fromBase64) {
return class Uint8ArrayBlobAdapter extends Uint8Array {
static fromString(source, encoding = "utf-8") {
if (typeof source === "string") {
if (encoding === "base64") {
return Uint8ArrayBlobAdapter.mutate(fromBase64(source));
}
return Uint8ArrayBlobAdapter.mutate(fromUtf8(source));
}
throw new Error(`Unsupported conversion from ${typeof source} to Uint8ArrayBlobAdapter.`);
}
static mutate(source) {
Object.setPrototypeOf(source, Uint8ArrayBlobAdapter.prototype);
return source;
}
transformToString(encoding = "utf-8") {
if (encoding === "base64") {
return toBase64(this);
}
return toUtf8(this);
}
};
}
var toUtf8$1 = (input) => {
if (typeof input === "string") {
return input;
}
if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
throw new Error("@smithy/util-utf8: toUtf8 encoder function only accepts string | Uint8Array.");
}
return fromArrayBuffer(input.buffer, input.byteOffset, input.byteLength).toString("utf8");
};
var decimalToHex = Array.from({ length: 256 }, (_, i) => i.toString(16).padStart(2, "0"));
function bindV4(getRandomValues) {
if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
return () => crypto.randomUUID();
}
return () => {
const rnds = new Uint8Array(16);
getRandomValues(rnds);
rnds[6] = rnds[6] & 15 | 64;
rnds[8] = rnds[8] & 63 | 128;
return decimalToHex[rnds[0]] + decimalToHex[rnds[1]] + decimalToHex[rnds[2]] + decimalToHex[rnds[3]] + "-" + decimalToHex[rnds[4]] + decimalToHex[rnds[5]] + "-" + decimalToHex[rnds[6]] + decimalToHex[rnds[7]] + "-" + decimalToHex[rnds[8]] + decimalToHex[rnds[9]] + "-" + decimalToHex[rnds[10]] + decimalToHex[rnds[11]] + decimalToHex[rnds[12]] + decimalToHex[rnds[13]] + decimalToHex[rnds[14]] + decimalToHex[rnds[15]];
};
}
var copyDocumentWithTransform = (source, _schemaRef, _transform = (_) => _) => source;
var parseBoolean = (value) => {
switch (value) {
case "true":
return true;
case "false":
return false;
default:
throw new Error(`Unable to parse boolean value "${value}"`);
}
};
var expectBoolean = (value) => {
if (value === null || value === undefined) {
return;
}
if (typeof value === "number") {
if (value === 0 || value === 1) {
logger.warn(stackTraceWarning(`Expected boolean, got ${typeof value}: ${value}`));
}
if (value === 0) {
return false;
}
if (value === 1) {
return true;
}
}
if (typeof value === "string") {
const lower = value.toLowerCase();
if (lower === "false" || lower === "true") {
logger.warn(stackTraceWarning(`Expected boolean, got ${typeof value}: ${value}`));
}
if (lower === "false") {
return false;
}
if (lower === "true") {
return true;
}
}
if (typeof value === "boolean") {
return value;
}
throw new TypeError(`Expected boolean, got ${typeof value}: ${value}`);
};
var expectNumber = (value) => {
if (value === null || value === undefined) {
return;
}
if (typeof value === "string") {
const parsed = parseFloat(value);
if (!Number.isNaN(parsed)) {
if (String(parsed) !== String(value)) {
logger.warn(stackTraceWarning(`Expected number but observed string: ${value}`));
}
return parsed;
}
}
if (typeof value === "number") {
return value;
}
throw new TypeError(`Expected number, got ${typeof value}: ${value}`);
};
var MAX_FLOAT = Math.ceil(2 ** 127 * (2 - 2 ** -23));
var expectFloat32 = (value) => {
const expected = expectNumber(value);
if (expected !== undefined && !Number.isNaN(expected) && expected !== Infinity && expected !== -Infinity) {
if (Math.abs(expected) > MAX_FLOAT) {
throw new TypeError(`Expected 32-bit float, got ${value}`);
}
}
return expected;
};
var expectLong = (value) => {
if (value === null || value === undefined) {
return;
}
if (Number.isInteger(value) && !Number.isNaN(value)) {
return value;
}
throw new TypeError(`Expected integer, got ${typeof value}: ${value}`);
};
var expectInt = expectLong;
var expectInt32 = (value) => expectSizedInt(value, 32);
var expectShort = (value) => expectSizedInt(value, 16);
var expectByte = (value) => expectSizedInt(value, 8);
var expectSizedInt = (value, size) => {
const expected = expectLong(value);
if (expected !== undefined && castInt(expected, size) !== expected) {
throw new TypeError(`Expected ${size}-bit integer, got ${value}`);
}
return expected;
};
var castInt = (value, size) => {
switch (size) {
case 32:
return Int32Array.of(value)[0];
case 16:
return Int16Array.of(value)[0];
case 8:
return Int8Array.of(value)[0];
}
};
var expectNonNull = (value, location) => {
if (value === null || value === undefined) {
if (location) {
throw new TypeError(`Expected a non-null value for ${location}`);
}
throw new TypeError("Expected a non-null value");
}
return value;
};
var expectObject = (value) => {
if (value === null || value === undefined) {
return;
}
if (typeof value === "object" && !Array.isArray(value)) {
return value;
}
const receivedType = Array.isArray(value) ? "array" : typeof value;
throw new TypeError(`Expected object, got ${receivedType}: ${value}`);
};
var expectString = (value) => {
if (value === null || value === undefined) {
return;
}
if (typeof value === "string") {
return value;
}
if (["boolean", "number", "bigint"].includes(typeof value)) {
logger.warn(stackTraceWarning(`Expected string, got ${typeof value}: ${value}`));
return String(value);
}
throw new TypeError(`Expected string, got ${typeof value}: ${value}`);
};
var expectUnion = (value) => {
if (value === null || value === undefined) {
return;
}
const asObject = expectObject(value);
const setKeys = [];
for (const k in asObject) {
if (!hasOwn(asObject, k))
continue;
if (asObject[k] != null) {
setKeys.push(k);
}
}
if (setKeys.length === 0) {
throw new TypeError(`Unions must have exactly one non-null member. None were found.`);
}
if (setKeys.length > 1) {
throw new TypeError(`Unions must have exactly one non-null member. Keys ${setKeys} were not null.`);
}
return asObject;
};
var strictParseDouble = (value) => {
if (typeof value == "string") {
return expectNumber(parseNumber(value));
}
return expectNumber(value);
};
var strictParseFloat = strictParseDouble;
var strictParseFloat32 = (value) => {
if (typeof value == "string") {
return expectFloat32(parseNumber(value));
}
return expectFloat32(value);
};
var NUMBER_REGEX = /(-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)|(-?Infinity)|(NaN)/g;
var parseNumber = (value) => {
const matches = value.match(NUMBER_REGEX);
if (matches === null || matches[0].length !== value.length) {
throw new TypeError(`Expected real number, got implicit NaN`);
}
return parseFloat(value);
};
var limitedParseDouble = (value) => {
if (typeof value == "string") {
return parseFloatString(value);
}
return expectNumber(value);
};
var handleFloat = limitedParseDouble;
var limitedParseFloat = limitedParseDouble;
var limitedParseFloat32 = (value) => {
if (typeof value == "string") {
return parseFloatString(value);
}
return expectFloat32(value);
};
var parseFloatString = (value) => {
switch (value) {
case "NaN":
return NaN;
case "Infinity":
return Infinity;
case "-Infinity":
return -Infinity;
default:
throw new Error(`Unable to parse float value: ${value}`);
}
};
var strictParseLong = (value) => {
if (typeof value === "string") {
return expectLong(parseNumber(value));
}
return expectLong(value);
};
var strictParseInt = strictParseLong;
var strictParseInt32 = (value) => {
if (typeof value === "string") {
return expectInt32(parseNumber(value));
}
return expectInt32(value);
};
var strictParseShort = (value) => {
if (typeof value === "string") {
return expectShort(parseNumber(value));
}
return expectShort(value);
};
var strictParseByte = (value) => {
if (typeof value === "string") {
return expectByte(parseNumber(value));
}
return expectByte(value);
};
var stackTraceWarning = (message) => {
return String(new TypeError(message).stack || message).split(`
`).slice(0, 5).filter((s) => !s.includes("stackTraceWarning")).join(`
`);
};
var logger = {
warn: console.warn
};
var DAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
var MONTHS = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
function dateToUtcString(date) {
const year = date.getUTCFullYear();
const month = date.getUTCMonth();
const dayOfWeek = date.getUTCDay();
const dayOfMonthInt = date.getUTCDate();
const hoursInt = date.getUTCHours();
const minutesInt = date.getUTCMinutes();
const secondsInt = date.getUTCSeconds();
const dayOfMonthString = dayOfMonthInt < 10 ? `0${dayOfMonthInt}` : `${dayOfMonthInt}`;
const hoursString = hoursInt < 10 ? `0${hoursInt}` : `${hoursInt}`;
const minutesString = minutesInt < 10 ? `0${minutesInt}` : `${minutesInt}`;
const secondsString = secondsInt < 10 ? `0${secondsInt}` : `${secondsInt}`;
return `${DAYS[dayOfWeek]}, ${dayOfMonthString} ${MONTHS[month]} ${year} ${hoursString}:${minutesString}:${secondsString} GMT`;
}
var RFC3339 = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?[zZ]$/);
var parseRfc3339DateTime = (value) => {
if (value === null || value === undefined) {
return;
}
if (typeof value !== "string") {
throw new TypeError("RFC-3339 date-times must be expressed as strings");
}
const match = RFC3339.exec(value);
if (!match) {
throw new TypeError("Invalid RFC-3339 date-time value");
}
const [_, yearStr, monthStr, dayStr, hours, minutes, seconds, fractionalMilliseconds] = match;
const year = strictParseShort(stripLeadingZeroes(yearStr));
const month = parseDateValue(monthStr, "month", 1, 12);
const day = parseDateValue(dayStr, "day", 1, 31);
return buildDate(year, month, day, { hours, minutes, seconds, fractionalMilliseconds });
};
var RFC3339_WITH_OFFSET$1 = new RegExp(/^(\d{4})-(\d{2})-(\d{2})[tT](\d{2}):(\d{2}):(\d{2})(?:\.(\d+))?(([-+]\d{2}:\d{2})|[zZ])$/);
var parseRfc3339DateTimeWithOffset = (value) => {
if (value === null || value === undefined) {
return;
}
if (typeof value !== "string") {
throw new TypeError("RFC-3339 date-times must be expressed as strings");
}
const match = RFC3339_WITH_OFFSET$1.exec(value);
if (!match) {
throw new TypeError("Invalid RFC-3339 date-time value");
}
const [_, yearStr, monthStr, dayStr, hours, minutes, seconds, fractionalMilliseconds, offsetStr] = match;
const year = strictParseShort(stripLeadingZeroes(yearStr));
const month = parseDateValue(monthStr, "month", 1, 12);
const day = parseDateValue(dayStr, "day", 1, 31);
const date = buildDate(year, month, day, { hours, minutes, seconds, fractionalMilliseconds });
if (offsetStr.toUpperCase() != "Z") {
date.setTime(date.getTime() - parseOffsetToMilliseconds(offsetStr));
}
return date;
};
var IMF_FIXDATE$1 = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), (\d{2}) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) (\d{4}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/);
var RFC_850_DATE$1 = new RegExp(/^(?:Monday|Tuesday|Wednesday|Thursday|Friday|Saturday|Sunday), (\d{2})-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-(\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? GMT$/);
var ASC_TIME$1 = new RegExp(/^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) ( [1-9]|\d{2}) (\d{1,2}):(\d{2}):(\d{2})(?:\.(\d+))? (\d{4})$/);
var parseRfc7231DateTime = (value) => {
if (value === null || value === undefined) {
return;
}
if (typeof value !== "string") {
throw new TypeError("RFC-7231 date-times must be expressed as strings");
}
let match = IMF_FIXDATE$1.exec(value);
if (match) {
const [_, dayStr, monthStr, yearStr, hours, minutes, seconds, fractionalMilliseconds] = match;
return buildDate(strictParseShort(stripLeadingZeroes(yearStr)), parseMonthByShortName(monthStr), parseDateValue(dayStr, "day", 1, 31), { hours, minutes, seconds, fractionalMilliseconds });
}
match = RFC_850_DATE$1.exec(value);
if (match) {
const [_, dayStr, monthStr, yearStr, hours, minutes, seconds, fractionalMilliseconds] = match;
return adjustRfc850Year(buildDate(parseTwoDigitYear(yearStr), parseMonthByShortName(monthStr), parseDateValue(dayStr, "day", 1, 31), {
hours,
minutes,
seconds,
fractionalMilliseconds
}));
}
match = ASC_TIME$1.exec(value);
if (match) {
const [_, monthStr, dayStr, hours, minutes, seconds, fractionalMilliseconds, yearStr] = match;
return buildDate(strictParseShort(stripLeadingZeroes(yearStr)), parseMonthByShortName(monthStr), parseDateValue(dayStr.trimLeft(), "day", 1, 31), { hours, minutes, seconds, fractionalMilliseconds });
}
throw new TypeError("Invalid RFC-7231 date-time value");
};
var parseEpochTimestamp = (value) => {
if (value === null || value === undefined) {
return;
}
let valueAsDouble;
if (typeof value === "number") {
valueAsDouble = value;
} else if (typeof value === "string") {
valueAsDouble = strictParseDouble(value);
} else if (typeof value === "object" && value.tag === 1) {
valueAsDouble = value.value;
} else {
throw new TypeError("Epoch timestamps must be expressed as floating point numbers or their string representation");
}
if (Number.isNaN(valueAsDouble) || valueAsDouble === Infinity || valueAsDouble === -Infinity) {
throw new TypeError("Epoch timestamps must be valid, non-Infinite, non-NaN numerics");
}
return new Date(Math.round(valueAsDouble * 1000));
};
var buildDate = (year, month, day, time) => {
const adjustedMonth = month - 1;
validateDayOfMonth(year, adjustedMonth, day);
return new Date(Date.UTC(year, adjustedMonth, day, parseDateValue(time.hours, "hour", 0, 23), parseDateValue(time.minutes, "minute", 0, 59), parseDateValue(time.seconds, "seconds", 0, 60), parseMilliseconds(time.fractionalMilliseconds)));
};
var parseTwoDigitYear = (value) => {
const thisYear = new Date().getUTCFullYear();
const valueInThisCentury = Math.floor(thisYear / 100) * 100 + strictParseShort(stripLeadingZeroes(value));
if (valueInThisCentury < thisYear) {
return valueInThisCentury + 100;
}
return valueInThisCentury;
};
var FIFTY_YEARS_IN_MILLIS = 50 * 365 * 24 * 60 * 60 * 1000;
var adjustRfc850Year = (input) => {
if (input.getTime() - new Date().getTime() > FIFTY_YEARS_IN_MILLIS) {
return new Date(Date.UTC(input.getUTCFullYear() - 100, input.getUTCMonth(), input.getUTCDate(), input.getUTCHours(), input.getUTCMinutes(), input.getUTCSeconds(), input.getUTCMilliseconds()));
}
return input;
};
var parseMonthByShortName = (value) => {
const monthIdx = MONTHS.indexOf(value);
if (monthIdx < 0) {
throw new TypeError(`Invalid month: ${value}`);
}
return monthIdx + 1;
};
var DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
var validateDayOfMonth = (year, month, day) => {
let maxDays = DAYS_IN_MONTH[month];
if (month === 1 && isLeapYear(year)) {
maxDays = 29;
}
if (day > maxDays) {
throw new TypeError(`Invalid day for ${MONTHS[month]} in ${year}: ${day}`);
}
};
var isLeapYear = (year) => {
return year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
};
var parseDateValue = (value, type, lower, upper) => {
const dateVal = strictParseByte(stripLeadingZeroes(value));
if (dateVal < lower || dateVal > upper) {
throw new TypeError(`${type} must be between ${lower} and ${upper}, inclusive`);
}
return dateVal;
};
var parseMilliseconds = (value) => {
if (value === null || value === undefined) {
return 0;
}
return strictParseFloat32("0." + value) * 1000;
};
var parseOffsetToMilliseconds = (value) => {
const directionStr = value[0];
let direction = 1;
if (directionStr == "+") {
direction = 1;
} else if (directionStr == "-") {
direction = -1;
} else {
throw new TypeError(`Offset direction, ${directionStr}, must be "+" or "-"`);
}
const hour = Number(value.substring(1, 3));
const minute = Number(value.substring(4, 6));
return direction * (hour * 60 + minute) * 60 * 1000;
};
var stripLeadingZeroes = (value) => {
let idx = 0;
while (idx < value.length - 1 && value.charAt(idx) === "0") {
idx++;
}
if (idx === 0) {
return value;
}
return value.slice(idx);
};
var LazyJsonString = function LazyJsonString(val) {
const str = Object.assign(new String(val), {
deserializeJSON() {
return JSON.parse(String(val));
},
toString() {
return String(val);
},
toJSON() {
return String(val);
}
});
return str;
};
LazyJsonString.from = (object) => {
if (object && typeof object === "object" && (object instanceof LazyJsonString || ("deserializeJSON" in object))) {
return object;
} else if (typeof object === "string" || Object.getPrototypeOf(object) === String.prototype) {
return LazyJsonString(String(object));
}
return LazyJsonString(JSON.stringify(object));
};
LazyJsonString.fromObject = LazyJsonString.from;
function quoteHeader(part) {
if (part.includes(",") || part.includes('"')) {
part = `"${part.replace(/"/g, "\\\"")}"`;
}
return part;
}
var ddd = `(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun)(?:[ne|u?r]?s?day)?`;
var mmm = `(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)`;
var time = `(\\d?\\d):(\\d{2}):(\\d{2})(?:\\.(\\d+))?`;
var date = `(\\d?\\d)`;
var year = `(\\d{4})`;
var RFC3339_WITH_OFFSET = new RegExp(/^(\d{4})-(\d\d)-(\d\d)[tT](\d\d):(\d\d):(\d\d)(\.(\d+))?(([-+]\d\d:\d\d)|[zZ])$/);
var IMF_FIXDATE = new RegExp(`^${ddd}, ${date} ${mmm} ${year} ${time} GMT$`);
var RFC_850_DATE = new RegExp(`^${ddd}, ${date}-${mmm}-(\\d\\d) ${time} GMT$`);
var ASC_TIME = new RegExp(`^${ddd} ${mmm} ( [1-9]|\\d\\d) ${time} ${year}$`);
var months = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
var _parseEpochTimestamp = (value) => {
if (value == null) {
return;
}
let num = NaN;
if (typeof value === "number") {
num = value;
} else if (typeof value === "string") {
if (!/^-?\d*\.?\d+$/.test(value)) {
throw new TypeError(`parseEpochTimestamp - numeric string invalid.`);
}
num = Number.parseFloat(value);
} else if (typeof value === "object" && value.tag === 1) {
num = value.value;
}
if (isNaN(num) || Math.abs(num) === Infinity) {
throw new TypeError("Epoch timestamps must be valid finite numbers.");
}
return new Date(Math.round(num * 1000));
};
var _parseRfc3339DateTimeWithOffset = (value) => {
if (value == null) {
return;
}
if (typeof value !== "string") {
throw new TypeError("RFC3339 timestamps must be strings");
}
const matches = RFC3339_WITH_OFFSET.exec(value);
if (!matches) {
throw new TypeError(`Invalid RFC3339 timestamp format ${value}`);
}
const [, yearStr, monthStr, dayStr, hours, minutes, seconds, , ms, offsetStr] = matches;
range(monthStr, 1, 12);
range(dayStr, 1, 31);
range(hours, 0, 23);
range(minutes, 0, 59);
range(seconds, 0, 60);
const date = new Date(Date.UTC(Number(yearStr), Number(monthStr) - 1, Number(dayStr), Number(hours), Number(minutes), Number(seconds), Number(ms) ? Math.round(parseFloat(`0.${ms}`) * 1000) : 0));
date.setUTCFullYear(Number(yearStr));
if (offsetStr.toUpperCase() != "Z") {
const [, sign, offsetH, offsetM] = /([+-])(\d\d):(\d\d)/.exec(offsetStr) || [undefined, "+", 0, 0];
const scalar = sign === "-" ? 1 : -1;
date.setTime(date.getTime() + scalar * (Number(offsetH) * 60 * 60 * 1000 + Number(offsetM) * 60 * 1000));
}
return date;
};
var _parseRfc7231DateTime = (value) => {
if (value == null) {
return;
}
if (typeof value !== "string") {
throw new TypeError("RFC7231 timestamps must be strings.");
}
let day;
let month;
let year;
let hour;
let minute;
let second;
let fraction;
let matches;
if (matches = IMF_FIXDATE.exec(value)) {
[, day, month, year, hour, minute, second, fraction] = matches;
} else if (matches = RFC_850_DATE.exec(value)) {
[, day, month, year, hour, minute, second, fraction] = matches;
year = (Number(year) + 1900).toString();
} else if (matches = ASC_TIME.exec(value)) {
[, month, day, hour, minute, second, fraction, year] = matches;
}
if (year && second) {
const timestamp = Date.UTC(Number(year), months.indexOf(month), Number(day), Number(hour), Number(minute), Number(second), fraction ? Math.round(parseFloat(`0.${fraction}`) * 1000) : 0);
range(day, 1, 31);
range(hour, 0, 23);
range(minute, 0, 59);
range(second, 0, 60);
const date = new Date(timestamp);
date.setUTCFullYear(Number(year));
return date;
}
throw new TypeError(`Invalid RFC7231 date-time value ${value}.`);
};
function range(v, min, max) {
const _v = Number(v);
if (_v < min || _v > max) {
throw new Error(`Value ${_v} out of range [${min}, ${max}]`);
}
}
function splitEvery(value, delimiter, numDelimiters) {
if (numDelimiters <= 0 || !Number.isInteger(numDelimiters)) {
throw new Error("Invalid number of delimiters (" + numDelimiters + ") for splitEvery.");
}
const segments = value.split(delimiter);
if (numDelimiters === 1) {
return segments;
}
const compoundSegments = [];
let currentSegment = "";
for (let i = 0;i < segments.length; i++) {
if (currentSegment === "") {
currentSegment = segments[i];
} else {
currentSegment += delimiter + segments[i];
}
if ((i + 1) % numDelimiters === 0) {
compoundSegments.push(currentSegment);
currentSegment = "";
}
}
if (currentSegment !== "") {
compoundSegments.push(currentSegment);
}
return compoundSegments;
}
var splitHeader = (value) => {
const z = value.length;
const values = [];
let withinQuotes = false;
let prevChar = undefined;
let anchor = 0;
for (let i = 0;i < z; ++i) {
const char = value[i];
switch (char) {
case `"`:
if (prevChar !== "\\") {
withinQuotes = !withinQuotes;
}
break;
case ",":
if (!withinQuotes) {
values.push(value.slice(anchor, i));
anchor = i + 1;
}
break;
}
prevChar = char;
}
values.push(value.slice(anchor));
return values.map((v) => {
v = v.trim();
const z = v.length;
if (z < 2) {
return v;
}
if (v[0] === `"` && v[z - 1] === `"`) {
v = v.slice(1, z - 1);
}
return v.replace(/\\"/g, '"');
});
};
var format = /^-?((0|[1-9]\d*)(\.\d+)?|\.\d+)([eE][+-]?\d+)?$/;
class NumericValue {
string;
type;
constructor(string, type) {
this.string = string;
this.type = type;
if (!format.test(string)) {
throw new Error(`@smithy/core/serde - NumericValue string must conform to the Smithy bigDecimal format. Received: "${string}"`);
}
}
toString() {
return this.string;
}
static [Symbol.hasInstance](object) {
if (!object || typeof object !== "object") {
return false;
}
const _nv = object;
return NumericValue.prototype.isPrototypeOf(object) || _nv.type === "bigDecimal" && format.test(_nv.string);
}
}
function nv(input) {
return new NumericValue(String(input), "bigDecimal");
}
var SHORT_TO_HEX = {};
var HEX_TO_SHORT = {};
for (let i = 0;i < 256; i++) {
let encodedByte = i.toString(16).toLowerCase();
if (encodedByte.length === 1) {
encodedByte = `0${encodedByte}`;
}
SHORT_TO_HEX[i] = encodedByte;
HEX_TO_SHORT[encodedByte] = i;
}
function fromHex(encoded) {
if (encoded.length % 2 !== 0) {
throw new Error("Hex encoded strings must have an even number length");
}
const out = new Uint8Array(encoded.length / 2);
for (let i = 0;i < encoded.length; i += 2) {
const encodedByte = encoded.slice(i, i + 2).toLowerCase();
if (encodedByte in HEX_TO_SHORT) {
out[i / 2] = HEX_TO_SHORT[encodedByte];
} else {
throw new Error(`Cannot decode unrecognized sequence ${encodedByte} as hexadecimal`);
}
}
return out;
}
function toHex(bytes) {
let out = "";
for (let i = 0;i < bytes.byteLength; i++) {
out += SHORT_TO_HEX[bytes[i]];
}
return out;
}
var calculateBodyLength = (body) => {
if (!body) {
return 0;
}
if (typeof body === "string") {
return Buffer.byteLength(body);
} else if (typeof body.byteLength === "number") {
return body.byteLength;
} else if (typeof body.size === "number") {
return body.size;
} else if (typeof body.start === "number" && typeof body.end === "number") {
return body.end + 1 - body.start;
} else if (body instanceof ReadStream) {
if (body.path != null) {
return lstatSync(body.path).size;
} else if (typeof body.fd === "number") {
return fstatSync(body.fd).size;
}
}
throw new Error(`Body Length computation failed for ${body}`);
};
var toUint8Array = (data) => {
if (data instanceof Uint8Array) {
return data;
}
if (typeof data === "string") {
return fromUtf8$1(data);
}
if (ArrayBuffer.isView(data)) {
return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT);
}
return new Uint8Array(data);
};
function concatBytes(arrays, length) {
if (length === undefined) {
length = 0;
for (const bytes of arrays) {
length += bytes.byteLength;
}
}
const result = new Uint8Array(length);
let offset = 0;
for (const buf of arrays) {
result.set(buf, offset);
offset += buf.byteLength;
}
return result;
}
var deserializerMiddleware = (options, deserializer) => (next, context) => async (args) => {
const { response } = await next(args);
try {
const parsed = await deserializer(response, options);
return {
response,
output: parsed
};
} catch (error) {
Object.defineProperty(error, "$response", {
value: response,
enumerable: false,
writable: false,
configurable: false
});
if (!("$metadata" in error)) {
const hint = `Deserialization error: to see the raw response, inspect the hidden field {error}.$response on this object.`;
try {
error.message += `
` + hint;
} catch (ignored) {
if (!context.logger || context.logger?.constructor?.name === "NoOpLogger") {
console.warn(hint);
} else {
context.logger?.warn?.(hint);
}
}
if (typeof error.$responseBodyText !== "undefined") {
if (error.$response) {
error.$response.body = error.$responseBodyText;
}
}
try {
if (HttpResponse.isInstance(response)) {
const { headers = {} } = response;
const headerEntries = Object.entries(headers);
error.$metadata = {
httpStatusCode: response.statusCode,
requestId: findHeader(/^x-[\w-]+-request-?id$/, headerEntries),
extendedRequestId: findHeader(/^x-[\w-]+-id-2$/, headerEntries),
cfId: findHeader(/^x-[\w-]+-cf-id$/, headerEntries)
};
}
} catch (ignored) {}
}
throw error;
}
};
var findHeader = (pattern, headers) => {
return (headers.find(([k]) => {
return k.match(pattern);
}) || [undefined, undefined])[1];
};
var serializerMiddleware = (options, serializer) => (next, context) => async (args) => {
const endpointConfig = options;
const endpoint = context.endpointV2 ? async () => toEndpointV1(context.endpointV2) : endpointConfig.endpoint;
if (!endpoint) {
throw new Error("No valid endpoint provider available.");
}
const request = await serializer(args.input, { ...options, endpoint });
return next({
...args,
request
});
};
var deserializerMiddlewareOption = {
name: "deserializerMiddleware",
step: "deserialize",
tags: ["DESERIALIZER"],
override: true
};
var serializerMiddlewareOption = {
name: "serializerMiddleware",
step: "serialize",
tags: ["SERIALIZER"],
override: true
};
function getSerdePlugin(config, serializer, deserializer) {
return {
applyToStack: (commandStack) => {
commandStack.add(deserializerMiddleware(config, deserializer), deserializerMiddlewareOption);
commandStack.add(serializerMiddleware(config, serializer), serializerMiddlewareOption);
}
};
}
class Hash {
algorithmIdentifier;
secret;
hash;
constructor(algorithmIdentifier, secret) {
this.algorithmIdentifier = algorithmIdentifier;
this.secret = secret;
this.reset();
}
update(toHash, encoding) {
this.hash.update(toUint8Array(castSourceData(toHash, encoding)));
}
digest() {
return Promise.resolve(this.hash.digest());
}
reset() {
this.hash = this.secret ? createHmac(this.algorithmIdentifier, castSourceData(this.secret)) : createHash(this.algorithmIdentifier);
}
}
function castSourceData(toCast, encoding) {
if (Buffer.isBuffer(toCast)) {
return toCast;
}
if (typeof toCast === "string") {
return fromString(toCast, encoding);
}
if (ArrayBuffer.isView(toCast)) {
return fromArrayBuffer(toCast.buffer, toCast.byteOffset, toCast.byteLength);
}
return fromArrayBuffer(toCast);
}
var ChecksumStream$1 = class ChecksumStream extends Readable {
expectedChecksum;
checksumSourceLocation;
checksum;
source;
base64Encoder;
constructor({ expectedChecksum, checksum, source, checksumSourceLocation, base64Encoder }) {
super();
if (typeof source.pipe !== "function") {
throw new Error(`@smithy/util-stream: unsupported source type ${source?.constructor?.name ?? source} in ChecksumStream.`);
}
this.source = source;
this.base64Encoder = base64Encoder ?? toBase64$1;
this.expectedChecksum = expectedChecksum;
this.checksum = checksum;
this.checksumSourceLocation = checksumSourceLocation;
this.source.on("data", this.onSourceData);
this.source.on("end", this.onSourceEnd);
this.source.on("error", this.onSourceError);
this.source.on("close", this.onSourceClose);
this.source.pause();
}
onSourceData = (chunk) => {
if (this.destroyed) {
return;
}
try {
this.checksum.update(chunk);
} catch (e) {
this.destroy(e);
return;
}
if (!this.push(chunk)) {
this.source.pause();
}
};
onSourceEnd = async () => {
if (this.destroyed) {
return;
}
try {
const digest = await this.checksum.digest();
const received = this.base64Encoder(digest);
if (this.expectedChecksum !== received) {
this.destroy(new Error(`Checksum mismatch: expected "${this.expectedChecksum}" but received "${received}"` + ` in response header "${this.checksumSourceLocation}".`));
return;
}
} catch (e) {
this.destroy(e);
return;
}
this.push(null);
};
onSourceError = (error) => {
this.destroy(error);
};
onSourceClose = () => {
if (!this.destroyed && !this.source.readableEnded) {
this.destroy(new Error("Connection lost or stream closed before all data was received."));
}
};
_read(_size) {
this.source.resume();
}
_destroy(error, callback) {
this.source?.removeListener("data", this.onSourceData);
this.source?.removeListener("end", this.onSourceEnd);
this.source?.removeListener("error", this.onSourceError);
this.source?.removeListener("close", this.onSourceClose);
this.source?.destroy();
callback(error);
}
};
var isReadableStream = (stream) => typeof ReadableStream === "function" && (stream?.constructor?.name === ReadableStream.name || stream instanceof ReadableStream);
var isBlob = (blob) => {
return typeof Blob === "function" && (blob?.constructor?.name === Blob.name || blob instanceof Blob);
};
var fromUtf8 = (input) => new TextEncoder().encode(input);
var chars = `ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/`;
Object.entries(chars).reduce((acc, [i, c]) => {
acc[c] = Number(i);
return acc;
}, {});
var alphabetByValue = chars.split("");
var bitsPerLetter = 6;
var bitsPerByte = 8;
var maxLetterValue = 63;
function toBase64(_input) {
let input;
if (typeof _input === "string") {
input = fromUtf8(_input);
} else {
input = _input;
}
const isArrayLike = typeof input === "object" && typeof input.length === "number";
const isUint8Array = typeof input === "object" && typeof input.byteOffset === "number" && typeof input.byteLength === "number";
if (!isArrayLike && !isUint8Array) {
throw new Error("@smithy/util-base64: toBase64 encoder function only accepts string | Uint8Array.");
}
let str = "";
for (let i = 0;i < input.length; i += 3) {
let bits = 0;
let bitLength = 0;
for (let j = i, limit = Math.min(i + 3, input.length);j < limit; j++) {
bits |= input[j] << (limit - j - 1) * bitsPerByte;
bitLength += bitsPerByte;
}
const bitClusterCount = Math.ceil(bitLength / bitsPerLetter);
bits <<= bitClusterCount * bitsPerLetter - bitLength;
for (let k = 1;k <= bitClusterCount; k++) {
const offset = (bitClusterCount - k) * bitsPerLetter;
str += alphabetByValue[(bits & maxLetterValue << offset) >> offset];
}
str += "==".slice(0, 4 - bitClusterCount);
}
return str;
}
var ReadableStreamRef = typeof ReadableStream === "function" ? ReadableStream : function() {};
class ChecksumStream extends ReadableStreamRef {
}
var createChecksumStream$1 = ({ expectedChecksum, checksum, source, checksumSourceLocation, base64Encoder }) => {
if (!isReadableStream(source)) {
throw new Error(`@smithy/util-stream: unsupported source type ${source?.constructor?.name ?? source} in ChecksumStream.`);
}
const encoder = base64Encoder ?? toBase64;
if (typeof TransformStream !== "function") {
throw new Error("@smithy/util-stream: unable to instantiate ChecksumStream because API unavailable: ReadableStream/TransformStream.");
}
const transform = new TransformStream({
start() {},
async transform(chunk, controller) {
checksum.update(chunk);
controller.enqueue(chunk);
},
async flush(controller) {
const digest = await checksum.digest();
const received = encoder(digest);
if (expectedChecksum !== received) {
const error = new Error(`Checksum mismatch: expected "${expectedChecksum}" but received "${received}"` + ` in response header "${checksumSourceLocation}".`);
controller.error(error);
} else {
controller.terminate();
}
}
});
source.pipeThrough(transform);
const readable = transform.readable;
Object.setPrototypeOf(readable, ChecksumStream.prototype);
return readable;
};
function createChecksumStream(init) {
if (typeof ReadableStream === "function" && isReadableStream(init.source)) {
return createChecksumStream$1(init);
}
return new ChecksumStream$1(init);
}
class ByteArrayCollector {
allocByteArray;
byteLength = 0;
byteArrays = [];
constructor(allocByteArray) {
this.allocByteArray = allocByteArray;
}
push(byteArray) {
this.byteArrays.push(byteArray);
this.byteLength += byteArray.byteLength;
}
flush() {
if (this.byteArrays.length === 1) {
const bytes = this.byteArrays[0];
this.reset();
return bytes;
}
const aggregation = this.allocByteArray(this.byteLength);
let cursor = 0;
for (let i = 0;i < this.byteArrays.length; ++i) {
const bytes = this.byteArrays[i];
aggregation.set(bytes, cursor);
cursor += bytes.byteLength;
}
this.reset();
return aggregation;
}
reset() {
this.byteArrays = [];
this.byteLength = 0;
}
}
function createBufferedReadableStream(upstream, size, logger) {
const reader = upstream.getReader();
let streamBufferingLoggedWarning = false;
let bytesSeen = 0;
const buffers = ["", new ByteArrayCollector((size) => new Uint8Array(size))];
let mode = -1;
const pull = async (controller) => {
const { value, done } = await reader.read();
const chunk = value;
if (done) {
if (mode !== -1) {
const remainder = flush(buffers, mode);
if (sizeOf(remainder) > 0) {
controller.enqueue(remainder);
}
}
controller.close();
} else {
const chunkMode = modeOf(chunk, false);
if (mode !== chunkMode) {
if (mode >= 0) {
controller.enqueue(flush(buffers, mode));
}
mode = chunkMode;
}
if (mode === -1) {
controller.enqueue(chunk);
return;
}
const chunkSize = sizeOf(chunk);
bytesSeen += chunkSize;
const bufferSize = sizeOf(buffers[mode]);
if (chunkSize >= size && bufferSize === 0) {
controller.enqueue(chunk);
} else {
const newSize = merge(buffers, mode, chunk);
if (!streamBufferingLoggedWarning && bytesSeen > size * 2) {
streamBufferingLoggedWarning = true;
logger?.warn(`@smithy/util-stream - stream chunk size ${chunkSize} is below threshold of ${size}, automatically buffering.`);
}
if (newSize >= size) {
controller.enqueue(flush(buffers, mode));
} else {
await pull(controller);
}
}
}
};
return new ReadableStream({
pull
});
}
function merge(buffers, mode, chunk) {
switch (mode) {
case 0:
buffers[0] += chunk;
return sizeOf(buffers[0]);
case 1:
case 2:
buffers[mode].push(chunk);
return sizeOf(buffers[mode]);
}
}
function flush(buffers, mode) {
switch (mode) {
case 0:
const s = buffers[0];
buffers[0] = "";
return s;
case 1:
case 2:
return buffers[mode].flush();
}
throw new Error(`@smithy/util-stream - invalid index ${mode} given to flush()`);
}
function sizeOf(chunk) {
return chunk?.byteLength ?? chunk?.length ?? 0;
}
function modeOf(chunk, allowBuffer = true) {
if (allowBuffer && typeof Buffer !== "undefined" && chunk instanceof Buffer) {
return 2;
}
if (chunk instanceof Uint8Array) {
return 1;
}
if (typeof chunk === "string") {
return 0;
}
return -1;
}
function createBufferedReadable(upstream, size, logger) {
if (isReadableStream(upstream)) {
return createBufferedReadableStream(upstream, size, logger);
}
const downstream = new Readable({ read() {} });
let streamBufferingLoggedWarning = false;
let bytesSeen = 0;
const buffers = [
"",
new ByteArrayCollector((size) => new Uint8Array(size)),
new ByteArrayCollector((size) => Buffer.from(new Uint8Array(size)))
];
let mode = -1;
upstream.on("data", (chunk) => {
const chunkMode = modeOf(chunk, true);
if (mode !== chunkMode) {
if (mode >= 0) {
downstream.push(flush(buffers, mode));
}
mode = chunkMode;
}
if (mode === -1) {
downstream.push(chunk);
return;
}
const chunkSize = sizeOf(chunk);
bytesSeen += chunkSize;
const bufferSize = sizeOf(buffers[mode]);
if (chunkSize >= size && bufferSize === 0) {
downstream.push(chunk);
} else {
const newSize = merge(buffers, mode, chunk);
if (!streamBufferingLoggedWarning && bytesSeen > size * 2) {
streamBufferingLoggedWarning = true;
logger?.warn(`@smithy/util-stream - stream chunk size ${chunkSize} is below threshold of ${size}, automatically buffering.`);
}
if (newSize >= size) {
downstream.push(flush(buffers, mode));
}
}
});
upstream.on("end", () => {
if (mode !== -1) {
const remainder = flush(buffers, mode);
if (sizeOf(remainder) > 0) {
downstream.push(remainder);
}
}
downstream.push(null);
});
return downstream;
}
var getAwsChunkedEncodingStream$1 = (readableStream, options) => {
const { base64Encoder, bodyLengthChecker, checksumAlgorithmFn, checksumLocationName, streamHasher } = options;
const checksumRequired = base64Encoder !== undefined && bodyLengthChecker !== undefined && checksumAlgorithmFn !== undefined && checksumLocationName !== undefined && streamHasher !== undefined;
const digest = checksumRequired ? streamHasher(checksumAlgorithmFn, readableStream) : undefined;
const reader = readableStream.getReader();
return new ReadableStream({
async pull(controller) {
const { value, done } = await reader.read();
if (done) {
controller.enqueue(`0\r
`);
if (checksumRequired) {
const checksum = base64Encoder(await digest);
controller.enqueue(`${checksumLocationName}:${checksum}\r
`);
controller.enqueue(`\r
`);
}
controller.close();
} else {
controller.enqueue(`${(bodyLengthChecker(value) || 0).toString(16)}\r
${value}\r
`);
}
}
});
};
function getAwsChunkedEncodingStream(stream, options) {
const readable = stream;
const readableStream = stream;
if (isReadableStream(readableStream)) {
return getAwsChunkedEncodingStream$1(readableStream, options);
}
const { base64Encoder, bodyLengthChecker, checksumAlgorithmFn, checksumLocationName, streamHasher } = options;
const checksumRequired = base64Encoder !== undefined && checksumAlgorithmFn !== undefined && checksumLocationName !== undefined && streamHasher !== undefined;
const digest = checksumRequired ? streamHasher(checksumAlgorithmFn, readable) : undefined;
const awsChunkedEncodingStream = new Readable({
read: () => {}
});
readable.on("data", (data) => {
const length = bodyLengthChecker(data) || 0;
if (length === 0) {
return;
}
awsChunkedEncodingStream.push(`${length.toString(16)}\r
`);
awsChunkedEncodingStream.push(data);
awsChunkedEncodingStream.push(`\r
`);
});
readable.on("end", async () => {
awsChunkedEncodingStream.push(`0\r
`);
if (checksumRequired) {
const checksum = base64Encoder(await digest);
awsChunkedEncodingStream.push(`${checksumLocationName}:${checksum}\r
`);
awsChunkedEncodingStream.push(`\r
`);
}
awsChunkedEncodingStream.push(null);
});
return awsChunkedEncodingStream;
}
async function headStream$1(stream, bytes) {
let byteLengthCounter = 0;
const chunks = [];
const reader = stream.getReader();
let isDone = false;
while (!isDone) {
const { done, value } = await reader.read();
if (value) {
chunks.push(value);
byteLengthCounter += value?.byteLength ?? 0;
}
if (byteLengthCounter >= bytes) {
break;
}
isDone = done;
}
reader.releaseLock();
const collected = new Uint8Array(Math.min(bytes, byteLengthCounter));
let offset = 0;
for (const chunk of chunks) {
if (chunk.byteLength > collected.byteLength - offset) {
collected.set(chunk.subarray(0, collected.byteLength - offset), offset);
break;
} else {
collected.set(chunk, offset);
}
offset += chunk.length;
}
return collected;
}
var headStream = (stream, bytes) => {
if (isReadableStream(stream)) {
return headStream$1(stream, bytes);
}
return new Promise((resolve, reject) => {
const collector = new Collector$1;
collector.limit = bytes;
stream.pipe(collector);
stream.on("error", (err) => {
collector.end();
reject(err);
});
collector.on("error", reject);
collector.on("finish", function() {
const bytes = concatBytes(this.buffers);
resolve(bytes);
});
});
};
var Collector$1 = class Collector extends Writable {
buffers = [];
limit = Infinity;
bytesBuffered = 0;
_write(chunk, encoding, callback) {
this.buffers.push(chunk);
this.bytesBuffered += chunk.byteLength ?? 0;
if (this.bytesBuffered >= this.limit) {
const excess = this.bytesBuffered - this.limit;
const tailBuffer = this.buffers[this.buffers.length - 1];
this.buffers[this.buffers.length - 1] = tailBuffer.subarray(0, tailBuffer.byteLength - excess);
this.emit("finish");
}
callback();
}
};
var toUtf8 = (input) => {
if (typeof input === "string") {
return input;
}
if (typeof input !== "object" || typeof input.byteOffset !== "number" || typeof input.byteLength !== "number") {
throw new Error("@smithy/util-utf8: toUtf8 encoder function only accepts string | Uint8Array.");
}
return new TextDecoder("utf-8").decode(input);
};
var streamCollector$1 = async (stream) => {
if (isBlob(stream)) {
return collectBlob(stream);
}
return collectReadableStream(stream);
};
async function collectBlob(blob) {
return blob.arrayBuffer().then((ab) => new Uint8Array(ab));
}
async function collectReadableStream(stream) {
const chunks = [];
const reader = stream.getReader();
let length = 0;
while (true) {
const { done, value } = await reader.read();
if (value) {
chunks.push(value);
length += value.length;
}
if (done) {
break;
}
}
return concatBytes(chunks, length);
}
var ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED$1 = "The stream has already been transformed.";
var sdkStreamMixin$1 = (stream) => {
if (!isBlobInstance(stream) && !isReadableStream(stream)) {
const name = stream?.__proto__?.constructor?.name || stream;
throw new Error(`Unexpected stream implementation, expect Blob or ReadableStream, got ${name}`);
}
let transformed = false;
const transformToByteArray = async () => {
if (transformed) {
throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED$1);
}
transformed = true;
return await streamCollector$1(stream);
};
const blobToWebStream = (blob) => {
if (typeof blob.stream !== "function") {
throw new Error(`Cannot transform payload Blob to web stream. Please make sure the Blob.stream() is polyfilled.
` + "If you are using React Native, this API is not yet supported, see: https://react-native.canny.io/feature-requests/p/fetch-streaming-body");
}
return blob.stream();
};
return Object.assign(stream, {
transformToByteArray,
transformToString: async (encoding) => {
const buf = await transformToByteArray();
if (encoding === "base64") {
return toBase64(buf);
} else if (encoding === "hex") {
return toHex(buf);
} else if (encoding === undefined || encoding === "utf8" || encoding === "utf-8") {
return toUtf8(buf);
} else if (typeof TextDecoder === "function") {
return new TextDecoder(encoding).decode(buf);
} else {
throw new Error("TextDecoder is not available, please make sure polyfill is provided.");
}
},
transformToWebStream: () => {
if (transformed) {
throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED$1);
}
transformed = true;
if (isBlobInstance(stream)) {
return blobToWebStream(stream);
} else if (isReadableStream(stream)) {
return stream;
} else {
throw new Error(`Cannot transform payload to web stream, got ${stream}`);
}
}
});
};
var isBlobInstance = (stream) => typeof Blob === "function" && stream instanceof Blob;
var streamCollector = (stream) => {
if (isBlob(stream)) {
return collectBlob(stream);
}
if (isReadableStream(stream)) {
return collectReadableStream(stream);
}
return new Promise((resolve, reject) => {
const collector = new Collector;
const nodeStream = stream;
nodeStream.pipe(collector);
nodeStream.on("error", (err) => {
collector.end();
reject(err);
});
collector.on("error", reject);
collector.on("finish", function() {
const bytes = concatBytes(this.bufferedBytes);
resolve(bytes);
});
});
};
class Collector extends Writable {
bufferedBytes = [];
_write(chunk, encoding, callback) {
this.bufferedBytes.push(chunk);
callback();
}
}
var ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED = "The stream has already been transformed.";
var sdkStreamMixin = (stream) => {
if (!(stream instanceof Readable)) {
try {
return sdkStreamMixin$1(stream);
} catch (ignored) {
const name = stream?.__proto__?.constructor?.name || stream;
throw new Error(`Unexpected stream implementation, expect Stream.Readable instance, got ${name}`);
}
}
let transformed = false;
const transformToByteArray = async () => {
if (transformed) {
throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED);
}
transformed = true;
return await streamCollector(stream);
};
return Object.assign(stream, {
transformToByteArray,
transformToString: async (encoding) => {
const buf = await transformToByteArray();
if (encoding === undefined || Buffer.isEncoding(encoding)) {
return fromArrayBuffer(buf.buffer, buf.byteOffset, buf.byteLength).toString(encoding);
} else {
const decoder = new TextDecoder(encoding);
return decoder.decode(buf);
}
},
transformToWebStream: () => {
if (transformed) {
throw new Error(ERR_MSG_STREAM_HAS_BEEN_TRANSFORMED);
}
if (stream.readableFlowing !== null) {
throw new Error("The stream has been consumed by other callbacks.");
}
if (typeof Readable.toWeb !== "function") {
throw new Error("Readable.toWeb() is not supported. Please ensure a polyfill is available.");
}
transformed = true;
return Readable.toWeb(stream);
}
});
};
async function splitStream$1(stream) {
if (typeof stream.stream === "function") {
stream = stream.stream();
}
const readableStream = stream;
return readableStream.tee();
}
async function splitStream(stream) {
if (isReadableStream(stream) || isBlob(stream)) {
return splitStream$1(stream);
}
const stream1 = new PassThrough;
const stream2 = new PassThrough;
stream.pipe(stream1);
stream.pipe(stream2);
return [stream1, stream2];
}
class Uint8ArrayBlobAdapter extends bindUint8ArrayBlobAdapter(toUtf8$1, fromUtf8$1, toBase64$1, fromBase64) {
}
var _getRandomValues = getRandomValues;
var v4 = bindV4(_getRandomValues);
var generateIdempotencyToken = v4;
exports.ChecksumStream = ChecksumStream$1;
exports.Hash = Hash;
exports.LazyJsonString = LazyJsonString;
exports.NumericValue = NumericValue;
exports.Uint8ArrayBlobAdapter = Uint8ArrayBlobAdapter;
exports._parseEpochTimestamp = _parseEpochTimestamp;
exports._parseRfc3339DateTimeWithOffset = _parseRfc3339DateTimeWithOffset;
exports._parseRfc7231DateTime = _parseRfc7231DateTime;
exports.calculateBodyLength = calculateBodyLength;
exports.concatBytes = concatBytes;
exports.copyDocumentWithTransform = copyDocumentWithTransform;
exports.createBufferedReadable = createBufferedReadable;
exports.createChecksumStream = createChecksumStream;
exports.dateToUtcString = dateToUtcString;
exports.deserializerMiddleware = deserializerMiddleware;
exports.deserializerMiddlewareOption = deserializerMiddlewareOption;
exports.expectBoolean = expectBoolean;
exports.expectByte = expectByte;
exports.expectFloat32 = expectFloat32;
exports.expectInt = expectInt;
exports.expectInt32 = expectInt32;
exports.expectLong = expectLong;
exports.expectNonNull = expectNonNull;
exports.expectNumber = expectNumber;
exports.expectObject = expectObject;
exports.expectShort = expectShort;
exports.expectString = expectString;
exports.expectUnion = expectUnion;
exports.fromArrayBuffer = fromArrayBuffer;
exports.fromBase64 = fromBase64;
exports.fromHex = fromHex;
exports.fromString = fromString;
exports.fromUtf8 = fromUtf8$1;
exports.generateIdempotencyToken = generateIdempotencyToken;
exports.getAwsChunkedEncodingStream = getAwsChunkedEncodingStream;
exports.getSerdePlugin = getSerdePlugin;
exports.handleFloat = handleFloat;
exports.headStream = headStream;
exports.isArrayBuffer = isArrayBuffer;
exports.isBlob = isBlob;
exports.isReadableStream = isReadableStream;
exports.limitedParseDouble = limitedParseDouble;
exports.limitedParseFloat = limitedParseFloat;
exports.limitedParseFloat32 = limitedParseFloat32;
exports.logger = logger;
exports.nv = nv;
exports.parseBoolean = parseBoolean;
exports.parseEpochTimestamp = parseEpochTimestamp;
exports.parseRfc3339DateTime = parseRfc3339DateTime;
exports.parseRfc3339DateTimeWithOffset = parseRfc3339DateTimeWithOffset;
exports.parseRfc7231DateTime = parseRfc7231DateTime;
exports.quoteHeader = quoteHeader;
exports.sdkStreamMixin = sdkStreamMixin;
exports.serializerMiddleware = serializerMiddleware;
exports.serializerMiddlewareOption = serializerMiddlewareOption;
exports.splitEvery = splitEvery;
exports.splitHeader = splitHeader;
exports.splitStream = splitStream;
exports.streamCollector = streamCollector;
exports.strictParseByte = strictParseByte;
exports.strictParseDouble = strictParseDouble;
exports.strictParseFloat = strictParseFloat;
exports.strictParseFloat32 = strictParseFloat32;
exports.strictParseInt = strictParseInt;
exports.strictParseInt32 = strictParseInt32;
exports.strictParseLong = strictParseLong;
exports.strictParseShort = strictParseShort;
exports.toBase64 = toBase64$1;
exports.toHex = toHex;
exports.toUint8Array = toUint8Array;
exports.toUtf8 = toUtf8$1;
exports.v4 = v4;
});
// ../../node_modules/.bun/@smithy+core@3.33.3/node_modules/@smithy/core/dist-cjs/submodules/checksum/index.js
var require_checksum = __commonJS(function(exports) {
var { createReadStream } = __require("fs");
var { Writable } = __require("stream");
var { toUint8Array, concatBytes } = require_serde();
var { createHash, createHmac } = __require("crypto");
var zlib = __require("zlib");
async function blobReader(blob, onChunk, chunkSize = 1024 * 1024) {
const size = blob.size;
let totalBytesRead = 0;
while (totalBytesRead < size) {
const slice = blob.slice(totalBytesRead, Math.min(size, totalBytesRead + chunkSize));
onChunk(new Uint8Array(await slice.arrayBuffer()));
totalBytesRead += slice.size;
}
}
var blobHasher = async function blobHasher(hashCtor, blob) {
const hash = new hashCtor;
await blobReader(blob, (chunk) => {
hash.update(chunk);
});
return hash.digest();
};
class HashCalculator extends Writable {
hash;
constructor(hash, options) {
super(options);
this.hash = hash;
}
_write(chunk, encoding, callback) {
try {
this.hash.update(toUint8Array(chunk));
} catch (err) {
return callback(err);
}
callback();
}
}
var fileStreamHasher = (hashCtor, fileStream) => new Promise((resolve, reject) => {
if (!isReadStream(fileStream)) {
reject(new Error("Unable to calculate hash for non-file streams."));
return;
}
const fileStreamTee = createReadStream(fileStream.path, {
start: fileStream.start,
end: fileStream.end
});
const hash = new hashCtor;
const hashCalculator = new HashCalculator(hash);
fileStreamTee.pipe(hashCalculator);
fileStreamTee.on("error", (err) => {
hashCalculator.end();
reject(err);
});
hashCalculator.on("error", reject);
hashCalculator.on("finish", function() {
hash.digest().then(resolve).catch(reject);
});
});
var isReadStream = (stream) => typeof stream.path === "string";
var readableStreamHasher = (hashCtor, readableStream) => {
if (readableStream.readableFlowing !== null) {
throw new Error("Unable to calculate hash for flowing readable stream");
}
const hash = new hashCtor;
const hashCalculator = new HashCalculator(hash);
readableStream.pipe(hashCalculator);
return new Promise((resolve, reject) => {
readableStream.on("error", (err) => {
hashCalculator.end();
reject(err);
});
hashCalculator.on("error", reject);
hashCalculator.on("finish", () => {
hash.digest().then(resolve).catch(reject);
});
});
};
class Md5Js {
digestLength = 16;
state = Uint32Array.from(INIT$1);
writeBuffer = new DataView(new ArrayBuffer(64));
bufferLength = 0;
bytesHashed = 0;
update(sourceData) {
const data = toUint8Array(sourceData);
let pos = 0;
let len = data.byteLength;
this.bytesHashed += len;
while (len > 0) {
this.writeBuffer.setUint8(this.bufferLength++, data[pos++]);
--len;
if (this.bufferLength === 64) {
compress(this.state, this.writeBuffer);
this.bufferLength = 0;
}
}
}
async digest() {
const state = Uint32Array.from(this.state);
const buf = new DataView(this.writeBuffer.buffer.slice(0));
let bufLen = this.bufferLength;
const bits = this.bytesHashed * 8;
buf.setUint8(bufLen++, 128);
if (this.bufferLength % 64 >= 56) {
for (let i = bufLen;i < 64; ++i) {
buf.setUint8(i, 0);
}
compress(state, buf);
bufLen = 0;
}
for (let i = bufLen;i < 56; ++i) {
buf.setUint8(i, 0);
}
buf.setUint32(56, bits >>> 0, true);
buf.setUint32(60, Math.floor(bits / 2 ** 32), true);
compress(state, buf);
const out = new Uint8Array(16);
const view = new DataView(out.buffer);
for (let i = 0;i < 4; ++i) {
view.setUint32(i * 4, state[i], true);
}
return out;
}
reset() {
this.state.set(INIT$1);
this.writeBuffer = new DataView(new ArrayBuffer(64));
this.bufferLength = 0;
this.bytesHashed = 0;
}
}
var INIT$1 = [1732584193, 4023233417, 2562383102, 271733878];
var M = 4294967295;
var S = Uint8Array.of(7, 12, 17, 22, 5, 9, 14, 20, 4, 11, 16, 23, 6, 10, 15, 21);
var T = Array.from({ length: 64 }, (_, i) => Math.abs(Math.sin(i + 1)) * 2 ** 32 >>> 0);
function compress(state, block) {
let a = state[0], b = state[1], c = state[2], d = state[3];
for (let i = 0;i < 64; ++i) {
let f, g;
if (i < 16) {
f = b & c | ~b & d;
g = i;
} else if (i < 32) {
f = d & b | c & ~d;
g = (5 * i + 1) % 16;
} else if (i < 48) {
f = b ^ c ^ d;
g = (3 * i + 5) % 16;
} else {
f = c ^ (b | ~d);
g = 7 * i % 16;
}
const x = block.getUint32(g * 4, true);
const tmp = d;
d = c;
c = b;
const s = S[(i >> 4) * 4 + (i & 3)];
const sum = (a + f & M) + (x + T[i] & M) & M;
b = b + ((sum << s | sum >>> 32 - s) >>> 0) & M;
a = tmp;
}
state[0] = state[0] + a & M;
state[1] = state[1] + b & M;
state[2] = state[2] + c & M;
state[3] = state[3] + d & M;
}
var hasNativeCrypto$1 = (() => {
try {
createHash("md5");
return true;
} catch {
return false;
}
})();
var Md5Node = hasNativeCrypto$1 ? buildNativeClass$2() : Md5Js;
function buildNativeClass$2() {
return class Md5Node {
digestLength = 16;
hash = createHash("md5");
update(data) {
this.hash.update(toUint8Array(data));
}
async digest() {
const buf = this.hash.copy().digest();
return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
}
reset() {
this.hash = createHash("md5");
}
};
}
var CRC32_TABLE = new Uint32Array(256);
for (let i = 0;i < 256; ++i) {
let c = i;
for (let j = 0;j < 8; ++j) {
c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
}
CRC32_TABLE[i] = c >>> 0;
}
var ONES = 4294967295;
class Crc32Js {
digestLength = 4;
checksum = ONES;
update(data) {
for (let i = 0;i < data.length; ++i) {
this.checksum = this.checksum >>> 8 ^ CRC32_TABLE[(this.checksum ^ data[i]) & 255];
}
}
digestSync() {
return (this.checksum ^ ONES) >>> 0;
}
async digest() {
const value = this.digestSync();
const out = new Uint8Array(4);
new DataView(out.buffer).setUint32(0, value, false);
return out;
}
reset() {
this.checksum = ONES;
}
}
var zlibCrc32 = typeof zlib.crc32 === "function" ? zlib.crc32 : undefined;
var Crc32Node = zlibCrc32 ? buildNativeClass$1(zlibCrc32) : Crc32Js;
function buildNativeClass$1(nativeCrc32) {
return class Crc32Node {
digestLength = 4;
value = 0;
update(data) {
this.value = nativeCrc32(data, this.value);
}
digestSync() {
return this.value >>> 0;
}
async digest() {
const out = new Uint8Array(4);
new DataView(out.buffer).setUint32(0, this.digestSync(), false);
return out;
}
reset() {
this.value = 0;
}
};
}
var BLOCK = 64;
var DIGEST_LENGTH = 32;
var MAX_HASHABLE_LENGTH = 2 ** 53 - 1;
class Sha256Js {
digestLength = DIGEST_LENGTH;
state = Int32Array.from(INIT);
w;
buffer = new Uint8Array(64);
bufferLength = 0;
bytesHashed = 0;
finished = false;
inner;
outer;
constructor(secret) {
if (secret) {
const key = Sha256Js.normalizeKey(secret);
this.inner = new Sha256Js;
this.outer = new Sha256Js;
const { inner, outer } = this;
const pad = new Uint8Array(BLOCK * 2);
for (let i = 0;i < BLOCK; ++i) {
pad[i] = 54 ^ key[i];
pad[i + BLOCK] = 92 ^ key[i];
}
inner.update(pad.subarray(0, BLOCK));
outer.update(pad.subarray(BLOCK));
}
}
update(data) {
if (this.finished) {
throw new Error("Attempted to update an already finished HMAC.");
}
if (this.inner) {
this.inner.update(data);
return;
}
const chunk = toUint8Array(data);
let position = 0;
let { byteLength } = chunk;
this.bytesHashed += byteLength;
if (this.bytesHashed * 8 > MAX_HASHABLE_LENGTH) {
throw new Error("Cannot hash more than 2^53 - 1 bits");
}
while (byteLength > 0) {
this.buffer[this.bufferLength++] = chunk[position++];
byteLength--;
if (this.bufferLength === BLOCK) {
this.hashBuffer();
this.bufferLength = 0;
}
}
}
async digest() {
const { inner, outer } = this;
if (inner && outer) {
if (this.finished) {
throw new Error("Attempted to digest an already finished HMAC.");
}
this.finished = true;
const innerDigest = inner.digestSync();
outer.update(innerDigest);
return outer.digestSync();
}
return this.digestSync();
}
reset() {
this.state = Int32Array.from(INIT);
this.buffer = new Uint8Array(64);
this.bufferLength = 0;
this.bytesHashed = 0;
}
digestSync() {
const state = this.state.slice();
const buffer = this.buffer.slice();
let bufferLength = this.bufferLength;
const bitsHashed = this.bytesHashed * 8;
const bufferView = new DataView(buffer.buffer, buffer.byteOffset, buffer.byteLength);
bufferView.setUint8(bufferLength++, 128);
if ((bufferLength - 1) % BLOCK >= BLOCK - 8) {
for (let i = bufferLength;i < BLOCK; ++i) {
bufferView.setUint8(i, 0);
}
this.hashBufferWith(state, buffer);
bufferLength = 0;
}
for (let i = bufferLength;i < BLOCK - 8; ++i) {
bufferView.setUint8(i, 0);
}
bufferView.setUint32(BLOCK - 8, Math.floor(bitsHashed / 4294967296), false);
bufferView.setUint32(BLOCK - 4, bitsHashed, false);
this.hashBufferWith(state, buffer);
const out = new Uint8Array(DIGEST_LENGTH);
for (let i = 0;i < 8; ++i) {
out[i * 4] = state[i] >>> 24 & 255;
out[i * 4 + 1] = state[i] >>> 16 & 255;
out[i * 4 + 2] = state[i] >>> 8 & 255;
out[i * 4 + 3] = state[i] >>> 0 & 255;
}
return out;
}
static normalizeKey(secret) {
const key = toUint8Array(secret);
if (key.byteLength > BLOCK) {
const h = new Sha256Js;
h.update(key);
const out = h.digestSync();
const padded = new Uint8Array(BLOCK);
padded.set(out);
return padded;
}
if (key.byteLength < BLOCK) {
const padded = new Uint8Array(BLOCK);
padded.set(key);
return padded;
}
return key;
}
hashBuffer() {
this.hashBufferWith(this.state, this.buffer);
}
hashBufferWith(state, buffer) {
const w = this.w ??= new Int32Array(64);
let s0 = state[0], s1 = state[1], s2 = state[2], s3 = state[3], s4 = state[4], s5 = state[5], s6 = state[6], s7 = state[7];
for (let i = 0;i < BLOCK; ++i) {
if (i < 16) {
w[i] = (buffer[i * 4] & 255) << 24 | (buffer[i * 4 + 1] & 255) << 16 | (buffer[i * 4 + 2] & 255) << 8 | buffer[i * 4 + 3] & 255;
} else {
let u = w[i - 2];
const t1 = (u >>> 17 | u << 15) ^ (u >>> 19 | u << 13) ^ u >>> 10;
u = w[i - 15];
const t2 = (u >>> 7 | u << 25) ^ (u >>> 18 | u << 14) ^ u >>> 3;
w[i] = (t1 + w[i - 7] | 0) + (t2 + w[i - 16] | 0);
}
const t1 = (((s4 >>> 6 | s4 << 26) ^ (s4 >>> 11 | s4 << 21) ^ (s4 >>> 25 | s4 << 7)) + (s4 & s5 ^ ~s4 & s6) | 0) + (s7 + (K[i] + w[i] | 0) | 0) | 0;
const t2 = ((s0 >>> 2 | s0 << 30) ^ (s0 >>> 13 | s0 << 19) ^ (s0 >>> 22 | s0 << 10)) + (s0 & s1 ^ s0 & s2 ^ s1 & s2) | 0;
s7 = s6;
s6 = s5;
s5 = s4;
s4 = s3 + t1 | 0;
s3 = s2;
s2 = s1;
s1 = s0;
s0 = t1 + t2 | 0;
}
state[0] += s0;
state[1] += s1;
state[2] += s2;
state[3] += s3;
state[4] += s4;
state[5] += s5;
state[6] += s6;
state[7] += s7;
}
}
var INIT = new Int32Array([
1779033703,
3144134277,
1013904242,
2773480762,
1359893119,
2600822924,
528734635,
1541459225
]);
var K = new Int32Array([
1116352408,
1899447441,
3049323471,
3921009573,
961987163,
1508970993,
2453635748,
2870763221,
3624381080,
310598401,
607225278,
1426881987,
1925078388,
2162078206,
2614888103,
3248222580,
3835390401,
4022224774,
264347078,
604807628,
770255983,
1249150122,
1555081692,
1996064986,
2554220882,
2821834349,
2952996808,
3210313671,
3336571891,
3584528711,
113926993,
338241895,
666307205,
773529912,
1294757372,
1396182291,
1695183700,
1986661051,
2177026350,
2456956037,
2730485921,
2820302411,
3259730800,
3345764771,
3516065817,
3600352804,
4094571909,
275423344,
430227734,
506948616,
659060556,
883997877,
958139571,
1322822218,
1537002063,
1747873779,
1955562222,
2024104815,
2227730452,
2361852424,
2428436474,
2756734187,
3204031479,
3329325298
]);
var hasNativeCrypto = (() => {
try {
createHash("sha256");
return true;
} catch {
return false;
}
})();
var Sha256Node = hasNativeCrypto ? buildNativeClass() : Sha256Js;
function buildNativeClass() {
return class Sha256Node {
digestLength = 32;
secret;
hash;
isHmac;
finished = false;
constructor(secret) {
this.secret = secret;
this.isHmac = !!secret;
this.hash = this.createHash();
}
update(data) {
if (this.finished) {
throw new Error("Attempted to update an already finished hash.");
}
this.hash.update(data);
}
async digest() {
let buf;
if (this.isHmac) {
this.finished = true;
buf = this.hash.digest();
} else {
buf = this.hash.copy().digest();
}
return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
}
reset() {
this.hash = this.createHash();
this.finished = false;
}
createHash() {
return this.secret ? createHmac("sha256", toBuffer(this.secret)) : createHash("sha256");
}
};
}
function toBuffer(data) {
if (typeof data === "string") {
return data;
}
if (ArrayBuffer.isView(data)) {
return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
}
return Buffer.from(data);
}
var { digest, sign, importKey } = globalThis?.crypto?.subtle ?? {};
var subtle = typeof digest === "function" && typeof sign === "function" && typeof importKey === "function" ? globalThis.crypto.subtle : undefined;
var MAX_PENDING_BYTES = 8 * 1024 * 1024;
class Sha256WebCrypto {
digestLength = 32;
secret;
pending = [];
pendingBytes = 0;
fallback;
finished = false;
constructor(secret) {
if (secret) {
this.secret = toUint8Array(secret);
}
}
update(data) {
if (this.finished) {
throw new Error("Attempted to update an already finished HMAC.");
}
if (this.fallback) {
this.fallback.update(data);
return;
}
this.pending.push(data.slice());
this.pendingBytes += data.byteLength;
if (this.pendingBytes >= MAX_PENDING_BYTES) {
this.switchToFallback();
}
}
async digest() {
if (this.fallback) {
return this.fallback.digest();
}
if (this.secret && this.finished) {
throw new Error("Attempted to digest an already finished HMAC.");
}
const data = concatBytes(this.pending);
if (subtle) {
if (this.secret) {
this.finished = true;
const key = await subtle.importKey("raw", this.secret, { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
const sig = await subtle.sign("HMAC", key, data);
return new Uint8Array(sig);
}
const hash = await subtle.digest("SHA-256", data);
return new Uint8Array(hash);
}
const sha256 = new Sha256Js(this.secret);
sha256.update(data);
return sha256.digest();
}
reset() {
this.pending = [];
this.pendingBytes = 0;
this.fallback = undefined;
this.finished = false;
}
switchToFallback() {
const sha256Js = new Sha256Js(this.secret);
for (const chunk of this.pending) {
sha256Js.update(chunk);
}
this.fallback = sha256Js;
this.pending = [];
this.pendingBytes = 0;
}
}
exports.Crc32 = Crc32Node;
exports.Crc32Js = Crc32Js;
exports.Crc32Node = Crc32Node;
exports.Md5 = Md5Node;
exports.Md5Js = Md5Js;
exports.Md5Node = Md5Node;
exports.Sha256 = Sha256Node;
exports.Sha256Js = Sha256Js;
exports.Sha256Node = Sha256Node;
exports.Sha256WebCrypto = Sha256WebCrypto;
exports.blobHasher = blobHasher;
exports.blobReader = blobReader;
exports.fileStreamHasher = fileStreamHasher;
exports.readableStreamHasher = readableStreamHasher;
});
// ../../node_modules/.bun/@smithy+core@3.33.3/node_modules/@smithy/core/dist-cjs/submodules/event-streams/index.js
var require_event_streams = __commonJS(function(exports) {
var { Crc32 } = require_checksum();
var { hasOwn } = require_transport();
var { toHex, fromHex, toUtf8, fromUtf8 } = require_serde();
var { Readable } = __require("stream");
var { TypeRegistry } = require_schema();
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 > 9223372036854776000 || number < -9223372036854776000) {
throw new Error(`${number} is too large (or, if negative, too small) to represent as an Int64`);
}
const bytes = 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());
}
}
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;
}
}
class HeaderMarshaller {
toUtf8;
fromUtf8;
constructor(toUtf8, fromUtf8) {
this.toUtf8 = toUtf8;
this.fromUtf8 = fromUtf8;
}
format(headers) {
const chunks = [];
for (const headerName in headers) {
if (!hasOwn(headers, headerName))
continue;
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 = new DataView(new ArrayBuffer(3));
shortView.setUint8(0, 3);
shortView.setInt16(1, header.value, false);
return new Uint8Array(shortView.buffer);
case "integer":
const intView = new DataView(new ArrayBuffer(5));
intView.setUint8(0, 4);
intView.setInt32(1, header.value, false);
return new Uint8Array(intView.buffer);
case "long":
const longBytes = 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 = 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 = 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;
}
}
var HEADER_VALUE_TYPE;
(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 = {}));
var BOOLEAN_TAG = "boolean";
var BYTE_TAG = "byte";
var SHORT_TAG = "short";
var INT_TAG = "integer";
var LONG_TAG = "long";
var BINARY_TAG = "binary";
var STRING_TAG = "string";
var TIMESTAMP_TAG = "timestamp";
var UUID_TAG = "uuid";
var UUID_PATTERN = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
var PRELUDE_MEMBER_LENGTH = 4;
var PRELUDE_LENGTH = PRELUDE_MEMBER_LENGTH * 2;
var CHECKSUM_LENGTH = 4;
var MINIMUM_MESSAGE_LENGTH = PRELUDE_LENGTH + CHECKSUM_LENGTH * 2;
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 Crc32;
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 - (PRELUDE_LENGTH + CHECKSUM_LENGTH)));
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 - (PRELUDE_LENGTH + CHECKSUM_LENGTH + CHECKSUM_LENGTH))
};
}
class EventStreamCodec {
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 Crc32;
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);
}
}
class MessageDecoderStream {
options;
constructor(options) {
this.options = options;
}
[Symbol.asyncIterator]() {
return this.asyncIterator();
}
async* asyncIterator() {
for await (const bytes of this.options.inputStream) {
const decoded = this.options.decoder.decode(bytes);
yield decoded;
}
}
}
class MessageEncoderStream {
options;
constructor(options) {
this.options = options;
}
[Symbol.asyncIterator]() {
return this.asyncIterator();
}
async* asyncIterator() {
for await (const msg of this.options.messageStream) {
const encoded = this.options.encoder.encode(msg);
yield encoded;
}
if (this.options.includeEndFrame) {
yield new Uint8Array(0);
}
}
}
class SmithyMessageDecoderStream {
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 === undefined)
continue;
yield deserialized;
}
}
}
class SmithyMessageEncoderStream {
options;
constructor(options) {
this.options = options;
}
[Symbol.asyncIterator]() {
return this.asyncIterator();
}
async* asyncIterator() {
for await (const chunk of this.options.inputStream) {
const payloadBuf = this.options.serializer(chunk);
yield payloadBuf;
}
}
}
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);
const currentMessageView = new DataView(currentMessage.buffer);
currentMessageView.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 = 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
};
}
function getUnmarshalledStream(source, options) {
const messageUnmarshaller = getMessageUnmarshaller(options.deserializer, options.toUtf8);
return {
[Symbol.asyncIterator]: async function* () {
for await (const chunk of source) {
const message = options.eventStreamCodec.decode(chunk);
const type = await messageUnmarshaller(message);
if (type === undefined)
continue;
yield type;
}
}
};
}
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 exception = { [code]: message };
const deserializedException = await deserializer(exception);
if (deserializedException.$unknown) {
const error = new Error(toUtf8(message.body));
error.name = code;
throw error;
}
throw deserializedException[code];
} else if (messageType === "event") {
const event = {
[message.headers[":event-type"].value]: message
};
const deserialized = await deserializer(event);
if (deserialized.$unknown)
return;
return deserialized;
} else {
throw Error(`Unrecognizable event type: ${message.headers[":event-type"].value}`);
}
};
}
var EventStreamMarshaller$1 = class EventStreamMarshaller {
eventStreamCodec;
utfEncoder;
constructor({ utf8Encoder, utf8Decoder }) {
this.eventStreamCodec = new EventStreamCodec(utf8Encoder, utf8Decoder);
this.utfEncoder = utf8Encoder;
}
deserialize(body, deserializer) {
const inputStream = getChunkedStream(body);
return new SmithyMessageDecoderStream({
messageStream: new MessageDecoderStream({ inputStream, decoder: this.eventStreamCodec }),
deserializer: getMessageUnmarshaller(deserializer, this.utfEncoder)
});
}
serialize(inputStream, serializer) {
return new MessageEncoderStream({
messageStream: new SmithyMessageEncoderStream({ inputStream, serializer }),
encoder: this.eventStreamCodec,
includeEndFrame: true
});
}
};
var eventStreamSerdeProvider$1 = (options) => new EventStreamMarshaller$1(options);
class EventStreamMarshaller {
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));
}
}
var eventStreamSerdeProvider = (options) => new EventStreamMarshaller(options);
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 readableStreamToIterable = (readableStream) => ({
[Symbol.asyncIterator]: async function* () {
const reader = readableStream.getReader();
try {
while (true) {
const { done, value } = await reader.read();
if (done)
return;
yield value;
}
} finally {
reader.releaseLock();
}
}
});
var iterableToReadableStream = (asyncIterable) => {
const iterator = asyncIterable[Symbol.asyncIterator]();
return new ReadableStream({
async pull(controller) {
const { done, value } = await iterator.next();
if (done) {
return controller.close();
}
controller.enqueue(value);
}
});
};
var resolveEventStreamSerdeConfig = (input) => Object.assign(input, {
eventStreamMarshaller: input.eventStreamSerdeProvider(input)
});
class EventStreamSerde {
marshaller;
serializer;
deserializer;
serdeContext;
defaultContentType;
compositeErrorRegistry;
constructor({ marshaller, serializer, deserializer, serdeContext, defaultContentType, compositeErrorRegistry }) {
this.marshaller = marshaller;
this.serializer = serializer;
this.deserializer = deserializer;
this.serdeContext = serdeContext;
this.defaultContentType = defaultContentType;
this.compositeErrorRegistry = compositeErrorRegistry;
}
async serializeEventStream({ eventStream, requestSchema, initialRequest, initialMessageType }) {
const marshaller = this.marshaller;
const eventStreamMember = requestSchema.getEventStreamMember();
const unionSchema = requestSchema.getMemberSchema(eventStreamMember);
const serializer = this.serializer;
const defaultContentType = this.defaultContentType;
const initialRequestMarker = Symbol("initialRequestMarker");
const eventStreamIterable = {
async* [Symbol.asyncIterator]() {
if (initialRequest) {
const headers = {
":event-type": { type: "string", value: initialMessageType ?? "initial-request" },
":message-type": { type: "string", value: "event" },
":content-type": { type: "string", value: defaultContentType }
};
serializer.write(requestSchema, initialRequest);
const body = serializer.flush();
yield {
[initialRequestMarker]: true,
headers,
body
};
}
for await (const page of eventStream) {
yield page;
}
}
};
return marshaller.serialize(eventStreamIterable, (event) => {
if (event[initialRequestMarker]) {
return {
headers: event.headers,
body: event.body
};
}
let unionMember = "";
for (const key in event) {
if (!hasOwn(event, key))
continue;
if (key !== "__type") {
unionMember = key;
break;
}
}
const { additionalHeaders, body, eventType, explicitPayloadContentType } = this.writeEventBody(unionMember, unionSchema, event);
const headers = {
":event-type": { type: "string", value: eventType },
":message-type": { type: "string", value: "event" },
":content-type": { type: "string", value: explicitPayloadContentType ?? defaultContentType },
...additionalHeaders
};
return {
headers,
body
};
});
}
async deserializeEventStream({ response, responseSchema, initialResponseContainer, initialMessageType }) {
const marshaller = this.marshaller;
const eventStreamMember = responseSchema.getEventStreamMember();
const unionSchema = responseSchema.getMemberSchema(eventStreamMember);
const memberSchemas = unionSchema.getMemberSchemas();
const initialResponseMarker = Symbol("initialResponseMarker");
const asyncIterable = marshaller.deserialize(response.body, async (event) => {
let unionMember = "";
for (const key in event) {
if (!hasOwn(event, key))
continue;
if (key !== "__type") {
unionMember = key;
break;
}
}
const body = event[unionMember].body;
if (unionMember === (initialMessageType ?? "initial-response")) {
const dataObject = await this.deserializer.read(responseSchema, body);
delete dataObject[eventStreamMember];
return {
[initialResponseMarker]: true,
...dataObject
};
} else if (unionMember in memberSchemas) {
const eventStreamSchema = memberSchemas[unionMember];
if (eventStreamSchema.isStructSchema()) {
const out = {};
let hasBindings = false;
for (const [name, member] of eventStreamSchema.structIterator()) {
const { eventHeader, eventPayload } = member.getMergedTraits();
hasBindings = hasBindings || Boolean(eventHeader || eventPayload);
if (eventPayload) {
if (member.isBlobSchema()) {
out[name] = body;
} else if (member.isStringSchema()) {
out[name] = (this.serdeContext?.utf8Encoder ?? toUtf8)(body);
} else if (member.isStructSchema()) {
out[name] = await this.deserializer.read(member, body);
}
} else if (eventHeader) {
const value = event[unionMember].headers[name]?.value;
if (value != null) {
if (member.isNumericSchema()) {
if (value && typeof value === "object" && "bytes" in value) {
out[name] = BigInt(value.toString());
} else {
out[name] = Number(value);
}
} else {
out[name] = value;
}
}
}
}
return {
[unionMember]: await this.readEventMember(eventStreamSchema, body, hasBindings, out)
};
}
return {
[unionMember]: await this.deserializer.read(eventStreamSchema, body)
};
} else {
return {
$unknown: event
};
}
});
const asyncIterator = asyncIterable[Symbol.asyncIterator]();
const firstEvent = await asyncIterator.next();
if (firstEvent.done) {
return asyncIterable;
}
if (firstEvent.value?.[initialResponseMarker]) {
if (!responseSchema) {
throw new Error("@smithy::core/protocols - initial-response event encountered in event stream but no response schema given.");
}
for (const key in firstEvent.value) {
if (!hasOwn(firstEvent.value, key))
continue;
initialResponseContainer[key] = firstEvent.value[key];
}
}
return {
async* [Symbol.asyncIterator]() {
if (!firstEvent?.value?.[initialResponseMarker]) {
yield firstEvent.value;
}
while (true) {
const { done, value } = await asyncIterator.next();
if (done) {
break;
}
yield value;
}
}
};
}
async readEventMember(eventStreamSchema, body, hasBindings, out) {
let ErrCtor;
const staticStructuralSchema = eventStreamSchema.getSchema();
if (Array.isArray(staticStructuralSchema) && staticStructuralSchema[0] === -3) {
const namespace = staticStructuralSchema[1];
const nsRegistry = TypeRegistry.for(namespace);
this.compositeErrorRegistry?.copyFrom(nsRegistry);
ErrCtor = (this.compositeErrorRegistry ?? nsRegistry)?.getErrorCtor(staticStructuralSchema);
}
const dataObject = hasBindings ? out : body.byteLength === 0 ? {} : await this.deserializer.read(eventStreamSchema, body);
if (ErrCtor) {
const message = dataObject.message ?? dataObject.Message ?? "Unknown";
const metadata = {};
const $fault = eventStreamSchema.getMergedTraits().error;
if ($fault) {
metadata.$fault = $fault;
}
return Object.assign(new ErrCtor({}), metadata, {
message
}, dataObject);
}
return dataObject;
}
writeEventBody(unionMember, unionSchema, event) {
const serializer = this.serializer;
let eventType = unionMember;
let explicitPayloadMember = null;
let explicitPayloadContentType;
const isKnownSchema = (() => {
const struct = unionSchema.getSchema();
return struct[4].includes(unionMember);
})();
const additionalHeaders = {};
if (!isKnownSchema) {
const [type, value] = event[unionMember];
eventType = type;
serializer.write(15, value);
} else {
const eventSchema = unionSchema.getMemberSchema(unionMember);
if (eventSchema.isStructSchema()) {
for (const [memberName, memberSchema] of eventSchema.structIterator()) {
const { eventHeader, eventPayload } = memberSchema.getMergedTraits();
if (eventPayload) {
explicitPayloadMember = memberName;
} else if (eventHeader) {
const value = event[unionMember][memberName];
let type = "binary";
if (memberSchema.isNumericSchema()) {
if ((-2) ** 31 <= value && value <= 2 ** 31 - 1) {
type = "integer";
} else {
type = "long";
}
} else if (memberSchema.isTimestampSchema()) {
type = "timestamp";
} else if (memberSchema.isStringSchema()) {
type = "string";
} else if (memberSchema.isBooleanSchema()) {
type = "boolean";
}
if (value != null) {
additionalHeaders[memberName] = {
type,
value
};
delete event[unionMember][memberName];
}
}
}
if (explicitPayloadMember !== null) {
const payloadSchema = eventSchema.getMemberSchema(explicitPayloadMember);
if (payloadSchema.isBlobSchema()) {
explicitPayloadContentType = "application/octet-stream";
} else if (payloadSchema.isStringSchema()) {
explicitPayloadContentType = "text/plain";
}
serializer.write(payloadSchema, event[unionMember][explicitPayloadMember]);
} else {
serializer.write(eventSchema, event[unionMember]);
}
} 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 body = typeof messageSerialization === "string" ? (this.serdeContext?.utf8Decoder ?? fromUtf8)(messageSerialization) : messageSerialization;
return {
body,
eventType,
explicitPayloadContentType,
additionalHeaders
};
}
}
exports.EventStreamCodec = EventStreamCodec;
exports.EventStreamMarshaller = EventStreamMarshaller;
exports.EventStreamSerde = EventStreamSerde;
exports.HeaderMarshaller = HeaderMarshaller;
exports.Int64 = Int64;
exports.MessageDecoderStream = MessageDecoderStream;
exports.MessageEncoderStream = MessageEncoderStream;
exports.SmithyMessageDecoderStream = SmithyMessageDecoderStream;
exports.SmithyMessageEncoderStream = SmithyMessageEncoderStream;
exports.UniversalEventStreamMarshaller = EventStreamMarshaller$1;
exports.eventStreamSerdeProvider = eventStreamSerdeProvider;
exports.getChunkedStream = getChunkedStream;
exports.getMessageUnmarshaller = getMessageUnmarshaller;
exports.getUnmarshalledStream = getUnmarshalledStream;
exports.iterableToReadableStream = iterableToReadableStream;
exports.readableStreamToIterable = readableStreamToIterable;
exports.resolveEventStreamSerdeConfig = resolveEventStreamSerdeConfig;
exports.universalEventStreamSerdeProvider = eventStreamSerdeProvider$1;
});
// ../../node_modules/.bun/@smithy+core@3.33.3/node_modules/@smithy/core/dist-cjs/submodules/protocols/index.js
var require_protocols = __commonJS(function(exports) {
var { Uint8ArrayBlobAdapter, sdkStreamMixin, splitEvery, splitHeader, fromBase64, _parseEpochTimestamp, _parseRfc7231DateTime, _parseRfc3339DateTimeWithOffset, LazyJsonString, NumericValue, toUtf8, fromUtf8, generateIdempotencyToken, toBase64, dateToUtcString, quoteHeader } = require_serde();
var { HttpRequest, HttpResponse, hasOwn, isValidHostname } = require_transport();
var { parseQueryString, parseUrl } = require_transport();
exports.HttpRequest = HttpRequest;
exports.HttpResponse = HttpResponse;
exports.isValidHostname = isValidHostname;
exports.parseQueryString = parseQueryString;
exports.parseUrl = parseUrl;
var { TypeRegistry, NormalizedSchema, translateTraits } = require_schema();
var { FieldPosition } = require_dist_cjs();
var collectBody = async (streamBody = new Uint8Array, context) => {
if (streamBody instanceof Uint8Array) {
return Uint8ArrayBlobAdapter.mutate(streamBody);
}
if (!streamBody) {
return Uint8ArrayBlobAdapter.mutate(new Uint8Array);
}
const fromContext = context.streamCollector(streamBody);
return Uint8ArrayBlobAdapter.mutate(await fromContext);
};
function extendedEncodeURIComponent(str) {
return encodeURIComponent(str).replace(/[!'()*]/g, function(c) {
return "%" + c.charCodeAt(0).toString(16).toUpperCase();
});
}
class SerdeContext {
serdeContext;
setSerdeContext(serdeContext) {
this.serdeContext = serdeContext;
}
}
class HttpProtocol extends SerdeContext {
options;
compositeErrorRegistry;
constructor(options) {
super();
this.options = options;
this.compositeErrorRegistry = TypeRegistry.for(options.defaultNamespace);
for (const etr of options.errorTypeRegistries ?? []) {
this.compositeErrorRegistry.copyFrom(etr);
}
}
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 || undefined;
request.username = endpoint.url.username || undefined;
request.password = endpoint.url.password || undefined;
if (!request.query) {
request.query = {};
}
for (const [k, v] of endpoint.url.searchParams.entries()) {
request.query[k] = v;
}
if (endpoint.headers) {
for (const name in endpoint.headers) {
if (!hasOwn(endpoint.headers, name))
continue;
request.headers[name] = endpoint.headers[name].join(", ");
}
}
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
};
if (endpoint.headers) {
for (const name in endpoint.headers) {
if (!hasOwn(endpoint.headers, name))
continue;
request.headers[name] = endpoint.headers[name];
}
}
return request;
}
}
setHostPrefix(request, operationSchema, input) {
if (this.serdeContext?.disableHostPrefix) {
return;
}
const inputNs = NormalizedSchema.of(operationSchema.input);
const opTraits = translateTraits(operationSchema.traits ?? {});
if (opTraits.endpoint) {
let hostPrefix = opTraits.endpoint?.[0];
if (typeof hostPrefix === "string") {
for (const [name, member] of inputNs.structIterator()) {
if (!member.getMergedTraits().hostLabel) {
continue;
}
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;
if (!isValidHostname(request.hostname)) {
throw new Error(`[${request.hostname}] is not a valid 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 serializeEventStream({ eventStream, requestSchema, initialRequest }) {
const eventStreamSerde = await this.loadEventStreamCapability();
return eventStreamSerde.serializeEventStream({
eventStream,
requestSchema,
initialRequest
});
}
async deserializeEventStream({ response, responseSchema, initialResponseContainer }) {
const eventStreamSerde = await this.loadEventStreamCapability();
return eventStreamSerde.deserializeEventStream({
response,
responseSchema,
initialResponseContainer
});
}
async loadEventStreamCapability() {
const { EventStreamSerde, eventStreamSerdeProvider } = require_event_streams();
const marshaller = this.resolveEventStreamMarshaller(eventStreamSerdeProvider);
return new EventStreamSerde({
marshaller,
serializer: this.serializer,
deserializer: this.deserializer,
serdeContext: this.serdeContext,
defaultContentType: this.getDefaultContentType(),
compositeErrorRegistry: this.compositeErrorRegistry
});
}
resolveEventStreamMarshaller(importedProvider) {
const context = this.serdeContext;
if (context.eventStreamMarshaller) {
return context.eventStreamMarshaller;
}
return importedProvider(this.serdeContext);
}
getDefaultContentType() {
throw new Error(`@smithy/core/protocols - ${this.constructor.name} getDefaultContentType() implementation missing.`);
}
async deserializeHttpMessage(schema, context, response, arg4, arg5) {
return [];
}
getEventStreamMarshaller() {
const context = this.serdeContext;
if (!context.eventStreamMarshaller) {
throw new Error("@smithy/core - HttpProtocol: eventStreamMarshaller missing in serdeContext.");
}
return context.eventStreamMarshaller;
}
}
class HttpBindingProtocol extends HttpProtocol {
async serializeRequest(operationSchema, _input, context) {
const input = _input && typeof _input === "object" ? _input : {};
const serializer = this.serializer;
const query = {};
const headers = {};
const endpoint = await context.endpoint();
const ns = NormalizedSchema.of(operationSchema?.input);
const payloadMemberNames = [];
const payloadMemberSchemas = [];
let hasNonHttpBindingMember = false;
let payload;
const request = new HttpRequest({
protocol: "",
hostname: "",
port: undefined,
path: "",
fragment: undefined,
query,
headers,
body: undefined
});
if (endpoint) {
this.updateServiceEndpoint(request, endpoint);
this.setHostPrefix(request, operationSchema, input);
const opTraits = 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 ?? "");
for (const [key, value] of traitSearchParams) {
query[key] = value;
}
}
}
for (const [memberName, memberNs] of ns.structIterator()) {
const memberTraits = memberNs.getMergedTraits() ?? {};
const inputMemberValue = input[memberName];
if (inputMemberValue == null && !memberNs.isIdempotencyToken()) {
if (memberTraits.httpLabel) {
if (request.path.includes(`{${memberName}+}`) || request.path.includes(`{${memberName}}`)) {
throw new Error(`No value provided for input HTTP label: ${memberName}.`);
}
}
continue;
}
if (memberTraits.httpPayload) {
const isStreaming = memberNs.isStreaming();
if (isStreaming) {
const isEventStream = memberNs.isStructSchema();
if (isEventStream) {
if (input[memberName]) {
payload = await this.serializeEventStream({
eventStream: input[memberName],
requestSchema: ns
});
}
} else {
payload = inputMemberValue;
}
} else {
serializer.write(memberNs, inputMemberValue);
payload = serializer.flush();
}
} else if (memberTraits.httpLabel) {
serializer.write(memberNs, inputMemberValue);
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));
}
} else if (memberTraits.httpHeader) {
serializer.write(memberNs, inputMemberValue);
headers[memberTraits.httpHeader.toLowerCase()] = String(serializer.flush());
} else if (typeof memberTraits.httpPrefixHeaders === "string") {
for (const key in inputMemberValue) {
if (!hasOwn(inputMemberValue, key))
continue;
const val = inputMemberValue[key];
const amalgam = memberTraits.httpPrefixHeaders + key;
serializer.write([memberNs.getValueSchema(), { httpHeader: amalgam }], val);
headers[amalgam.toLowerCase()] = serializer.flush();
}
} else if (memberTraits.httpQuery || memberTraits.httpQueryParams) {
this.serializeQuery(memberNs, inputMemberValue, query);
} else {
hasNonHttpBindingMember = true;
payloadMemberNames.push(memberName);
payloadMemberSchemas.push(memberNs);
}
}
if (hasNonHttpBindingMember && input) {
const [namespace, name] = (ns.getName(true) ?? "#Unknown").split("#");
const requiredMembers = ns.getSchema()[6];
const payloadSchema = [
3,
namespace,
name,
ns.getMergedTraits(),
payloadMemberNames,
payloadMemberSchemas,
undefined
];
if (requiredMembers) {
payloadSchema[6] = requiredMembers;
} else {
payloadSchema.pop();
}
serializer.write(payloadSchema, 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 in data) {
if (!hasOwn(data, key))
continue;
if (!(key in query)) {
const val = data[key];
const valueSchema = ns.getValueSchema();
Object.assign(valueSchema.getMergedTraits(), {
...traits,
httpQuery: key,
httpQueryParams: undefined
});
this.serializeQuery(valueSchema, 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(15, 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) {
if (!hasOwn(response.headers, header))
continue;
const value = response.headers[header];
delete response.headers[header];
response.headers[header.toLowerCase()] = value;
}
const nonHttpBindingMembers = await this.deserializeHttpMessage(ns, context, response, 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) {
if (dataFromBody[member] != null) {
dataObject[member] = dataFromBody[member];
}
}
}
} else if (nonHttpBindingMembers.discardResponseBody) {
await collectBody(response.body, context);
}
dataObject.$metadata = this.deserializeMetadata(response);
return dataObject;
}
async deserializeHttpMessage(schema, context, response, arg4, arg5) {
let dataObject;
if (arg4 instanceof Set) {
dataObject = arg5;
} else {
dataObject = arg4;
}
let discardResponseBody = true;
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) {
discardResponseBody = false;
const isStreaming = memberSchema.isStreaming();
if (isStreaming) {
const isEventStream = memberSchema.isStructSchema();
if (isEventStream) {
dataObject[memberName] = await this.deserializeEventStream({
response,
responseSchema: ns
});
} 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 (value != null) {
if (memberSchema.isListSchema()) {
const headerListValueSchema = memberSchema.getValueSchema();
headerListValueSchema.getMergedTraits().httpHeader = key;
let sections;
if (headerListValueSchema.isTimestampSchema() && headerListValueSchema.getSchema() === 4) {
sections = splitEvery(value, ",", 2);
} else {
sections = splitHeader(value);
}
const list = [];
for (const section of sections) {
list.push(await deserializer.read(headerListValueSchema, section.trim()));
}
dataObject[memberName] = list;
} else {
dataObject[memberName] = await deserializer.read(memberSchema, value);
}
}
} else if (memberTraits.httpPrefixHeaders !== undefined) {
dataObject[memberName] = {};
for (const header in response.headers) {
if (!hasOwn(response.headers, header))
continue;
if (header.startsWith(memberTraits.httpPrefixHeaders)) {
const value = response.headers[header];
const valueSchema = memberSchema.getValueSchema();
valueSchema.getMergedTraits().httpHeader = header;
dataObject[memberName][header.slice(memberTraits.httpPrefixHeaders.length)] = await deserializer.read(valueSchema, value);
}
}
} else if (memberTraits.httpResponseCode) {
dataObject[memberName] = response.statusCode;
} else {
nonHttpBindingMembers.push(memberName);
}
}
nonHttpBindingMembers.discardResponseBody = discardResponseBody;
return nonHttpBindingMembers;
}
}
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 input = _input && typeof _input === "object" ? _input : {};
const request = new HttpRequest({
protocol: "",
hostname: "",
port: undefined,
path: "/",
fragment: undefined,
query,
headers,
body: undefined
});
if (endpoint) {
this.updateServiceEndpoint(request, endpoint);
this.setHostPrefix(request, operationSchema, input);
}
if (input) {
const eventStreamMember = ns.getEventStreamMember();
if (eventStreamMember) {
if (input[eventStreamMember]) {
const initialRequest = {};
for (const [memberName] of ns.structIterator()) {
if (memberName !== eventStreamMember && input[memberName] != null) {
initialRequest[memberName] = input[memberName];
}
}
payload = await this.serializeEventStream({
eventStream: input[eventStreamMember],
requestSchema: ns,
initialRequest
});
}
} else {
serializer.write(schema, input);
payload = serializer.flush();
}
}
request.headers = Object.assign(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(15, 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) {
if (!hasOwn(response.headers, header))
continue;
const value = response.headers[header];
delete response.headers[header];
response.headers[header.toLowerCase()] = value;
}
const eventStreamMember = ns.getEventStreamMember();
if (eventStreamMember) {
dataObject[eventStreamMember] = await this.deserializeEventStream({
response,
responseSchema: ns,
initialResponseContainer: dataObject
});
} else {
const bytes = await collectBody(response.body, context);
if (bytes.byteLength > 0) {
Object.assign(dataObject, await deserializer.read(ns, bytes));
}
}
dataObject.$metadata = this.deserializeMetadata(response);
return dataObject;
}
}
var resolvedPath = (resolvedPath, input, memberName, labelValueProvider, uriLabel, isGreedyLabel) => {
if (input != null && input[memberName] !== undefined) {
const labelValue = labelValueProvider();
if (labelValue == null || labelValue.length <= 0) {
throw new Error("Empty value provided for input HTTP label: " + memberName + ".");
}
resolvedPath = resolvedPath.replace(uriLabel, isGreedyLabel ? labelValue.split("/").map((segment) => extendedEncodeURIComponent(segment)).join("/") : extendedEncodeURIComponent(labelValue));
} else {
throw new Error("No value provided for input HTTP label: " + memberName + ".");
}
return resolvedPath;
};
function requestBuilder(input, context) {
return new RequestBuilder(input, context);
}
class RequestBuilder {
input;
context;
query = {};
method = "";
headers = {};
path = "";
body = null;
hostname = "";
resolvePathStack = [];
constructor(input, context) {
this.input = input;
this.context = context;
}
async build() {
const { hostname, protocol = "https", port, path: basePath } = await this.context.endpoint();
this.path = basePath;
for (const resolvePath of this.resolvePathStack) {
resolvePath(this.path);
}
return new HttpRequest({
protocol,
hostname: this.hostname || hostname,
port,
method: this.method,
path: this.path,
query: this.query,
body: this.body,
headers: this.headers
});
}
hn(hostname) {
this.hostname = hostname;
return this;
}
bp(uriLabel) {
this.resolvePathStack.push((basePath) => {
this.path = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + uriLabel;
});
return this;
}
p(memberName, labelValueProvider, uriLabel, isGreedyLabel) {
this.resolvePathStack.push((path) => {
this.path = resolvedPath(path, this.input, memberName, labelValueProvider, uriLabel, isGreedyLabel);
});
return this;
}
h(headers) {
this.headers = headers;
return this;
}
q(query) {
this.query = query;
return this;
}
b(body) {
this.body = body;
return this;
}
m(method) {
this.method = method;
return this;
}
}
function determineTimestampFormat(ns, settings) {
if (settings.timestampFormat.useTrait) {
if (ns.isTimestampSchema() && (ns.getSchema() === 5 || ns.getSchema() === 6 || ns.getSchema() === 7)) {
return ns.getSchema();
}
}
const { httpLabel, httpPrefixHeaders, httpHeader, httpQuery } = ns.getMergedTraits();
const bindingFormat = settings.httpBindings ? typeof httpPrefixHeaders === "string" || Boolean(httpHeader) ? 6 : Boolean(httpQuery) || Boolean(httpLabel) ? 5 : undefined : undefined;
return bindingFormat ?? settings.timestampFormat.default;
}
class FromStringShapeDeserializer extends SerdeContext {
settings;
constructor(settings) {
super();
this.settings = settings;
}
read(_schema, data) {
const ns = NormalizedSchema.of(_schema);
if (ns.isListSchema()) {
return splitHeader(data).map((item) => this.read(ns.getValueSchema(), item));
}
if (ns.isBlobSchema()) {
return (this.serdeContext?.base64Decoder ?? fromBase64)(data);
}
if (ns.isTimestampSchema()) {
const format = determineTimestampFormat(ns, this.settings);
switch (format) {
case 5:
return _parseRfc3339DateTimeWithOffset(data);
case 6:
return _parseRfc7231DateTime(data);
case 7:
return _parseEpochTimestamp(data);
default:
console.warn("Missing timestamp format, parsing value with Date constructor:", data);
return new Date(data);
}
}
if (ns.isStringSchema()) {
const mediaType = ns.getMergedTraits().mediaType;
let intermediateValue = data;
if (mediaType) {
if (ns.getMergedTraits().httpHeader) {
intermediateValue = this.base64ToUtf8(intermediateValue);
}
const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
if (isJson) {
intermediateValue = LazyJsonString.from(intermediateValue);
}
return intermediateValue;
}
}
if (ns.isNumericSchema()) {
return Number(data);
}
if (ns.isBigIntegerSchema()) {
return BigInt(data);
}
if (ns.isBigDecimalSchema()) {
return new NumericValue(data, "bigDecimal");
}
if (ns.isBooleanSchema()) {
return String(data).toLowerCase() === "true";
}
return data;
}
base64ToUtf8(base64String) {
return (this.serdeContext?.utf8Encoder ?? toUtf8)((this.serdeContext?.base64Decoder ?? fromBase64)(base64String));
}
}
class HttpInterceptingShapeDeserializer extends SerdeContext {
codecDeserializer;
stringDeserializer;
constructor(codecDeserializer, codecSettings) {
super();
this.codecDeserializer = codecDeserializer;
this.stringDeserializer = new FromStringShapeDeserializer(codecSettings);
}
setSerdeContext(serdeContext) {
this.stringDeserializer.setSerdeContext(serdeContext);
this.codecDeserializer.setSerdeContext(serdeContext);
this.serdeContext = serdeContext;
}
read(schema, data) {
const ns = NormalizedSchema.of(schema);
const traits = ns.getMergedTraits();
const toString = this.serdeContext?.utf8Encoder ?? toUtf8;
if (traits.httpHeader || traits.httpResponseCode) {
return this.stringDeserializer.read(ns, toString(data));
}
if (traits.httpPayload) {
if (ns.isBlobSchema()) {
const toBytes = this.serdeContext?.utf8Decoder ?? fromUtf8;
if (typeof data === "string") {
return toBytes(data);
}
return data;
} else if (ns.isStringSchema()) {
if ("byteLength" in data) {
return toString(data);
}
return data;
}
}
return this.codecDeserializer.read(ns, data);
}
}
class ToStringShapeSerializer extends SerdeContext {
settings;
stringBuffer = "";
constructor(settings) {
super();
this.settings = settings;
}
write(schema, value) {
const ns = NormalizedSchema.of(schema);
switch (typeof value) {
case "object":
if (value === null) {
this.stringBuffer = "null";
return;
}
if (ns.isTimestampSchema()) {
if (!(value instanceof Date)) {
throw new Error(`@smithy/core/protocols - received non-Date value ${value} when schema expected Date in ${ns.getName(true)}`);
}
const format = determineTimestampFormat(ns, this.settings);
switch (format) {
case 5:
this.stringBuffer = value.toISOString().replace(".000Z", "Z");
break;
case 6:
this.stringBuffer = dateToUtcString(value);
break;
case 7:
this.stringBuffer = String(value.getTime() / 1000);
break;
default:
console.warn("Missing timestamp format, using epoch seconds", value);
this.stringBuffer = String(value.getTime() / 1000);
}
return;
}
if (ns.isBlobSchema() && "byteLength" in value) {
this.stringBuffer = (this.serdeContext?.base64Encoder ?? toBase64)(value);
return;
}
if (ns.isListSchema() && Array.isArray(value)) {
let buffer = "";
for (const item of value) {
this.write([ns.getValueSchema(), ns.getMergedTraits()], item);
const headerItem = this.flush();
const serialized = ns.getValueSchema().isTimestampSchema() ? headerItem : quoteHeader(headerItem);
if (buffer !== "") {
buffer += ", ";
}
buffer += serialized;
}
this.stringBuffer = buffer;
return;
}
this.stringBuffer = JSON.stringify(value, null, 2);
break;
case "string":
const mediaType = ns.getMergedTraits().mediaType;
let intermediateValue = value;
if (mediaType) {
const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
if (isJson) {
intermediateValue = LazyJsonString.from(intermediateValue);
}
if (ns.getMergedTraits().httpHeader) {
this.stringBuffer = (this.serdeContext?.base64Encoder ?? toBase64)(intermediateValue.toString());
return;
}
}
this.stringBuffer = value;
break;
default:
if (ns.isIdempotencyToken()) {
this.stringBuffer = generateIdempotencyToken();
} else {
this.stringBuffer = String(value);
}
}
}
flush() {
const buffer = this.stringBuffer;
this.stringBuffer = "";
return buffer;
}
}
class HttpInterceptingShapeSerializer {
codecSerializer;
stringSerializer;
buffer;
constructor(codecSerializer, codecSettings, stringSerializer = new ToStringShapeSerializer(codecSettings)) {
this.codecSerializer = codecSerializer;
this.stringSerializer = stringSerializer;
}
setSerdeContext(serdeContext) {
this.codecSerializer.setSerdeContext(serdeContext);
this.stringSerializer.setSerdeContext(serdeContext);
}
write(schema, value) {
const ns = NormalizedSchema.of(schema);
const traits = ns.getMergedTraits();
if (traits.httpHeader || traits.httpLabel || traits.httpQuery) {
this.stringSerializer.write(ns, value);
this.buffer = this.stringSerializer.flush();
return;
}
return this.codecSerializer.write(ns, value);
}
flush() {
if (this.buffer !== undefined) {
const buffer = this.buffer;
this.buffer = undefined;
return buffer;
}
return this.codecSerializer.flush();
}
}
class Field {
name;
kind;
values;
constructor({ name, kind = FieldPosition.HEADER, values = [] }) {
this.name = name;
this.kind = kind;
this.values = values;
}
add(value) {
this.values.push(value);
}
set(values) {
this.values = values;
}
remove(value) {
this.values = this.values.filter((v) => v !== value);
}
toString() {
return this.values.map((v) => v.includes(",") || v.includes(" ") ? `"${v}"` : v).join(", ");
}
get() {
return this.values;
}
}
class Fields {
entries = {};
encoding;
constructor({ fields = [], encoding = "utf-8" }) {
fields.forEach(this.setField.bind(this));
this.encoding = encoding;
}
setField(field) {
this.entries[field.name.toLowerCase()] = field;
}
getField(name) {
return this.entries[name.toLowerCase()];
}
removeField(name) {
delete this.entries[name.toLowerCase()];
}
getByType(kind) {
return Object.values(this.entries).filter((field) => field.kind === kind);
}
}
var getHttpHandlerExtensionConfiguration = (runtimeConfig) => {
if (runtimeConfig.logger && runtimeConfig.logger.constructor?.name !== "NoOpLogger") {
runtimeConfig.requestHandler?.updateHttpClientConfig?.(Symbol.for("logger"), runtimeConfig.logger);
}
return {
setHttpHandler(handler) {
runtimeConfig.requestHandler = handler;
},
httpHandler() {
return runtimeConfig.requestHandler;
},
updateHttpClientConfig(key, value) {
runtimeConfig.requestHandler?.updateHttpClientConfig(key, value);
},
httpHandlerConfigs() {
return runtimeConfig.requestHandler.httpHandlerConfigs();
}
};
};
var resolveHttpHandlerRuntimeConfig = (httpHandlerExtensionConfiguration) => {
return {
requestHandler: httpHandlerExtensionConfiguration.httpHandler()
};
};
var CONTENT_LENGTH_HEADER = "content-length";
function contentLengthMiddleware(bodyLengthChecker) {
return (next) => async (args) => {
const request = args.request;
if (HttpRequest.isInstance(request)) {
const { body, headers } = request;
if (body && Object.keys(headers).map((str) => str.toLowerCase()).indexOf(CONTENT_LENGTH_HEADER) === -1) {
try {
const length = bodyLengthChecker(body);
if (length != null) {
request.headers = {
...request.headers,
[CONTENT_LENGTH_HEADER]: String(length)
};
}
} catch (ignored) {}
}
}
return next({
...args,
request
});
};
}
var contentLengthMiddlewareOptions = {
step: "build",
tags: ["SET_CONTENT_LENGTH", "CONTENT_LENGTH"],
name: "contentLengthMiddleware",
override: true
};
var getContentLengthPlugin = (options) => ({
applyToStack: (clientStack) => {
clientStack.add(contentLengthMiddleware(options.bodyLengthChecker), contentLengthMiddlewareOptions);
}
});
var escapeUri = (uri) => encodeURIComponent(uri).replace(/[!'()*]/g, hexEncode);
var hexEncode = (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`;
var escapeUriPath = (uri) => uri.split("/").map(escapeUri).join("/");
function buildQueryString(query) {
const parts = [];
for (let key of Object.keys(query).sort()) {
const value = query[key];
key = escapeUri(key);
if (Array.isArray(value)) {
for (let i = 0, iLen = value.length;i < iLen; i++) {
parts.push(`${key}=${escapeUri(value[i])}`);
}
} else {
let qsEntry = key;
if (value || typeof value === "string") {
qsEntry += `=${escapeUri(value)}`;
}
parts.push(qsEntry);
}
}
return parts.join("&");
}
exports.Field = Field;
exports.Fields = Fields;
exports.FromStringShapeDeserializer = FromStringShapeDeserializer;
exports.HttpBindingProtocol = HttpBindingProtocol;
exports.HttpInterceptingShapeDeserializer = HttpInterceptingShapeDeserializer;
exports.HttpInterceptingShapeSerializer = HttpInterceptingShapeSerializer;
exports.HttpProtocol = HttpProtocol;
exports.RequestBuilder = RequestBuilder;
exports.RpcProtocol = RpcProtocol;
exports.SerdeContext = SerdeContext;
exports.ToStringShapeSerializer = ToStringShapeSerializer;
exports.buildQueryString = buildQueryString;
exports.collectBody = collectBody;
exports.contentLengthMiddleware = contentLengthMiddleware;
exports.contentLengthMiddlewareOptions = contentLengthMiddlewareOptions;
exports.determineTimestampFormat = determineTimestampFormat;
exports.escapeUri = escapeUri;
exports.escapeUriPath = escapeUriPath;
exports.extendedEncodeURIComponent = extendedEncodeURIComponent;
exports.getContentLengthPlugin = getContentLengthPlugin;
exports.getHttpHandlerExtensionConfiguration = getHttpHandlerExtensionConfiguration;
exports.requestBuilder = requestBuilder;
exports.resolveHttpHandlerRuntimeConfig = resolveHttpHandlerRuntimeConfig;
exports.resolvedPath = resolvedPath;
});
// ../../node_modules/.bun/@smithy+core@3.33.3/node_modules/@smithy/core/dist-cjs/submodules/retry/index.js
var require_retry = __commonJS(function(exports) {
var { Readable } = __require("stream");
var { NoOpLogger, normalizeProvider } = require_client();
var { HttpResponse, HttpRequest } = require_protocols();
var { parseRfc7231DateTime, v4 } = require_serde();
var { hasOwn } = require_transport();
var isStreamingPayload = (request) => request?.body instanceof Readable || typeof ReadableStream !== "undefined" && request?.body instanceof ReadableStream;
var CLOCK_SKEW_ERROR_CODES = [
"AccessDeniedException",
"AuthFailure",
"InvalidSignatureException",
"RequestExpired",
"RequestInTheFuture",
"RequestTimeTooSkewed",
"SignatureDoesNotMatch"
];
var THROTTLING_ERROR_CODES = [
"BandwidthLimitExceeded",
"EC2ThrottledException",
"LimitExceededException",
"PriorRequestNotComplete",
"ProvisionedThroughputExceededException",
"RequestLimitExceeded",
"RequestThrottled",
"RequestThrottledException",
"SlowDown",
"ThrottledException",
"Throttling",
"ThrottlingException",
"TooManyRequestsException",
"TransactionInProgressException"
];
var TRANSIENT_ERROR_CODES = ["TimeoutError", "RequestTimeout", "RequestTimeoutException"];
var TRANSIENT_ERROR_STATUS_CODES = [500, 502, 503, 504];
var NODEJS_TIMEOUT_ERROR_CODES = ["ECONNRESET", "ECONNREFUSED", "EPIPE", "ETIMEDOUT"];
var NODEJS_NETWORK_ERROR_CODES = ["EHOSTUNREACH", "ENETUNREACH", "ENOTFOUND", "EAI_AGAIN"];
var isRetryableByTrait = (error) => error?.$retryable !== undefined;
var isClockSkewError = (error) => CLOCK_SKEW_ERROR_CODES.includes(error.name);
var isClockSkewCorrectedError = (error) => error.$metadata?.clockSkewCorrected;
var isBrowserNetworkError = (error) => {
const errorMessages = new Set([
"Failed to fetch",
"NetworkError when attempting to fetch resource",
"The Internet connection appears to be offline",
"Load failed",
"Network request failed"
]);
const isValid = error && error instanceof TypeError;
if (!isValid) {
return false;
}
return errorMessages.has(error.message);
};
var isThrottlingError = (error) => error.$metadata?.httpStatusCode === 429 || THROTTLING_ERROR_CODES.includes(error.name) || error.$retryable?.throttling == true;
var isTransientError = (error, depth = 0) => isRetryableByTrait(error) || isClockSkewCorrectedError(error) || error.name === "InvalidSignatureException" && error.message?.includes("Signature expired") || TRANSIENT_ERROR_CODES.includes(error.name) || NODEJS_TIMEOUT_ERROR_CODES.includes(error?.code || "") || NODEJS_NETWORK_ERROR_CODES.includes(error?.code || "") || TRANSIENT_ERROR_STATUS_CODES.includes(error.$metadata?.httpStatusCode || 0) || isBrowserNetworkError(error) || isNodeJsHttp2TransientError(error) || error.cause !== undefined && depth <= 10 && isTransientError(error.cause, depth + 1);
var isServerError = (error) => {
if (error.$metadata?.httpStatusCode !== undefined) {
const statusCode = error.$metadata.httpStatusCode;
if (500 <= statusCode && statusCode <= 599 && !isTransientError(error)) {
return true;
}
return false;
}
return false;
};
function isNodeJsHttp2TransientError(error) {
return error.code === "ERR_HTTP2_STREAM_ERROR" && error.message.includes("NGHTTP2_REFUSED_STREAM");
}
var DEFAULT_RETRY_DELAY_BASE = 100;
var MAXIMUM_RETRY_DELAY = 20 * 1000;
var THROTTLING_RETRY_DELAY_BASE = 500;
var INITIAL_RETRY_TOKENS = 500;
var RETRY_COST = 5;
var TIMEOUT_RETRY_COST = 10;
var NO_RETRY_INCREMENT = 1;
var INVOCATION_ID_HEADER = "amz-sdk-invocation-id";
var REQUEST_HEADER = "amz-sdk-request";
function parseRetryAfterHeader(response, logger) {
if (!HttpResponse.isInstance(response)) {
return;
}
for (const header in response.headers) {
if (!hasOwn(response.headers, header))
continue;
const h = header.toLowerCase();
if (h === "retry-after") {
const retryAfter = response.headers[header];
let retryAfterSeconds = NaN;
if (retryAfter.endsWith("GMT")) {
try {
const date = parseRfc7231DateTime(retryAfter);
retryAfterSeconds = (date.getTime() - Date.now()) / 1000;
} catch (e) {
logger?.trace?.("Failed to parse retry-after header");
logger?.trace?.(e);
}
} else if (retryAfter.match(/ GMT, ((\d+)|(\d+\.\d+))$/)) {
retryAfterSeconds = Number(retryAfter.match(/ GMT, ([\d.]+)$/)?.[1]);
} else if (retryAfter.match(/^((\d+)|(\d+\.\d+))$/)) {
retryAfterSeconds = Number(retryAfter);
} else if (Date.parse(retryAfter) >= Date.now()) {
retryAfterSeconds = (Date.parse(retryAfter) - Date.now()) / 1000;
}
if (isNaN(retryAfterSeconds)) {
return;
}
return new Date(Date.now() + retryAfterSeconds * 1000);
} else if (h === "x-amz-retry-after") {
const v = response.headers[header];
const backoffMilliseconds = Number(v);
if (isNaN(backoffMilliseconds)) {
logger?.trace?.(`Failed to parse x-amz-retry-after=${v}`);
return;
}
return new Date(Date.now() + backoffMilliseconds);
}
}
}
function getRetryAfterHint(response, logger) {
return parseRetryAfterHeader(response, logger);
}
var asSdkError = (error) => {
if (error instanceof Error)
return error;
if (error instanceof Object)
return Object.assign(new Error, error);
if (typeof error === "string")
return new Error(error);
return new Error(`AWS SDK error wrapper for ${error}`);
};
function bindRetryMiddleware(isStreamingPayload) {
return (options) => (next, context) => async (args) => {
let retryStrategy = await options.retryStrategy();
const maxAttempts = await options.maxAttempts();
if (isRetryStrategyV2(retryStrategy)) {
retryStrategy = retryStrategy;
let retryToken = await retryStrategy.acquireInitialRetryToken((context["partition_id"] ?? "") + (context.__retryLongPoll ? ":longpoll" : ""));
let lastError = new Error;
let attempts = 0;
let totalRetryDelay = 0;
const { request } = args;
const isRequest = HttpRequest.isInstance(request);
if (isRequest) {
request.headers[INVOCATION_ID_HEADER] = v4();
}
while (true) {
try {
if (isRequest) {
request.headers[REQUEST_HEADER] = `attempt=${attempts + 1}; max=${maxAttempts}`;
}
const { response, output } = await next(args);
retryStrategy.recordSuccess(retryToken);
output.$metadata.attempts = attempts + 1;
output.$metadata.totalRetryDelay = totalRetryDelay;
return { response, output };
} catch (e) {
const retryErrorInfo = getRetryErrorInfo(e, options.logger);
lastError = asSdkError(e);
if (isRequest && isStreamingPayload(request)) {
(context.logger instanceof NoOpLogger ? console : context.logger)?.warn("An error was encountered in a non-retryable streaming request.");
throw lastError;
}
try {
retryToken = await retryStrategy.refreshRetryTokenForRetry(retryToken, retryErrorInfo);
} catch (ignoredRefreshError) {
if (!lastError.$metadata) {
lastError.$metadata = {};
}
lastError.$metadata.attempts = attempts + 1;
lastError.$metadata.totalRetryDelay = totalRetryDelay;
throw lastError;
}
attempts = retryToken.getRetryCount();
const delay = retryToken.getRetryDelay();
totalRetryDelay += (retryToken?.$retryLog?.acquisitionDelay ?? 0) + delay;
if (delay > 0) {
await cooldown(delay);
}
}
}
} else {
retryStrategy = retryStrategy;
if (retryStrategy?.mode) {
context.userAgent = [...context.userAgent || [], ["cfg/retry-mode", retryStrategy.mode]];
}
return retryStrategy.retry(next, args);
}
};
}
var cooldown = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
var isRetryStrategyV2 = (retryStrategy) => typeof retryStrategy.acquireInitialRetryToken !== "undefined" && typeof retryStrategy.refreshRetryTokenForRetry !== "undefined" && typeof retryStrategy.recordSuccess !== "undefined";
var getRetryErrorInfo = (error, logger) => {
const errorInfo = {
error,
errorType: getRetryErrorType(error)
};
const retryAfterHint = parseRetryAfterHeader(error.$response, logger);
if (retryAfterHint) {
errorInfo.retryAfterHint = retryAfterHint;
}
return errorInfo;
};
var getRetryErrorType = (error) => {
if (isThrottlingError(error))
return "THROTTLING";
if (isTransientError(error))
return "TRANSIENT";
if (isServerError(error))
return "SERVER_ERROR";
return "CLIENT_ERROR";
};
var retryMiddlewareOptions = {
name: "retryMiddleware",
tags: ["RETRY"],
step: "finalizeRequest",
priority: "high",
override: true
};
function bindGetRetryPlugin(isStreamingPayload) {
const retryMiddleware = bindRetryMiddleware(isStreamingPayload);
return (options) => ({
applyToStack: (clientStack) => {
clientStack.add(retryMiddleware(options), retryMiddlewareOptions);
}
});
}
class DefaultRateLimiter {
static setTimeoutFn = (fn, delay) => setTimeout(fn, delay);
beta;
minCapacity;
minFillRate;
scaleConstant;
smooth;
enabled = false;
availableTokens = 0;
lastMaxRate = 0;
measuredTxRate = 0;
requestCount = 0;
fillRate;
lastThrottleTime;
lastTimestamp = 0;
lastTxRateBucket;
maxCapacity;
timeWindow = 0;
constructor(options) {
this.beta = options?.beta ?? 0.7;
this.minCapacity = options?.minCapacity ?? 1;
this.minFillRate = options?.minFillRate ?? 0.5;
this.scaleConstant = options?.scaleConstant ?? 0.4;
this.smooth = options?.smooth ?? 0.8;
this.lastThrottleTime = this.getCurrentTimeInSeconds();
this.lastTxRateBucket = Math.floor(this.getCurrentTimeInSeconds());
this.fillRate = this.minFillRate;
this.maxCapacity = this.minCapacity;
}
async getSendToken() {
return this.acquireTokenBucket(1);
}
updateClientSendingRate(response) {
let calculatedRate;
this.updateMeasuredRate();
const retryErrorInfo = response;
const isThrottling = retryErrorInfo?.errorType === "THROTTLING" || isThrottlingError(retryErrorInfo?.error ?? response);
if (isThrottling) {
const rateToUse = !this.enabled ? this.measuredTxRate : Math.min(this.measuredTxRate, this.fillRate);
this.lastMaxRate = rateToUse;
this.calculateTimeWindow();
this.lastThrottleTime = this.getCurrentTimeInSeconds();
calculatedRate = this.cubicThrottle(rateToUse);
this.enableTokenBucket();
} else {
this.calculateTimeWindow();
calculatedRate = this.cubicSuccess(this.getCurrentTimeInSeconds());
}
const newRate = Math.min(calculatedRate, 2 * this.measuredTxRate);
this.updateTokenBucketRate(newRate);
}
getCurrentTimeInSeconds() {
return Date.now() / 1000;
}
async acquireTokenBucket(amount) {
if (!this.enabled) {
return;
}
this.refillTokenBucket();
while (amount > this.availableTokens) {
const delay = (amount - this.availableTokens) / this.fillRate * 1000;
await new Promise((resolve) => DefaultRateLimiter.setTimeoutFn(resolve, delay));
this.refillTokenBucket();
}
this.availableTokens = this.availableTokens - amount;
}
refillTokenBucket() {
const timestamp = this.getCurrentTimeInSeconds();
if (!this.lastTimestamp) {
this.lastTimestamp = timestamp;
return;
}
const fillAmount = (timestamp - this.lastTimestamp) * this.fillRate;
this.availableTokens = Math.min(this.maxCapacity, this.availableTokens + fillAmount);
this.lastTimestamp = timestamp;
}
calculateTimeWindow() {
this.timeWindow = this.getPrecise(Math.pow(this.lastMaxRate * (1 - this.beta) / this.scaleConstant, 1 / 3));
}
cubicThrottle(rateToUse) {
return this.getPrecise(rateToUse * this.beta);
}
cubicSuccess(timestamp) {
return this.getPrecise(this.scaleConstant * Math.pow(timestamp - this.lastThrottleTime - this.timeWindow, 3) + this.lastMaxRate);
}
enableTokenBucket() {
this.enabled = true;
}
updateTokenBucketRate(newRate) {
this.refillTokenBucket();
this.fillRate = Math.max(newRate, this.minFillRate);
this.maxCapacity = Math.max(newRate, this.minCapacity);
this.availableTokens = Math.min(this.availableTokens, this.maxCapacity);
}
updateMeasuredRate() {
const t = this.getCurrentTimeInSeconds();
const timeBucket = Math.floor(t * 2) / 2;
this.requestCount++;
if (timeBucket > this.lastTxRateBucket) {
const currentRate = this.requestCount / (timeBucket - this.lastTxRateBucket);
this.measuredTxRate = this.getPrecise(currentRate * this.smooth + this.measuredTxRate * (1 - this.smooth));
this.requestCount = 0;
this.lastTxRateBucket = timeBucket;
}
}
getPrecise(num) {
return parseFloat(num.toFixed(8));
}
}
class Retry {
static v2026 = typeof process !== "undefined" && process.env?.SMITHY_NEW_RETRIES_2026 === "true";
static delay() {
return Retry.v2026 ? 50 : 100;
}
static throttlingDelay() {
return Retry.v2026 ? 1000 : 500;
}
static cost() {
return Retry.v2026 ? 14 : 5;
}
static throttlingCost() {
return Retry.v2026 ? 5 : 10;
}
static modifiedCostType() {
return Retry.v2026 ? "THROTTLING" : "TRANSIENT";
}
}
class DefaultRetryBackoffStrategy {
x = Retry.delay();
computeNextBackoffDelay(i) {
const b = Math.random();
const r = 2;
const t_i = b * Math.min(this.x * r ** i, MAXIMUM_RETRY_DELAY);
return Math.floor(t_i);
}
setDelayBase(delay) {
this.x = delay;
}
}
class DefaultRetryToken {
delay;
count;
cost;
longPoll;
$retryLog = {
acquisitionDelay: 0
};
constructor(delay, count, cost, longPoll) {
this.delay = delay;
this.count = count;
this.cost = cost;
this.longPoll = longPoll;
}
getRetryCount() {
return this.count;
}
getRetryDelay() {
return Math.min(MAXIMUM_RETRY_DELAY, this.delay);
}
getRetryCost() {
return this.cost;
}
isLongPoll() {
return this.longPoll;
}
}
var RETRY_MODES;
(function(RETRY_MODES) {
RETRY_MODES["STANDARD"] = "standard";
RETRY_MODES["ADAPTIVE"] = "adaptive";
})(RETRY_MODES || (RETRY_MODES = {}));
var DEFAULT_MAX_ATTEMPTS = 3;
var DEFAULT_RETRY_MODE = RETRY_MODES.STANDARD;
var refusal = {
incompatible: 1,
attempts: 2,
capacity: 3
};
var StandardRetryStrategy$1 = class StandardRetryStrategy {
mode = RETRY_MODES.STANDARD;
retryBackoffStrategy;
capacity = INITIAL_RETRY_TOKENS;
maxAttemptsProvider;
baseDelay;
constructor(arg1) {
if (typeof arg1 === "number") {
this.maxAttemptsProvider = async () => arg1;
} else if (typeof arg1 === "function") {
this.maxAttemptsProvider = arg1;
} else if (arg1 && typeof arg1 === "object") {
this.maxAttemptsProvider = async () => arg1.maxAttempts;
this.baseDelay = arg1.baseDelay;
this.retryBackoffStrategy = arg1.backoff;
}
this.maxAttemptsProvider ??= async () => DEFAULT_MAX_ATTEMPTS;
this.baseDelay ??= Retry.delay();
this.retryBackoffStrategy ??= new DefaultRetryBackoffStrategy;
}
async acquireInitialRetryToken(retryTokenScope) {
return new DefaultRetryToken(Retry.delay(), 0, undefined, Retry.v2026 && retryTokenScope.includes(":longpoll"));
}
async refreshRetryTokenForRetry(token, errorInfo) {
const maxAttempts = await this.getMaxAttempts();
const retryCode = this.retryCode(token, errorInfo, maxAttempts);
const shouldRetry = retryCode === 0;
const isLongPoll = token.isLongPoll?.();
if (shouldRetry || isLongPoll) {
const errorType = errorInfo.errorType;
this.retryBackoffStrategy.setDelayBase(errorType === "THROTTLING" ? Retry.throttlingDelay() : this.baseDelay);
const delayFromErrorType = this.retryBackoffStrategy.computeNextBackoffDelay(token.getRetryCount());
let retryDelay = delayFromErrorType;
if (errorInfo.retryAfterHint instanceof Date) {
retryDelay = Math.max(delayFromErrorType, Math.min(errorInfo.retryAfterHint.getTime() - Date.now(), delayFromErrorType + 5000));
}
if (!shouldRetry) {
const longPollBackoff = Retry.v2026 && retryCode === refusal.capacity && isLongPoll ? retryDelay : 0;
if (longPollBackoff > 0) {
await new Promise((r) => setTimeout(r, longPollBackoff));
}
} else {
const capacityCost = this.getCapacityCost(errorType);
this.capacity -= capacityCost;
const nextToken = new DefaultRetryToken(0, token.getRetryCount() + 1, capacityCost, token.isLongPoll?.() ?? false);
await new Promise((r) => setTimeout(r, retryDelay));
nextToken.$retryLog.acquisitionDelay = retryDelay;
return nextToken;
}
}
throw new Error("No retry token available");
}
recordSuccess(token) {
this.capacity = Math.min(INITIAL_RETRY_TOKENS, this.capacity + (token.getRetryCost() ?? NO_RETRY_INCREMENT));
}
getCapacity() {
return this.capacity;
}
async maxAttempts() {
return this.maxAttemptsProvider();
}
async getMaxAttempts() {
try {
return await this.maxAttemptsProvider();
} catch (ignored) {
console.warn(`Max attempts provider could not resolve. Using default of ${DEFAULT_MAX_ATTEMPTS}`);
return DEFAULT_MAX_ATTEMPTS;
}
}
retryCode(tokenToRenew, errorInfo, maxAttempts) {
const attempts = tokenToRenew.getRetryCount() + 1;
const retryableStatus = this.isRetryableError(errorInfo.errorType) ? 0 : refusal.incompatible;
const attemptStatus = attempts < maxAttempts ? 0 : refusal.attempts;
const capacityStatus = this.capacity >= this.getCapacityCost(errorInfo.errorType) ? 0 : refusal.capacity;
return retryableStatus || attemptStatus || capacityStatus;
}
getCapacityCost(errorType) {
return errorType === Retry.modifiedCostType() ? Retry.throttlingCost() : Retry.cost();
}
isRetryableError(errorType) {
return errorType === "THROTTLING" || errorType === "TRANSIENT";
}
};
var AdaptiveRetryStrategy$1 = class AdaptiveRetryStrategy {
mode = RETRY_MODES.ADAPTIVE;
rateLimiter;
standardRetryStrategy;
constructor(maxAttemptsProvider, options) {
const { rateLimiter } = options ?? {};
this.rateLimiter = rateLimiter ?? new DefaultRateLimiter;
this.standardRetryStrategy = options ? new StandardRetryStrategy$1({
maxAttempts: typeof maxAttemptsProvider === "number" ? maxAttemptsProvider : 3,
...options
}) : new StandardRetryStrategy$1(maxAttemptsProvider);
}
async acquireInitialRetryToken(retryTokenScope) {
const token = await this.standardRetryStrategy.acquireInitialRetryToken(retryTokenScope);
await this.rateLimiter.getSendToken();
return token;
}
async refreshRetryTokenForRetry(tokenToRenew, errorInfo) {
this.rateLimiter.updateClientSendingRate(errorInfo);
const token = await this.standardRetryStrategy.refreshRetryTokenForRetry(tokenToRenew, errorInfo);
await this.rateLimiter.getSendToken();
return token;
}
recordSuccess(token) {
this.rateLimiter.updateClientSendingRate({});
this.standardRetryStrategy.recordSuccess(token);
}
async maxAttemptsProvider() {
return this.standardRetryStrategy.maxAttempts();
}
};
class ConfiguredRetryStrategy extends StandardRetryStrategy$1 {
computeNextBackoffDelay;
constructor(maxAttempts, computeNextBackoffDelay = Retry.delay()) {
super(typeof maxAttempts === "function" ? maxAttempts : async () => maxAttempts);
if (typeof computeNextBackoffDelay === "number") {
this.computeNextBackoffDelay = () => computeNextBackoffDelay;
} else {
this.computeNextBackoffDelay = computeNextBackoffDelay;
}
this.retryBackoffStrategy.computeNextBackoffDelay = (completedAttempt) => {
const nextAttempt = completedAttempt + 1;
return this.computeNextBackoffDelay(nextAttempt);
};
}
}
var getDefaultRetryQuota = (initialRetryTokens, options) => {
const MAX_CAPACITY = initialRetryTokens;
const noRetryIncrement = NO_RETRY_INCREMENT;
const retryCost = RETRY_COST;
const timeoutRetryCost = TIMEOUT_RETRY_COST;
let availableCapacity = initialRetryTokens;
const getCapacityAmount = (error) => error.name === "TimeoutError" ? timeoutRetryCost : retryCost;
const hasRetryTokens = (error) => getCapacityAmount(error) <= availableCapacity;
const retrieveRetryTokens = (error) => {
if (!hasRetryTokens(error)) {
throw new Error("No retry token available");
}
const capacityAmount = getCapacityAmount(error);
availableCapacity -= capacityAmount;
return capacityAmount;
};
const releaseRetryTokens = (capacityReleaseAmount) => {
availableCapacity += capacityReleaseAmount ?? noRetryIncrement;
availableCapacity = Math.min(availableCapacity, MAX_CAPACITY);
};
return Object.freeze({
hasRetryTokens,
retrieveRetryTokens,
releaseRetryTokens
});
};
var defaultDelayDecider = (delayBase, attempts) => Math.floor(Math.min(MAXIMUM_RETRY_DELAY, Math.random() * 2 ** attempts * delayBase));
var defaultRetryDecider = (error) => {
if (!error) {
return false;
}
return isRetryableByTrait(error) || isClockSkewError(error) || isThrottlingError(error) || isTransientError(error);
};
class StandardRetryStrategy {
maxAttemptsProvider;
retryDecider;
delayDecider;
retryQuota;
mode = RETRY_MODES.STANDARD;
constructor(maxAttemptsProvider, options) {
this.maxAttemptsProvider = maxAttemptsProvider;
this.retryDecider = options?.retryDecider ?? defaultRetryDecider;
this.delayDecider = options?.delayDecider ?? defaultDelayDecider;
this.retryQuota = options?.retryQuota ?? getDefaultRetryQuota(INITIAL_RETRY_TOKENS);
}
shouldRetry(error, attempts, maxAttempts) {
return attempts < maxAttempts && this.retryDecider(error) && this.retryQuota.hasRetryTokens(error);
}
async getMaxAttempts() {
let maxAttempts;
try {
maxAttempts = await this.maxAttemptsProvider();
} catch (ignored) {
maxAttempts = DEFAULT_MAX_ATTEMPTS;
}
return maxAttempts;
}
async retry(next, args, options) {
let retryTokenAmount;
let attempts = 0;
let totalDelay = 0;
const maxAttempts = await this.getMaxAttempts();
const { request } = args;
if (HttpRequest.isInstance(request)) {
request.headers[INVOCATION_ID_HEADER] = v4();
}
while (true) {
try {
if (HttpRequest.isInstance(request)) {
request.headers[REQUEST_HEADER] = `attempt=${attempts + 1}; max=${maxAttempts}`;
}
if (options?.beforeRequest) {
await options.beforeRequest();
}
const { response, output } = await next(args);
if (options?.afterRequest) {
options.afterRequest(response);
}
this.retryQuota.releaseRetryTokens(retryTokenAmount);
output.$metadata.attempts = attempts + 1;
output.$metadata.totalRetryDelay = totalDelay;
return { response, output };
} catch (e) {
const err = asSdkError(e);
attempts++;
if (this.shouldRetry(err, attempts, maxAttempts)) {
retryTokenAmount = this.retryQuota.retrieveRetryTokens(err);
const delayFromDecider = this.delayDecider(isThrottlingError(err) ? THROTTLING_RETRY_DELAY_BASE : DEFAULT_RETRY_DELAY_BASE, attempts);
const delayFromResponse = getDelayFromRetryAfterHeader(err.$response);
const delay = Math.max(delayFromResponse || 0, delayFromDecider);
totalDelay += delay;
await new Promise((resolve) => setTimeout(resolve, delay));
continue;
}
if (!err.$metadata) {
err.$metadata = {};
}
err.$metadata.attempts = attempts;
err.$metadata.totalRetryDelay = totalDelay;
throw err;
}
}
}
}
var getDelayFromRetryAfterHeader = (response) => {
if (!HttpResponse.isInstance(response))
return;
const retryAfterHeaderName = Object.keys(response.headers).find((key) => key.toLowerCase() === "retry-after");
if (!retryAfterHeaderName)
return;
const retryAfter = response.headers[retryAfterHeaderName];
const retryAfterSeconds = Number(retryAfter);
if (!Number.isNaN(retryAfterSeconds))
return Math.min(retryAfterSeconds * 1000, 20000);
const retryAfterDate = new Date(retryAfter);
return Math.min(retryAfterDate.getTime() - Date.now(), 20000);
};
class AdaptiveRetryStrategy extends StandardRetryStrategy {
rateLimiter;
constructor(maxAttemptsProvider, options) {
const { rateLimiter, ...superOptions } = options ?? {};
super(maxAttemptsProvider, superOptions);
this.rateLimiter = rateLimiter ?? new DefaultRateLimiter;
this.mode = RETRY_MODES.ADAPTIVE;
}
async retry(next, args) {
return super.retry(next, args, {
beforeRequest: async () => {
return this.rateLimiter.getSendToken();
},
afterRequest: (response) => {
this.rateLimiter.updateClientSendingRate(response);
}
});
}
}
var ENV_MAX_ATTEMPTS = "AWS_MAX_ATTEMPTS";
var CONFIG_MAX_ATTEMPTS = "max_attempts";
var NODE_MAX_ATTEMPT_CONFIG_OPTIONS = {
environmentVariableSelector: (env) => {
const value = env[ENV_MAX_ATTEMPTS];
if (!value)
return;
const maxAttempt = parseInt(value);
if (Number.isNaN(maxAttempt)) {
throw new Error(`Environment variable ${ENV_MAX_ATTEMPTS} mast be a number, got "${value}"`);
}
return maxAttempt;
},
configFileSelector: (profile) => {
const value = profile[CONFIG_MAX_ATTEMPTS];
if (!value)
return;
const maxAttempt = parseInt(value);
if (Number.isNaN(maxAttempt)) {
throw new Error(`Shared config file entry ${CONFIG_MAX_ATTEMPTS} mast be a number, got "${value}"`);
}
return maxAttempt;
},
default: DEFAULT_MAX_ATTEMPTS
};
var resolveRetryConfig = (input, defaults) => {
const { retryStrategy, retryMode } = input;
const { defaultMaxAttempts = DEFAULT_MAX_ATTEMPTS, defaultBaseDelay = Retry.delay() } = defaults ?? {};
const maxAttemptsProvider = normalizeProvider(input.maxAttempts ?? defaultMaxAttempts);
let controller = retryStrategy ? Promise.resolve(retryStrategy) : undefined;
const getDefault = async () => {
const maxAttempts = await maxAttemptsProvider();
const adaptive = await normalizeProvider(retryMode)() === RETRY_MODES.ADAPTIVE;
if (adaptive) {
return new AdaptiveRetryStrategy$1(maxAttemptsProvider, {
maxAttempts,
baseDelay: defaultBaseDelay
});
}
return new StandardRetryStrategy$1({
maxAttempts,
baseDelay: defaultBaseDelay
});
};
return Object.assign(input, {
maxAttempts: maxAttemptsProvider,
retryStrategy: () => controller ??= getDefault()
});
};
var ENV_RETRY_MODE = "AWS_RETRY_MODE";
var CONFIG_RETRY_MODE = "retry_mode";
var NODE_RETRY_MODE_CONFIG_OPTIONS = {
environmentVariableSelector: (env) => env[ENV_RETRY_MODE],
configFileSelector: (profile) => profile[CONFIG_RETRY_MODE],
default: DEFAULT_RETRY_MODE
};
var omitRetryHeadersMiddleware = () => (next) => async (args) => {
const { request } = args;
if (HttpRequest.isInstance(request)) {
delete request.headers[INVOCATION_ID_HEADER];
delete request.headers[REQUEST_HEADER];
}
return next(args);
};
var omitRetryHeadersMiddlewareOptions = {
name: "omitRetryHeadersMiddleware",
tags: ["RETRY", "HEADERS", "OMIT_RETRY_HEADERS"],
relation: "before",
toMiddleware: "awsAuthMiddleware",
override: true
};
var getOmitRetryHeadersPlugin = (options) => ({
applyToStack: (clientStack) => {
clientStack.addRelativeTo(omitRetryHeadersMiddleware(), omitRetryHeadersMiddlewareOptions);
}
});
var retryMiddleware = bindRetryMiddleware(isStreamingPayload);
var getRetryPlugin = bindGetRetryPlugin(isStreamingPayload);
exports.AdaptiveRetryStrategy = AdaptiveRetryStrategy$1;
exports.CONFIG_MAX_ATTEMPTS = CONFIG_MAX_ATTEMPTS;
exports.CONFIG_RETRY_MODE = CONFIG_RETRY_MODE;
exports.ConfiguredRetryStrategy = ConfiguredRetryStrategy;
exports.DEFAULT_MAX_ATTEMPTS = DEFAULT_MAX_ATTEMPTS;
exports.DEFAULT_RETRY_DELAY_BASE = DEFAULT_RETRY_DELAY_BASE;
exports.DEFAULT_RETRY_MODE = DEFAULT_RETRY_MODE;
exports.DefaultRateLimiter = DefaultRateLimiter;
exports.DeprecatedAdaptiveRetryStrategy = AdaptiveRetryStrategy;
exports.DeprecatedStandardRetryStrategy = StandardRetryStrategy;
exports.ENV_MAX_ATTEMPTS = ENV_MAX_ATTEMPTS;
exports.ENV_RETRY_MODE = ENV_RETRY_MODE;
exports.INITIAL_RETRY_TOKENS = INITIAL_RETRY_TOKENS;
exports.INVOCATION_ID_HEADER = INVOCATION_ID_HEADER;
exports.MAXIMUM_RETRY_DELAY = MAXIMUM_RETRY_DELAY;
exports.NODE_MAX_ATTEMPT_CONFIG_OPTIONS = NODE_MAX_ATTEMPT_CONFIG_OPTIONS;
exports.NODE_RETRY_MODE_CONFIG_OPTIONS = NODE_RETRY_MODE_CONFIG_OPTIONS;
exports.NO_RETRY_INCREMENT = NO_RETRY_INCREMENT;
exports.REQUEST_HEADER = REQUEST_HEADER;
exports.RETRY_COST = RETRY_COST;
exports.RETRY_MODES = RETRY_MODES;
exports.Retry = Retry;
exports.StandardRetryStrategy = StandardRetryStrategy$1;
exports.THROTTLING_RETRY_DELAY_BASE = THROTTLING_RETRY_DELAY_BASE;
exports.TIMEOUT_RETRY_COST = TIMEOUT_RETRY_COST;
exports.defaultDelayDecider = defaultDelayDecider;
exports.defaultRetryDecider = defaultRetryDecider;
exports.getOmitRetryHeadersPlugin = getOmitRetryHeadersPlugin;
exports.getRetryAfterHint = getRetryAfterHint;
exports.getRetryPlugin = getRetryPlugin;
exports.isBrowserNetworkError = isBrowserNetworkError;
exports.isClockSkewCorrectedError = isClockSkewCorrectedError;
exports.isClockSkewError = isClockSkewError;
exports.isNodeJsHttp2TransientError = isNodeJsHttp2TransientError;
exports.isRetryableByTrait = isRetryableByTrait;
exports.isServerError = isServerError;
exports.isThrottlingError = isThrottlingError;
exports.isTransientError = isTransientError;
exports.omitRetryHeadersMiddleware = omitRetryHeadersMiddleware;
exports.omitRetryHeadersMiddlewareOptions = omitRetryHeadersMiddlewareOptions;
exports.resolveRetryConfig = resolveRetryConfig;
exports.retryMiddleware = retryMiddleware;
exports.retryMiddlewareOptions = retryMiddlewareOptions;
});
// ../../node_modules/.bun/@aws+lambda-invoke-store@0.3.0/node_modules/@aws/lambda-invoke-store/dist-cjs/invoke-store.js
var require_invoke_store = __commonJS(function(exports) {
var PROTECTED_KEYS = {
REQUEST_ID: Symbol.for("_AWS_LAMBDA_REQUEST_ID"),
X_RAY_TRACE_ID: Symbol.for("_AWS_LAMBDA_X_RAY_TRACE_ID"),
TENANT_ID: Symbol.for("_AWS_LAMBDA_TENANT_ID"),
TRACEPARENT: Symbol.for("_AWS_LAMBDA_TRACEPARENT"),
TRACESTATE: Symbol.for("_AWS_LAMBDA_TRACESTATE"),
BAGGAGE: Symbol.for("_AWS_LAMBDA_BAGGAGE")
};
var NO_GLOBAL_AWS_LAMBDA = ["true", "1"].includes(process.env?.AWS_LAMBDA_NODEJS_NO_GLOBAL_AWSLAMBDA ?? "");
if (!NO_GLOBAL_AWS_LAMBDA) {
globalThis.awslambda = globalThis.awslambda || {};
}
class InvokeStoreBase {
static PROTECTED_KEYS = PROTECTED_KEYS;
isProtectedKey(key) {
return Object.values(PROTECTED_KEYS).includes(key);
}
getRequestId() {
return this.get(PROTECTED_KEYS.REQUEST_ID) ?? "-";
}
getXRayTraceId() {
return this.get(PROTECTED_KEYS.X_RAY_TRACE_ID);
}
getTenantId() {
return this.get(PROTECTED_KEYS.TENANT_ID);
}
getTraceparent() {
return this.get(PROTECTED_KEYS.TRACEPARENT);
}
getTracestate() {
return this.get(PROTECTED_KEYS.TRACESTATE);
}
getBaggage() {
return this.get(PROTECTED_KEYS.BAGGAGE);
}
}
class InvokeStoreSingle extends InvokeStoreBase {
currentContext;
getContext() {
return this.currentContext;
}
hasContext() {
return this.currentContext !== undefined;
}
get(key) {
return this.currentContext?.[key];
}
set(key, value) {
if (this.isProtectedKey(key)) {
throw new Error(`Cannot modify protected Lambda context field: ${String(key)}`);
}
this.currentContext = this.currentContext || {};
this.currentContext[key] = value;
}
run(context, fn) {
this.currentContext = context;
return fn();
}
}
class InvokeStoreMulti extends InvokeStoreBase {
als;
static async create() {
const instance = new InvokeStoreMulti;
const asyncHooks = await import("async_hooks");
instance.als = new asyncHooks.AsyncLocalStorage;
return instance;
}
getContext() {
return this.als.getStore();
}
hasContext() {
return this.als.getStore() !== undefined;
}
get(key) {
return this.als.getStore()?.[key];
}
set(key, value) {
if (this.isProtectedKey(key)) {
throw new Error(`Cannot modify protected Lambda context field: ${String(key)}`);
}
const store = this.als.getStore();
if (!store) {
throw new Error("No context available");
}
store[key] = value;
}
run(context, fn) {
return this.als.run(context, fn);
}
}
exports.InvokeStore = undefined;
(function(InvokeStore) {
let instance = null;
async function getInstanceAsync(forceInvokeStoreMulti) {
if (!instance) {
instance = (async () => {
const isMulti = forceInvokeStoreMulti === true || "AWS_LAMBDA_MAX_CONCURRENCY" in process.env;
const newInstance = isMulti ? await InvokeStoreMulti.create() : new InvokeStoreSingle;
if (!NO_GLOBAL_AWS_LAMBDA && globalThis.awslambda?.InvokeStore) {
return globalThis.awslambda.InvokeStore;
} else if (!NO_GLOBAL_AWS_LAMBDA && globalThis.awslambda) {
globalThis.awslambda.InvokeStore = newInstance;
return newInstance;
} else {
return newInstance;
}
})();
}
return instance;
}
InvokeStore.getInstanceAsync = getInstanceAsync;
InvokeStore._testing = process.env.AWS_LAMBDA_BENCHMARK_MODE === "1" ? {
reset: () => {
instance = null;
if (globalThis.awslambda?.InvokeStore) {
delete globalThis.awslambda.InvokeStore;
}
globalThis.awslambda = { InvokeStore: undefined };
}
} : undefined;
})(exports.InvokeStore || (exports.InvokeStore = {}));
exports.InvokeStoreBase = InvokeStoreBase;
});
// ../../node_modules/.bun/@smithy+core@3.33.3/node_modules/@smithy/core/dist-cjs/index.js
var require_dist_cjs2 = __commonJS(function(exports) {
var { getSmithyContext, hasOwn } = require_transport();
exports.getSmithyContext = getSmithyContext;
var { HttpRequest } = require_protocols();
var { requestBuilder } = require_protocols();
exports.requestBuilder = requestBuilder;
var { HttpApiKeyAuthLocation } = require_dist_cjs();
var resolveAuthOptions = (candidateAuthOptions, authSchemePreference) => {
if (!authSchemePreference || authSchemePreference.length === 0) {
return candidateAuthOptions;
}
const preferredAuthOptions = [];
for (const preferredSchemeName of authSchemePreference) {
for (const candidateAuthOption of candidateAuthOptions) {
const candidateAuthSchemeName = candidateAuthOption.schemeId.split("#")[1];
if (candidateAuthSchemeName === preferredSchemeName) {
preferredAuthOptions.push(candidateAuthOption);
}
}
}
for (const candidateAuthOption of candidateAuthOptions) {
if (!preferredAuthOptions.find(({ schemeId }) => schemeId === candidateAuthOption.schemeId)) {
preferredAuthOptions.push(candidateAuthOption);
}
}
return preferredAuthOptions;
};
function convertHttpAuthSchemesToMap(httpAuthSchemes) {
const map = new Map;
for (const scheme of httpAuthSchemes) {
map.set(scheme.schemeId, scheme);
}
return map;
}
var httpAuthSchemeMiddleware = (config, mwOptions) => (next, context) => async (args) => {
const options = config.httpAuthSchemeProvider(await mwOptions.httpAuthSchemeParametersProvider(config, context, args.input));
const authSchemePreference = config.authSchemePreference ? await config.authSchemePreference() : [];
const resolvedOptions = resolveAuthOptions(options, authSchemePreference);
const authSchemes = convertHttpAuthSchemesToMap(config.httpAuthSchemes);
const smithyContext = getSmithyContext(context);
const failureReasons = [];
for (const option of resolvedOptions) {
const scheme = authSchemes.get(option.schemeId);
if (!scheme) {
failureReasons.push(`HttpAuthScheme \`${option.schemeId}\` was not enabled for this service.`);
continue;
}
const identityProvider = scheme.identityProvider(await mwOptions.identityProviderConfigProvider(config));
if (!identityProvider) {
failureReasons.push(`HttpAuthScheme \`${option.schemeId}\` did not have an IdentityProvider configured.`);
continue;
}
const { identityProperties = {}, signingProperties = {} } = option.propertiesExtractor?.(config, context) || {};
option.identityProperties = Object.assign(option.identityProperties || {}, identityProperties);
option.signingProperties = Object.assign(option.signingProperties || {}, signingProperties);
smithyContext.selectedHttpAuthScheme = {
httpAuthOption: option,
identity: await identityProvider(option.identityProperties),
signer: scheme.signer
};
break;
}
if (!smithyContext.selectedHttpAuthScheme) {
throw new Error(failureReasons.join(`
`));
}
return next(args);
};
var httpAuthSchemeEndpointRuleSetMiddlewareOptions = {
step: "serialize",
tags: ["HTTP_AUTH_SCHEME"],
name: "httpAuthSchemeMiddleware",
override: true,
relation: "before",
toMiddleware: "endpointV2Middleware"
};
var getHttpAuthSchemeEndpointRuleSetPlugin = (config, { httpAuthSchemeParametersProvider, identityProviderConfigProvider }) => ({
applyToStack: (clientStack) => {
clientStack.addRelativeTo(httpAuthSchemeMiddleware(config, {
httpAuthSchemeParametersProvider,
identityProviderConfigProvider
}), httpAuthSchemeEndpointRuleSetMiddlewareOptions);
}
});
var httpAuthSchemeMiddlewareOptions = {
step: "serialize",
tags: ["HTTP_AUTH_SCHEME"],
name: "httpAuthSchemeMiddleware",
override: true,
relation: "before",
toMiddleware: "serializerMiddleware"
};
var getHttpAuthSchemePlugin = (config, { httpAuthSchemeParametersProvider, identityProviderConfigProvider }) => ({
applyToStack: (clientStack) => {
clientStack.addRelativeTo(httpAuthSchemeMiddleware(config, {
httpAuthSchemeParametersProvider,
identityProviderConfigProvider
}), httpAuthSchemeMiddlewareOptions);
}
});
var defaultErrorHandler = (signingProperties) => (error) => {
throw error;
};
var defaultSuccessHandler = (httpResponse, signingProperties) => {};
var httpSigningMiddleware = (config) => (next, context) => async (args) => {
if (!HttpRequest.isInstance(args.request)) {
return next(args);
}
const smithyContext = getSmithyContext(context);
const scheme = smithyContext.selectedHttpAuthScheme;
if (!scheme) {
throw new Error(`No HttpAuthScheme was selected: unable to sign request`);
}
const { httpAuthOption: { signingProperties = {} }, identity, signer } = scheme;
const output = await next({
...args,
request: await signer.sign(args.request, identity, signingProperties)
}).catch((signer.errorHandler || defaultErrorHandler)(signingProperties));
(signer.successHandler || defaultSuccessHandler)(output.response, signingProperties);
return output;
};
var httpSigningMiddlewareOptions = {
step: "finalizeRequest",
tags: ["HTTP_SIGNING"],
name: "httpSigningMiddleware",
aliases: ["apiKeyMiddleware", "tokenMiddleware", "awsAuthMiddleware"],
override: true,
relation: "after",
toMiddleware: "retryMiddleware"
};
var getHttpSigningPlugin = (config) => ({
applyToStack: (clientStack) => {
clientStack.addRelativeTo(httpSigningMiddleware(), httpSigningMiddlewareOptions);
}
});
var normalizeProvider = (input) => {
if (typeof input === "function")
return input;
const promisified = Promise.resolve(input);
return () => promisified;
};
var makePagedClientRequest = async (CommandCtor, client, input, withCommand = (_) => _, ...args) => {
let command = new CommandCtor(input);
command = withCommand(command) ?? command;
return await client.send(command, ...args);
};
function createPaginator(ClientCtor, CommandCtor, inputTokenName, outputTokenName, pageSizeTokenName) {
return async function* paginateOperation(config, input, ...additionalArguments) {
const _input = input;
let token = config.startingToken ?? _input[inputTokenName];
let hasNext = true;
let page;
while (hasNext) {
_input[inputTokenName] = token;
if (pageSizeTokenName) {
_input[pageSizeTokenName] = _input[pageSizeTokenName] ?? config.pageSize;
}
if (config.client instanceof ClientCtor) {
page = await makePagedClientRequest(CommandCtor, config.client, input, config.withCommand, ...additionalArguments);
} else {
throw new Error(`Invalid client, expected instance of ${ClientCtor.name}`);
}
yield page;
const prevToken = token;
token = get(page, outputTokenName);
hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
}
return;
};
}
var get = (fromObject, path) => {
let cursor = fromObject;
const pathComponents = path.split(".");
for (const step of pathComponents) {
if (!cursor || typeof cursor !== "object") {
return;
}
cursor = cursor[step];
}
return cursor;
};
function setFeature(context, feature, value) {
if (!context.__smithy_context) {
context.__smithy_context = {
features: {}
};
} else if (!context.__smithy_context.features) {
context.__smithy_context.features = {};
}
context.__smithy_context.features[feature] = value;
}
class DefaultIdentityProviderConfig {
authSchemes = new Map;
constructor(config) {
for (const key in config) {
if (!hasOwn(config, key))
continue;
const value = config[key];
if (value !== undefined) {
this.authSchemes.set(key, value);
}
}
}
getIdentityProvider(schemeId) {
return this.authSchemes.get(schemeId);
}
}
class HttpApiKeyAuthSigner {
async sign(httpRequest, identity, signingProperties) {
if (!signingProperties) {
throw new Error("request could not be signed with `apiKey` since the `name` and `in` signer properties are missing");
}
if (!signingProperties.name) {
throw new Error("request could not be signed with `apiKey` since the `name` signer property is missing");
}
if (!signingProperties.in) {
throw new Error("request could not be signed with `apiKey` since the `in` signer property is missing");
}
if (!identity.apiKey) {
throw new Error("request could not be signed with `apiKey` since the `apiKey` is not defined");
}
const clonedRequest = HttpRequest.clone(httpRequest);
if (signingProperties.in === HttpApiKeyAuthLocation.QUERY) {
clonedRequest.query[signingProperties.name] = identity.apiKey;
} else if (signingProperties.in === HttpApiKeyAuthLocation.HEADER) {
clonedRequest.headers[signingProperties.name] = signingProperties.scheme ? `${signingProperties.scheme} ${identity.apiKey}` : identity.apiKey;
} else {
throw new Error("request can only be signed with `apiKey` locations `query` or `header`, " + "but found: `" + signingProperties.in + "`");
}
return clonedRequest;
}
}
class HttpBearerAuthSigner {
async sign(httpRequest, identity, signingProperties) {
const clonedRequest = HttpRequest.clone(httpRequest);
if (!identity.token) {
throw new Error("request could not be signed with `token` since the `token` is not defined");
}
clonedRequest.headers["Authorization"] = `Bearer ${identity.token}`;
return clonedRequest;
}
}
class NoAuthSigner {
async sign(httpRequest, identity, signingProperties) {
return httpRequest;
}
}
var createIsIdentityExpiredFunction = (expirationMs) => function isIdentityExpired(identity) {
return doesIdentityRequireRefresh(identity) && identity.expiration.getTime() - Date.now() < expirationMs;
};
var EXPIRATION_MS = 300000;
var isIdentityExpired = createIsIdentityExpiredFunction(EXPIRATION_MS);
var doesIdentityRequireRefresh = (identity) => identity.expiration !== undefined;
var memoizeIdentityProvider = (provider, isExpired, requiresRefresh) => {
if (provider === undefined) {
return;
}
const normalizedProvider = typeof provider !== "function" ? async () => Promise.resolve(provider) : provider;
let resolved;
let pending;
let hasResult;
let isConstant = false;
const coalesceProvider = async (options) => {
if (!pending) {
pending = normalizedProvider(options);
}
try {
resolved = await pending;
hasResult = true;
isConstant = false;
} finally {
pending = undefined;
}
return resolved;
};
if (isExpired === undefined) {
return async (options) => {
if (!hasResult || options?.forceRefresh) {
resolved = await coalesceProvider(options);
}
return resolved;
};
}
return async (options) => {
if (!hasResult || options?.forceRefresh) {
resolved = await coalesceProvider(options);
}
if (isConstant) {
return resolved;
}
if (!requiresRefresh(resolved)) {
isConstant = true;
return resolved;
}
if (isExpired(resolved)) {
await coalesceProvider(options);
return resolved;
}
return resolved;
};
};
exports.DefaultIdentityProviderConfig = DefaultIdentityProviderConfig;
exports.EXPIRATION_MS = EXPIRATION_MS;
exports.HttpApiKeyAuthSigner = HttpApiKeyAuthSigner;
exports.HttpBearerAuthSigner = HttpBearerAuthSigner;
exports.NoAuthSigner = NoAuthSigner;
exports.createIsIdentityExpiredFunction = createIsIdentityExpiredFunction;
exports.createPaginator = createPaginator;
exports.doesIdentityRequireRefresh = doesIdentityRequireRefresh;
exports.getHttpAuthSchemeEndpointRuleSetPlugin = getHttpAuthSchemeEndpointRuleSetPlugin;
exports.getHttpAuthSchemePlugin = getHttpAuthSchemePlugin;
exports.getHttpSigningPlugin = getHttpSigningPlugin;
exports.httpAuthSchemeEndpointRuleSetMiddlewareOptions = httpAuthSchemeEndpointRuleSetMiddlewareOptions;
exports.httpAuthSchemeMiddleware = httpAuthSchemeMiddleware;
exports.httpAuthSchemeMiddlewareOptions = httpAuthSchemeMiddlewareOptions;
exports.httpSigningMiddleware = httpSigningMiddleware;
exports.httpSigningMiddlewareOptions = httpSigningMiddlewareOptions;
exports.isIdentityExpired = isIdentityExpired;
exports.memoizeIdentityProvider = memoizeIdentityProvider;
exports.normalizeProvider = normalizeProvider;
exports.setFeature = setFeature;
});
// ../../node_modules/.bun/bowser@2.14.1/node_modules/bowser/es5.js
var require_es5 = __commonJS(function(exports, module) {
(function(e, t) {
typeof exports == "object" && typeof module == "object" ? module.exports = t() : typeof define == "function" && define.amd ? define([], t) : typeof exports == "object" ? exports.bowser = t() : e.bowser = t();
})(exports, function() {
return function(e) {
var t = {};
function r(i) {
if (t[i])
return t[i].exports;
var n = t[i] = { i, l: false, exports: {} };
return e[i].call(n.exports, n, n.exports, r), n.l = true, n.exports;
}
return r.m = e, r.c = t, r.d = function(e, t, i) {
r.o(e, t) || Object.defineProperty(e, t, { enumerable: true, get: i });
}, r.r = function(e) {
typeof Symbol != "undefined" && Symbol.toStringTag && Object.defineProperty(e, Symbol.toStringTag, { value: "Module" }), Object.defineProperty(e, "__esModule", { value: true });
}, r.t = function(e, t) {
if (1 & t && (e = r(e)), 8 & t)
return e;
if (4 & t && typeof e == "object" && e && e.__esModule)
return e;
var i = Object.create(null);
if (r.r(i), Object.defineProperty(i, "default", { enumerable: true, value: e }), 2 & t && typeof e != "string")
for (var n in e)
r.d(i, n, function(t) {
return e[t];
}.bind(null, n));
return i;
}, r.n = function(e) {
var t = e && e.__esModule ? function() {
return e.default;
} : function() {
return e;
};
return r.d(t, "a", t), t;
}, r.o = function(e, t) {
return Object.prototype.hasOwnProperty.call(e, t);
}, r.p = "", r(r.s = 90);
}({ 17: function(e, t, r) {
t.__esModule = true, t.default = undefined;
var i = r(18), n = function() {
function e() {}
return e.getFirstMatch = function(e, t) {
var r = t.match(e);
return r && r.length > 0 && r[1] || "";
}, e.getSecondMatch = function(e, t) {
var r = t.match(e);
return r && r.length > 1 && r[2] || "";
}, e.matchAndReturnConst = function(e, t, r) {
if (e.test(t))
return r;
}, e.getWindowsVersionName = function(e) {
switch (e) {
case "NT":
return "NT";
case "XP":
return "XP";
case "NT 5.0":
return "2000";
case "NT 5.1":
return "XP";
case "NT 5.2":
return "2003";
case "NT 6.0":
return "Vista";
case "NT 6.1":
return "7";
case "NT 6.2":
return "8";
case "NT 6.3":
return "8.1";
case "NT 10.0":
return "10";
default:
return;
}
}, e.getMacOSVersionName = function(e) {
var t = e.split(".").splice(0, 2).map(function(e) {
return parseInt(e, 10) || 0;
});
t.push(0);
var r = t[0], i = t[1];
if (r === 10)
switch (i) {
case 5:
return "Leopard";
case 6:
return "Snow Leopard";
case 7:
return "Lion";
case 8:
return "Mountain Lion";
case 9:
return "Mavericks";
case 10:
return "Yosemite";
case 11:
return "El Capitan";
case 12:
return "Sierra";
case 13:
return "High Sierra";
case 14:
return "Mojave";
case 15:
return "Catalina";
default:
return;
}
switch (r) {
case 11:
return "Big Sur";
case 12:
return "Monterey";
case 13:
return "Ventura";
case 14:
return "Sonoma";
case 15:
return "Sequoia";
default:
return;
}
}, e.getAndroidVersionName = function(e) {
var t = e.split(".").splice(0, 2).map(function(e) {
return parseInt(e, 10) || 0;
});
if (t.push(0), !(t[0] === 1 && t[1] < 5))
return t[0] === 1 && t[1] < 6 ? "Cupcake" : t[0] === 1 && t[1] >= 6 ? "Donut" : t[0] === 2 && t[1] < 2 ? "Eclair" : t[0] === 2 && t[1] === 2 ? "Froyo" : t[0] === 2 && t[1] > 2 ? "Gingerbread" : t[0] === 3 ? "Honeycomb" : t[0] === 4 && t[1] < 1 ? "Ice Cream Sandwich" : t[0] === 4 && t[1] < 4 ? "Jelly Bean" : t[0] === 4 && t[1] >= 4 ? "KitKat" : t[0] === 5 ? "Lollipop" : t[0] === 6 ? "Marshmallow" : t[0] === 7 ? "Nougat" : t[0] === 8 ? "Oreo" : t[0] === 9 ? "Pie" : undefined;
}, e.getVersionPrecision = function(e) {
return e.split(".").length;
}, e.compareVersions = function(t, r, i) {
i === undefined && (i = false);
var n = e.getVersionPrecision(t), a = e.getVersionPrecision(r), o = Math.max(n, a), s = 0, u = e.map([t, r], function(t) {
var r = o - e.getVersionPrecision(t), i = t + new Array(r + 1).join(".0");
return e.map(i.split("."), function(e) {
return new Array(20 - e.length).join("0") + e;
}).reverse();
});
for (i && (s = o - Math.min(n, a)), o -= 1;o >= s; ) {
if (u[0][o] > u[1][o])
return 1;
if (u[0][o] === u[1][o]) {
if (o === s)
return 0;
o -= 1;
} else if (u[0][o] < u[1][o])
return -1;
}
}, e.map = function(e, t) {
var r, i = [];
if (Array.prototype.map)
return Array.prototype.map.call(e, t);
for (r = 0;r < e.length; r += 1)
i.push(t(e[r]));
return i;
}, e.find = function(e, t) {
var r, i;
if (Array.prototype.find)
return Array.prototype.find.call(e, t);
for (r = 0, i = e.length;r < i; r += 1) {
var n = e[r];
if (t(n, r))
return n;
}
}, e.assign = function(e) {
for (var t, r, i = e, n = arguments.length, a = new Array(n > 1 ? n - 1 : 0), o = 1;o < n; o++)
a[o - 1] = arguments[o];
if (Object.assign)
return Object.assign.apply(Object, [e].concat(a));
var s = function() {
var e = a[t];
typeof e == "object" && e !== null && Object.keys(e).forEach(function(t) {
i[t] = e[t];
});
};
for (t = 0, r = a.length;t < r; t += 1)
s();
return e;
}, e.getBrowserAlias = function(e) {
return i.BROWSER_ALIASES_MAP[e];
}, e.getBrowserTypeByAlias = function(e) {
return i.BROWSER_MAP[e] || "";
}, e;
}();
t.default = n, e.exports = t.default;
}, 18: function(e, t, r) {
t.__esModule = true, t.ENGINE_MAP = t.OS_MAP = t.PLATFORMS_MAP = t.BROWSER_MAP = t.BROWSER_ALIASES_MAP = undefined;
t.BROWSER_ALIASES_MAP = { AmazonBot: "amazonbot", "Amazon Silk": "amazon_silk", "Android Browser": "android", BaiduSpider: "baiduspider", Bada: "bada", BingCrawler: "bingcrawler", Brave: "brave", BlackBerry: "blackberry", "ChatGPT-User": "chatgpt_user", Chrome: "chrome", ClaudeBot: "claudebot", Chromium: "chromium", Diffbot: "diffbot", DuckDuckBot: "duckduckbot", DuckDuckGo: "duckduckgo", Electron: "electron", Epiphany: "epiphany", FacebookExternalHit: "facebookexternalhit", Firefox: "firefox", Focus: "focus", Generic: "generic", "Google Search": "google_search", Googlebot: "googlebot", GPTBot: "gptbot", "Internet Explorer": "ie", InternetArchiveCrawler: "internetarchivecrawler", "K-Meleon": "k_meleon", LibreWolf: "librewolf", Linespider: "linespider", Maxthon: "maxthon", "Meta-ExternalAds": "meta_externalads", "Meta-ExternalAgent": "meta_externalagent", "Meta-ExternalFetcher": "meta_externalfetcher", "Meta-WebIndexer": "meta_webindexer", "Microsoft Edge": "edge", "MZ Browser": "mz", "NAVER Whale Browser": "naver", "OAI-SearchBot": "oai_searchbot", Omgilibot: "omgilibot", Opera: "opera", "Opera Coast": "opera_coast", "Pale Moon": "pale_moon", PerplexityBot: "perplexitybot", "Perplexity-User": "perplexity_user", PhantomJS: "phantomjs", PingdomBot: "pingdombot", Puffin: "puffin", QQ: "qq", QQLite: "qqlite", QupZilla: "qupzilla", Roku: "roku", Safari: "safari", Sailfish: "sailfish", "Samsung Internet for Android": "samsung_internet", SlackBot: "slackbot", SeaMonkey: "seamonkey", Sleipnir: "sleipnir", "Sogou Browser": "sogou", Swing: "swing", Tizen: "tizen", "UC Browser": "uc", Vivaldi: "vivaldi", "WebOS Browser": "webos", WeChat: "wechat", YahooSlurp: "yahooslurp", "Yandex Browser": "yandex", YandexBot: "yandexbot", YouBot: "youbot" };
t.BROWSER_MAP = { amazonbot: "AmazonBot", amazon_silk: "Amazon Silk", android: "Android Browser", baiduspider: "BaiduSpider", bada: "Bada", bingcrawler: "BingCrawler", blackberry: "BlackBerry", brave: "Brave", chatgpt_user: "ChatGPT-User", chrome: "Chrome", claudebot: "ClaudeBot", chromium: "Chromium", diffbot: "Diffbot", duckduckbot: "DuckDuckBot", duckduckgo: "DuckDuckGo", edge: "Microsoft Edge", electron: "Electron", epiphany: "Epiphany", facebookexternalhit: "FacebookExternalHit", firefox: "Firefox", focus: "Focus", generic: "Generic", google_search: "Google Search", googlebot: "Googlebot", gptbot: "GPTBot", ie: "Internet Explorer", internetarchivecrawler: "InternetArchiveCrawler", k_meleon: "K-Meleon", librewolf: "LibreWolf", linespider: "Linespider", maxthon: "Maxthon", meta_externalads: "Meta-ExternalAds", meta_externalagent: "Meta-ExternalAgent", meta_externalfetcher: "Meta-ExternalFetcher", meta_webindexer: "Meta-WebIndexer", mz: "MZ Browser", naver: "NAVER Whale Browser", oai_searchbot: "OAI-SearchBot", omgilibot: "Omgilibot", opera: "Opera", opera_coast: "Opera Coast", pale_moon: "Pale Moon", perplexitybot: "PerplexityBot", perplexity_user: "Perplexity-User", phantomjs: "PhantomJS", pingdombot: "PingdomBot", puffin: "Puffin", qq: "QQ Browser", qqlite: "QQ Browser Lite", qupzilla: "QupZilla", roku: "Roku", safari: "Safari", sailfish: "Sailfish", samsung_internet: "Samsung Internet for Android", seamonkey: "SeaMonkey", slackbot: "SlackBot", sleipnir: "Sleipnir", sogou: "Sogou Browser", swing: "Swing", tizen: "Tizen", uc: "UC Browser", vivaldi: "Vivaldi", webos: "WebOS Browser", wechat: "WeChat", yahooslurp: "YahooSlurp", yandex: "Yandex Browser", yandexbot: "YandexBot", youbot: "YouBot" };
t.PLATFORMS_MAP = { bot: "bot", desktop: "desktop", mobile: "mobile", tablet: "tablet", tv: "tv" };
t.OS_MAP = { Android: "Android", Bada: "Bada", BlackBerry: "BlackBerry", ChromeOS: "Chrome OS", HarmonyOS: "HarmonyOS", iOS: "iOS", Linux: "Linux", MacOS: "macOS", PlayStation4: "PlayStation 4", Roku: "Roku", Tizen: "Tizen", WebOS: "WebOS", Windows: "Windows", WindowsPhone: "Windows Phone" };
t.ENGINE_MAP = { Blink: "Blink", EdgeHTML: "EdgeHTML", Gecko: "Gecko", Presto: "Presto", Trident: "Trident", WebKit: "WebKit" };
}, 90: function(e, t, r) {
t.__esModule = true, t.default = undefined;
var i, n = (i = r(91)) && i.__esModule ? i : { default: i }, a = r(18);
function o(e, t) {
for (var r = 0;r < t.length; r++) {
var i = t[r];
i.enumerable = i.enumerable || false, i.configurable = true, "value" in i && (i.writable = true), Object.defineProperty(e, i.key, i);
}
}
var s = function() {
function e() {}
var t, r, i;
return e.getParser = function(e, t, r) {
if (t === undefined && (t = false), r === undefined && (r = null), typeof e != "string")
throw new Error("UserAgent should be a string");
return new n.default(e, t, r);
}, e.parse = function(e, t) {
return t === undefined && (t = null), new n.default(e, t).getResult();
}, t = e, i = [{ key: "BROWSER_MAP", get: function() {
return a.BROWSER_MAP;
} }, { key: "ENGINE_MAP", get: function() {
return a.ENGINE_MAP;
} }, { key: "OS_MAP", get: function() {
return a.OS_MAP;
} }, { key: "PLATFORMS_MAP", get: function() {
return a.PLATFORMS_MAP;
} }], (r = null) && o(t.prototype, r), i && o(t, i), e;
}();
t.default = s, e.exports = t.default;
}, 91: function(e, t, r) {
t.__esModule = true, t.default = undefined;
var i = u(r(92)), n = u(r(93)), a = u(r(94)), o = u(r(95)), s = u(r(17));
function u(e) {
return e && e.__esModule ? e : { default: e };
}
var d = function() {
function e(e, t, r) {
if (t === undefined && (t = false), r === undefined && (r = null), e == null || e === "")
throw new Error("UserAgent parameter can't be empty");
this._ua = e;
var i = false;
typeof t == "boolean" ? (i = t, this._hints = r) : this._hints = t != null && typeof t == "object" ? t : null, this.parsedResult = {}, i !== true && this.parse();
}
var t = e.prototype;
return t.getHints = function() {
return this._hints;
}, t.hasBrand = function(e) {
if (!this._hints || !Array.isArray(this._hints.brands))
return false;
var t = e.toLowerCase();
return this._hints.brands.some(function(e) {
return e.brand && e.brand.toLowerCase() === t;
});
}, t.getBrandVersion = function(e) {
if (this._hints && Array.isArray(this._hints.brands)) {
var t = e.toLowerCase(), r = this._hints.brands.find(function(e) {
return e.brand && e.brand.toLowerCase() === t;
});
return r ? r.version : undefined;
}
}, t.getUA = function() {
return this._ua;
}, t.test = function(e) {
return e.test(this._ua);
}, t.parseBrowser = function() {
var e = this;
this.parsedResult.browser = {};
var t = s.default.find(i.default, function(t) {
if (typeof t.test == "function")
return t.test(e);
if (Array.isArray(t.test))
return t.test.some(function(t) {
return e.test(t);
});
throw new Error("Browser's test function is not valid");
});
return t && (this.parsedResult.browser = t.describe(this.getUA(), this)), this.parsedResult.browser;
}, t.getBrowser = function() {
return this.parsedResult.browser ? this.parsedResult.browser : this.parseBrowser();
}, t.getBrowserName = function(e) {
return e ? String(this.getBrowser().name).toLowerCase() || "" : this.getBrowser().name || "";
}, t.getBrowserVersion = function() {
return this.getBrowser().version;
}, t.getOS = function() {
return this.parsedResult.os ? this.parsedResult.os : this.parseOS();
}, t.parseOS = function() {
var e = this;
this.parsedResult.os = {};
var t = s.default.find(n.default, function(t) {
if (typeof t.test == "function")
return t.test(e);
if (Array.isArray(t.test))
return t.test.some(function(t) {
return e.test(t);
});
throw new Error("Browser's test function is not valid");
});
return t && (this.parsedResult.os = t.describe(this.getUA())), this.parsedResult.os;
}, t.getOSName = function(e) {
var t = this.getOS().name;
return e ? String(t).toLowerCase() || "" : t || "";
}, t.getOSVersion = function() {
return this.getOS().version;
}, t.getPlatform = function() {
return this.parsedResult.platform ? this.parsedResult.platform : this.parsePlatform();
}, t.getPlatformType = function(e) {
e === undefined && (e = false);
var t = this.getPlatform().type;
return e ? String(t).toLowerCase() || "" : t || "";
}, t.parsePlatform = function() {
var e = this;
this.parsedResult.platform = {};
var t = s.default.find(a.default, function(t) {
if (typeof t.test == "function")
return t.test(e);
if (Array.isArray(t.test))
return t.test.some(function(t) {
return e.test(t);
});
throw new Error("Browser's test function is not valid");
});
return t && (this.parsedResult.platform = t.describe(this.getUA())), this.parsedResult.platform;
}, t.getEngine = function() {
return this.parsedResult.engine ? this.parsedResult.engine : this.parseEngine();
}, t.getEngineName = function(e) {
return e ? String(this.getEngine().name).toLowerCase() || "" : this.getEngine().name || "";
}, t.parseEngine = function() {
var e = this;
this.parsedResult.engine = {};
var t = s.default.find(o.default, function(t) {
if (typeof t.test == "function")
return t.test(e);
if (Array.isArray(t.test))
return t.test.some(function(t) {
return e.test(t);
});
throw new Error("Browser's test function is not valid");
});
return t && (this.parsedResult.engine = t.describe(this.getUA())), this.parsedResult.engine;
}, t.parse = function() {
return this.parseBrowser(), this.parseOS(), this.parsePlatform(), this.parseEngine(), this;
}, t.getResult = function() {
return s.default.assign({}, this.parsedResult);
}, t.satisfies = function(e) {
var t = this, r = {}, i = 0, n = {}, a = 0;
if (Object.keys(e).forEach(function(t) {
var o = e[t];
typeof o == "string" ? (n[t] = o, a += 1) : typeof o == "object" && (r[t] = o, i += 1);
}), i > 0) {
var o = Object.keys(r), u = s.default.find(o, function(e) {
return t.isOS(e);
});
if (u) {
var d = this.satisfies(r[u]);
if (d !== undefined)
return d;
}
var c = s.default.find(o, function(e) {
return t.isPlatform(e);
});
if (c) {
var f = this.satisfies(r[c]);
if (f !== undefined)
return f;
}
}
if (a > 0) {
var l = Object.keys(n), b = s.default.find(l, function(e) {
return t.isBrowser(e, true);
});
if (b !== undefined)
return this.compareVersion(n[b]);
}
}, t.isBrowser = function(e, t) {
t === undefined && (t = false);
var r = this.getBrowserName().toLowerCase(), i = e.toLowerCase(), n = s.default.getBrowserTypeByAlias(i);
return t && n && (i = n.toLowerCase()), i === r;
}, t.compareVersion = function(e) {
var t = [0], r = e, i = false, n = this.getBrowserVersion();
if (typeof n == "string")
return e[0] === ">" || e[0] === "<" ? (r = e.substr(1), e[1] === "=" ? (i = true, r = e.substr(2)) : t = [], e[0] === ">" ? t.push(1) : t.push(-1)) : e[0] === "=" ? r = e.substr(1) : e[0] === "~" && (i = true, r = e.substr(1)), t.indexOf(s.default.compareVersions(n, r, i)) > -1;
}, t.isOS = function(e) {
return this.getOSName(true) === String(e).toLowerCase();
}, t.isPlatform = function(e) {
return this.getPlatformType(true) === String(e).toLowerCase();
}, t.isEngine = function(e) {
return this.getEngineName(true) === String(e).toLowerCase();
}, t.is = function(e, t) {
return t === undefined && (t = false), this.isBrowser(e, t) || this.isOS(e) || this.isPlatform(e);
}, t.some = function(e) {
var t = this;
return e === undefined && (e = []), e.some(function(e) {
return t.is(e);
});
}, e;
}();
t.default = d, e.exports = t.default;
}, 92: function(e, t, r) {
t.__esModule = true, t.default = undefined;
var i, n = (i = r(17)) && i.__esModule ? i : { default: i };
var a = /version\/(\d+(\.?_?\d+)+)/i, o = [{ test: [/gptbot/i], describe: function(e) {
var t = { name: "GPTBot" }, r = n.default.getFirstMatch(/gptbot\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/chatgpt-user/i], describe: function(e) {
var t = { name: "ChatGPT-User" }, r = n.default.getFirstMatch(/chatgpt-user\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/oai-searchbot/i], describe: function(e) {
var t = { name: "OAI-SearchBot" }, r = n.default.getFirstMatch(/oai-searchbot\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/claudebot/i, /claude-web/i, /claude-user/i, /claude-searchbot/i], describe: function(e) {
var t = { name: "ClaudeBot" }, r = n.default.getFirstMatch(/(?:claudebot|claude-web|claude-user|claude-searchbot)\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/omgilibot/i, /webzio-extended/i], describe: function(e) {
var t = { name: "Omgilibot" }, r = n.default.getFirstMatch(/(?:omgilibot|webzio-extended)\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/diffbot/i], describe: function(e) {
var t = { name: "Diffbot" }, r = n.default.getFirstMatch(/diffbot\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/perplexitybot/i], describe: function(e) {
var t = { name: "PerplexityBot" }, r = n.default.getFirstMatch(/perplexitybot\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/perplexity-user/i], describe: function(e) {
var t = { name: "Perplexity-User" }, r = n.default.getFirstMatch(/perplexity-user\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/youbot/i], describe: function(e) {
var t = { name: "YouBot" }, r = n.default.getFirstMatch(/youbot\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/meta-webindexer/i], describe: function(e) {
var t = { name: "Meta-WebIndexer" }, r = n.default.getFirstMatch(/meta-webindexer\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/meta-externalads/i], describe: function(e) {
var t = { name: "Meta-ExternalAds" }, r = n.default.getFirstMatch(/meta-externalads\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/meta-externalagent/i], describe: function(e) {
var t = { name: "Meta-ExternalAgent" }, r = n.default.getFirstMatch(/meta-externalagent\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/meta-externalfetcher/i], describe: function(e) {
var t = { name: "Meta-ExternalFetcher" }, r = n.default.getFirstMatch(/meta-externalfetcher\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/googlebot/i], describe: function(e) {
var t = { name: "Googlebot" }, r = n.default.getFirstMatch(/googlebot\/(\d+(\.\d+))/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/linespider/i], describe: function(e) {
var t = { name: "Linespider" }, r = n.default.getFirstMatch(/(?:linespider)(?:-[-\w]+)?[\s/](\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/amazonbot/i], describe: function(e) {
var t = { name: "AmazonBot" }, r = n.default.getFirstMatch(/amazonbot\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/bingbot/i], describe: function(e) {
var t = { name: "BingCrawler" }, r = n.default.getFirstMatch(/bingbot\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/baiduspider/i], describe: function(e) {
var t = { name: "BaiduSpider" }, r = n.default.getFirstMatch(/baiduspider\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/duckduckbot/i], describe: function(e) {
var t = { name: "DuckDuckBot" }, r = n.default.getFirstMatch(/duckduckbot\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/ia_archiver/i], describe: function(e) {
var t = { name: "InternetArchiveCrawler" }, r = n.default.getFirstMatch(/ia_archiver\/(\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/facebookexternalhit/i, /facebookcatalog/i], describe: function() {
return { name: "FacebookExternalHit" };
} }, { test: [/slackbot/i, /slack-imgProxy/i], describe: function(e) {
var t = { name: "SlackBot" }, r = n.default.getFirstMatch(/(?:slackbot|slack-imgproxy)(?:-[-\w]+)?[\s/](\d+(\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/yahoo!?[\s/]*slurp/i], describe: function() {
return { name: "YahooSlurp" };
} }, { test: [/yandexbot/i, /yandexmobilebot/i], describe: function() {
return { name: "YandexBot" };
} }, { test: [/pingdom/i], describe: function() {
return { name: "PingdomBot" };
} }, { test: [/opera/i], describe: function(e) {
var t = { name: "Opera" }, r = n.default.getFirstMatch(a, e) || n.default.getFirstMatch(/(?:opera)[\s/](\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/opr\/|opios/i], describe: function(e) {
var t = { name: "Opera" }, r = n.default.getFirstMatch(/(?:opr|opios)[\s/](\S+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/SamsungBrowser/i], describe: function(e) {
var t = { name: "Samsung Internet for Android" }, r = n.default.getFirstMatch(a, e) || n.default.getFirstMatch(/(?:SamsungBrowser)[\s/](\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/Whale/i], describe: function(e) {
var t = { name: "NAVER Whale Browser" }, r = n.default.getFirstMatch(a, e) || n.default.getFirstMatch(/(?:whale)[\s/](\d+(?:\.\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/PaleMoon/i], describe: function(e) {
var t = { name: "Pale Moon" }, r = n.default.getFirstMatch(a, e) || n.default.getFirstMatch(/(?:PaleMoon)[\s/](\d+(?:\.\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/MZBrowser/i], describe: function(e) {
var t = { name: "MZ Browser" }, r = n.default.getFirstMatch(/(?:MZBrowser)[\s/](\d+(?:\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/focus/i], describe: function(e) {
var t = { name: "Focus" }, r = n.default.getFirstMatch(/(?:focus)[\s/](\d+(?:\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/swing/i], describe: function(e) {
var t = { name: "Swing" }, r = n.default.getFirstMatch(/(?:swing)[\s/](\d+(?:\.\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/coast/i], describe: function(e) {
var t = { name: "Opera Coast" }, r = n.default.getFirstMatch(a, e) || n.default.getFirstMatch(/(?:coast)[\s/](\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/opt\/\d+(?:.?_?\d+)+/i], describe: function(e) {
var t = { name: "Opera Touch" }, r = n.default.getFirstMatch(/(?:opt)[\s/](\d+(\.?_?\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/yabrowser/i], describe: function(e) {
var t = { name: "Yandex Browser" }, r = n.default.getFirstMatch(/(?:yabrowser)[\s/](\d+(\.?_?\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/ucbrowser/i], describe: function(e) {
var t = { name: "UC Browser" }, r = n.default.getFirstMatch(a, e) || n.default.getFirstMatch(/(?:ucbrowser)[\s/](\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/Maxthon|mxios/i], describe: function(e) {
var t = { name: "Maxthon" }, r = n.default.getFirstMatch(a, e) || n.default.getFirstMatch(/(?:Maxthon|mxios)[\s/](\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/epiphany/i], describe: function(e) {
var t = { name: "Epiphany" }, r = n.default.getFirstMatch(a, e) || n.default.getFirstMatch(/(?:epiphany)[\s/](\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/puffin/i], describe: function(e) {
var t = { name: "Puffin" }, r = n.default.getFirstMatch(a, e) || n.default.getFirstMatch(/(?:puffin)[\s/](\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/sleipnir/i], describe: function(e) {
var t = { name: "Sleipnir" }, r = n.default.getFirstMatch(a, e) || n.default.getFirstMatch(/(?:sleipnir)[\s/](\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/k-meleon/i], describe: function(e) {
var t = { name: "K-Meleon" }, r = n.default.getFirstMatch(a, e) || n.default.getFirstMatch(/(?:k-meleon)[\s/](\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/micromessenger/i], describe: function(e) {
var t = { name: "WeChat" }, r = n.default.getFirstMatch(/(?:micromessenger)[\s/](\d+(\.?_?\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/qqbrowser/i], describe: function(e) {
var t = { name: /qqbrowserlite/i.test(e) ? "QQ Browser Lite" : "QQ Browser" }, r = n.default.getFirstMatch(/(?:qqbrowserlite|qqbrowser)[/](\d+(\.?_?\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/msie|trident/i], describe: function(e) {
var t = { name: "Internet Explorer" }, r = n.default.getFirstMatch(/(?:msie |rv:)(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/\sedg\//i], describe: function(e) {
var t = { name: "Microsoft Edge" }, r = n.default.getFirstMatch(/\sedg\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/edg([ea]|ios)/i], describe: function(e) {
var t = { name: "Microsoft Edge" }, r = n.default.getSecondMatch(/edg([ea]|ios)\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/vivaldi/i], describe: function(e) {
var t = { name: "Vivaldi" }, r = n.default.getFirstMatch(/vivaldi\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/seamonkey/i], describe: function(e) {
var t = { name: "SeaMonkey" }, r = n.default.getFirstMatch(/seamonkey\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/sailfish/i], describe: function(e) {
var t = { name: "Sailfish" }, r = n.default.getFirstMatch(/sailfish\s?browser\/(\d+(\.\d+)?)/i, e);
return r && (t.version = r), t;
} }, { test: [/silk/i], describe: function(e) {
var t = { name: "Amazon Silk" }, r = n.default.getFirstMatch(/silk\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/phantom/i], describe: function(e) {
var t = { name: "PhantomJS" }, r = n.default.getFirstMatch(/phantomjs\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/slimerjs/i], describe: function(e) {
var t = { name: "SlimerJS" }, r = n.default.getFirstMatch(/slimerjs\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/blackberry|\bbb\d+/i, /rim\stablet/i], describe: function(e) {
var t = { name: "BlackBerry" }, r = n.default.getFirstMatch(a, e) || n.default.getFirstMatch(/blackberry[\d]+\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/(web|hpw)[o0]s/i], describe: function(e) {
var t = { name: "WebOS Browser" }, r = n.default.getFirstMatch(a, e) || n.default.getFirstMatch(/w(?:eb)?[o0]sbrowser\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/bada/i], describe: function(e) {
var t = { name: "Bada" }, r = n.default.getFirstMatch(/dolfin\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/tizen/i], describe: function(e) {
var t = { name: "Tizen" }, r = n.default.getFirstMatch(/(?:tizen\s?)?browser\/(\d+(\.?_?\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/qupzilla/i], describe: function(e) {
var t = { name: "QupZilla" }, r = n.default.getFirstMatch(/(?:qupzilla)[\s/](\d+(\.?_?\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/librewolf/i], describe: function(e) {
var t = { name: "LibreWolf" }, r = n.default.getFirstMatch(/(?:librewolf)[\s/](\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/firefox|iceweasel|fxios/i], describe: function(e) {
var t = { name: "Firefox" }, r = n.default.getFirstMatch(/(?:firefox|iceweasel|fxios)[\s/](\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/electron/i], describe: function(e) {
var t = { name: "Electron" }, r = n.default.getFirstMatch(/(?:electron)\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/sogoumobilebrowser/i, /metasr/i, /se 2\.[x]/i], describe: function(e) {
var t = { name: "Sogou Browser" }, r = n.default.getFirstMatch(/(?:sogoumobilebrowser)[\s/](\d+(\.?_?\d+)+)/i, e), i = n.default.getFirstMatch(/(?:chrome|crios|crmo)\/(\d+(\.?_?\d+)+)/i, e), a = n.default.getFirstMatch(/se ([\d.]+)x/i, e), o = r || i || a;
return o && (t.version = o), t;
} }, { test: [/MiuiBrowser/i], describe: function(e) {
var t = { name: "Miui" }, r = n.default.getFirstMatch(/(?:MiuiBrowser)[\s/](\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: function(e) {
return !!e.hasBrand("DuckDuckGo") || e.test(/\sDdg\/[\d.]+$/i);
}, describe: function(e, t) {
var r = { name: "DuckDuckGo" };
if (t) {
var i = t.getBrandVersion("DuckDuckGo");
if (i)
return r.version = i, r;
}
var a = n.default.getFirstMatch(/\sDdg\/([\d.]+)$/i, e);
return a && (r.version = a), r;
} }, { test: function(e) {
return e.hasBrand("Brave");
}, describe: function(e, t) {
var r = { name: "Brave" };
if (t) {
var i = t.getBrandVersion("Brave");
if (i)
return r.version = i, r;
}
return r;
} }, { test: [/chromium/i], describe: function(e) {
var t = { name: "Chromium" }, r = n.default.getFirstMatch(/(?:chromium)[\s/](\d+(\.?_?\d+)+)/i, e) || n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/chrome|crios|crmo/i], describe: function(e) {
var t = { name: "Chrome" }, r = n.default.getFirstMatch(/(?:chrome|crios|crmo)\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/GSA/i], describe: function(e) {
var t = { name: "Google Search" }, r = n.default.getFirstMatch(/(?:GSA)\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: function(e) {
var t = !e.test(/like android/i), r = e.test(/android/i);
return t && r;
}, describe: function(e) {
var t = { name: "Android Browser" }, r = n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/playstation 4/i], describe: function(e) {
var t = { name: "PlayStation 4" }, r = n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/safari|applewebkit/i], describe: function(e) {
var t = { name: "Safari" }, r = n.default.getFirstMatch(a, e);
return r && (t.version = r), t;
} }, { test: [/.*/i], describe: function(e) {
var t = e.search("\\(") !== -1 ? /^(.*)\/(.*)[ \t]\((.*)/ : /^(.*)\/(.*) /;
return { name: n.default.getFirstMatch(t, e), version: n.default.getSecondMatch(t, e) };
} }];
t.default = o, e.exports = t.default;
}, 93: function(e, t, r) {
t.__esModule = true, t.default = undefined;
var i, n = (i = r(17)) && i.__esModule ? i : { default: i }, a = r(18);
var o = [{ test: [/Roku\/DVP/], describe: function(e) {
var t = n.default.getFirstMatch(/Roku\/DVP-(\d+\.\d+)/i, e);
return { name: a.OS_MAP.Roku, version: t };
} }, { test: [/windows phone/i], describe: function(e) {
var t = n.default.getFirstMatch(/windows phone (?:os)?\s?(\d+(\.\d+)*)/i, e);
return { name: a.OS_MAP.WindowsPhone, version: t };
} }, { test: [/windows /i], describe: function(e) {
var t = n.default.getFirstMatch(/Windows ((NT|XP)( \d\d?.\d)?)/i, e), r = n.default.getWindowsVersionName(t);
return { name: a.OS_MAP.Windows, version: t, versionName: r };
} }, { test: [/Macintosh(.*?) FxiOS(.*?)\//], describe: function(e) {
var t = { name: a.OS_MAP.iOS }, r = n.default.getSecondMatch(/(Version\/)(\d[\d.]+)/, e);
return r && (t.version = r), t;
} }, { test: [/macintosh/i], describe: function(e) {
var t = n.default.getFirstMatch(/mac os x (\d+(\.?_?\d+)+)/i, e).replace(/[_\s]/g, "."), r = n.default.getMacOSVersionName(t), i = { name: a.OS_MAP.MacOS, version: t };
return r && (i.versionName = r), i;
} }, { test: [/(ipod|iphone|ipad)/i], describe: function(e) {
var t = n.default.getFirstMatch(/os (\d+([_\s]\d+)*) like mac os x/i, e).replace(/[_\s]/g, ".");
return { name: a.OS_MAP.iOS, version: t };
} }, { test: [/OpenHarmony/i], describe: function(e) {
var t = n.default.getFirstMatch(/OpenHarmony\s+(\d+(\.\d+)*)/i, e);
return { name: a.OS_MAP.HarmonyOS, version: t };
} }, { test: function(e) {
var t = !e.test(/like android/i), r = e.test(/android/i);
return t && r;
}, describe: function(e) {
var t = n.default.getFirstMatch(/android[\s/-](\d+(\.\d+)*)/i, e), r = n.default.getAndroidVersionName(t), i = { name: a.OS_MAP.Android, version: t };
return r && (i.versionName = r), i;
} }, { test: [/(web|hpw)[o0]s/i], describe: function(e) {
var t = n.default.getFirstMatch(/(?:web|hpw)[o0]s\/(\d+(\.\d+)*)/i, e), r = { name: a.OS_MAP.WebOS };
return t && t.length && (r.version = t), r;
} }, { test: [/blackberry|\bbb\d+/i, /rim\stablet/i], describe: function(e) {
var t = n.default.getFirstMatch(/rim\stablet\sos\s(\d+(\.\d+)*)/i, e) || n.default.getFirstMatch(/blackberry\d+\/(\d+([_\s]\d+)*)/i, e) || n.default.getFirstMatch(/\bbb(\d+)/i, e);
return { name: a.OS_MAP.BlackBerry, version: t };
} }, { test: [/bada/i], describe: function(e) {
var t = n.default.getFirstMatch(/bada\/(\d+(\.\d+)*)/i, e);
return { name: a.OS_MAP.Bada, version: t };
} }, { test: [/tizen/i], describe: function(e) {
var t = n.default.getFirstMatch(/tizen[/\s](\d+(\.\d+)*)/i, e);
return { name: a.OS_MAP.Tizen, version: t };
} }, { test: [/linux/i], describe: function() {
return { name: a.OS_MAP.Linux };
} }, { test: [/CrOS/], describe: function() {
return { name: a.OS_MAP.ChromeOS };
} }, { test: [/PlayStation 4/], describe: function(e) {
var t = n.default.getFirstMatch(/PlayStation 4[/\s](\d+(\.\d+)*)/i, e);
return { name: a.OS_MAP.PlayStation4, version: t };
} }];
t.default = o, e.exports = t.default;
}, 94: function(e, t, r) {
t.__esModule = true, t.default = undefined;
var i, n = (i = r(17)) && i.__esModule ? i : { default: i }, a = r(18);
var o = [{ test: [/googlebot/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Google" };
} }, { test: [/linespider/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Line" };
} }, { test: [/amazonbot/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Amazon" };
} }, { test: [/gptbot/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "OpenAI" };
} }, { test: [/chatgpt-user/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "OpenAI" };
} }, { test: [/oai-searchbot/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "OpenAI" };
} }, { test: [/baiduspider/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Baidu" };
} }, { test: [/bingbot/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Bing" };
} }, { test: [/duckduckbot/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "DuckDuckGo" };
} }, { test: [/claudebot/i, /claude-web/i, /claude-user/i, /claude-searchbot/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Anthropic" };
} }, { test: [/omgilibot/i, /webzio-extended/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Webz.io" };
} }, { test: [/diffbot/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Diffbot" };
} }, { test: [/perplexitybot/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Perplexity AI" };
} }, { test: [/perplexity-user/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Perplexity AI" };
} }, { test: [/youbot/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "You.com" };
} }, { test: [/ia_archiver/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Internet Archive" };
} }, { test: [/meta-webindexer/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Meta" };
} }, { test: [/meta-externalads/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Meta" };
} }, { test: [/meta-externalagent/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Meta" };
} }, { test: [/meta-externalfetcher/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Meta" };
} }, { test: [/facebookexternalhit/i, /facebookcatalog/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Meta" };
} }, { test: [/slackbot/i, /slack-imgProxy/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Slack" };
} }, { test: [/yahoo/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Yahoo" };
} }, { test: [/yandexbot/i, /yandexmobilebot/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Yandex" };
} }, { test: [/pingdom/i], describe: function() {
return { type: a.PLATFORMS_MAP.bot, vendor: "Pingdom" };
} }, { test: [/huawei/i], describe: function(e) {
var t = n.default.getFirstMatch(/(can-l01)/i, e) && "Nova", r = { type: a.PLATFORMS_MAP.mobile, vendor: "Huawei" };
return t && (r.model = t), r;
} }, { test: [/nexus\s*(?:7|8|9|10).*/i], describe: function() {
return { type: a.PLATFORMS_MAP.tablet, vendor: "Nexus" };
} }, { test: [/ipad/i], describe: function() {
return { type: a.PLATFORMS_MAP.tablet, vendor: "Apple", model: "iPad" };
} }, { test: [/Macintosh(.*?) FxiOS(.*?)\//], describe: function() {
return { type: a.PLATFORMS_MAP.tablet, vendor: "Apple", model: "iPad" };
} }, { test: [/kftt build/i], describe: function() {
return { type: a.PLATFORMS_MAP.tablet, vendor: "Amazon", model: "Kindle Fire HD 7" };
} }, { test: [/silk/i], describe: function() {
return { type: a.PLATFORMS_MAP.tablet, vendor: "Amazon" };
} }, { test: [/tablet(?! pc)/i], describe: function() {
return { type: a.PLATFORMS_MAP.tablet };
} }, { test: function(e) {
var t = e.test(/ipod|iphone/i), r = e.test(/like (ipod|iphone)/i);
return t && !r;
}, describe: function(e) {
var t = n.default.getFirstMatch(/(ipod|iphone)/i, e);
return { type: a.PLATFORMS_MAP.mobile, vendor: "Apple", model: t };
} }, { test: [/nexus\s*[0-6].*/i, /galaxy nexus/i], describe: function() {
return { type: a.PLATFORMS_MAP.mobile, vendor: "Nexus" };
} }, { test: [/Nokia/i], describe: function(e) {
var t = n.default.getFirstMatch(/Nokia\s+([0-9]+(\.[0-9]+)?)/i, e), r = { type: a.PLATFORMS_MAP.mobile, vendor: "Nokia" };
return t && (r.model = t), r;
} }, { test: [/[^-]mobi/i], describe: function() {
return { type: a.PLATFORMS_MAP.mobile };
} }, { test: function(e) {
return e.getBrowserName(true) === "blackberry";
}, describe: function() {
return { type: a.PLATFORMS_MAP.mobile, vendor: "BlackBerry" };
} }, { test: function(e) {
return e.getBrowserName(true) === "bada";
}, describe: function() {
return { type: a.PLATFORMS_MAP.mobile };
} }, { test: function(e) {
return e.getBrowserName() === "windows phone";
}, describe: function() {
return { type: a.PLATFORMS_MAP.mobile, vendor: "Microsoft" };
} }, { test: function(e) {
var t = Number(String(e.getOSVersion()).split(".")[0]);
return e.getOSName(true) === "android" && t >= 3;
}, describe: function() {
return { type: a.PLATFORMS_MAP.tablet };
} }, { test: function(e) {
return e.getOSName(true) === "android";
}, describe: function() {
return { type: a.PLATFORMS_MAP.mobile };
} }, { test: [/smart-?tv|smarttv/i], describe: function() {
return { type: a.PLATFORMS_MAP.tv };
} }, { test: [/netcast/i], describe: function() {
return { type: a.PLATFORMS_MAP.tv };
} }, { test: function(e) {
return e.getOSName(true) === "macos";
}, describe: function() {
return { type: a.PLATFORMS_MAP.desktop, vendor: "Apple" };
} }, { test: function(e) {
return e.getOSName(true) === "windows";
}, describe: function() {
return { type: a.PLATFORMS_MAP.desktop };
} }, { test: function(e) {
return e.getOSName(true) === "linux";
}, describe: function() {
return { type: a.PLATFORMS_MAP.desktop };
} }, { test: function(e) {
return e.getOSName(true) === "playstation 4";
}, describe: function() {
return { type: a.PLATFORMS_MAP.tv };
} }, { test: function(e) {
return e.getOSName(true) === "roku";
}, describe: function() {
return { type: a.PLATFORMS_MAP.tv };
} }];
t.default = o, e.exports = t.default;
}, 95: function(e, t, r) {
t.__esModule = true, t.default = undefined;
var i, n = (i = r(17)) && i.__esModule ? i : { default: i }, a = r(18);
var o = [{ test: function(e) {
return e.getBrowserName(true) === "microsoft edge";
}, describe: function(e) {
if (/\sedg\//i.test(e))
return { name: a.ENGINE_MAP.Blink };
var t = n.default.getFirstMatch(/edge\/(\d+(\.?_?\d+)+)/i, e);
return { name: a.ENGINE_MAP.EdgeHTML, version: t };
} }, { test: [/trident/i], describe: function(e) {
var t = { name: a.ENGINE_MAP.Trident }, r = n.default.getFirstMatch(/trident\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: function(e) {
return e.test(/presto/i);
}, describe: function(e) {
var t = { name: a.ENGINE_MAP.Presto }, r = n.default.getFirstMatch(/presto\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: function(e) {
var t = e.test(/gecko/i), r = e.test(/like gecko/i);
return t && !r;
}, describe: function(e) {
var t = { name: a.ENGINE_MAP.Gecko }, r = n.default.getFirstMatch(/gecko\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }, { test: [/(apple)?webkit\/537\.36/i], describe: function() {
return { name: a.ENGINE_MAP.Blink };
} }, { test: [/(apple)?webkit/i], describe: function(e) {
var t = { name: a.ENGINE_MAP.WebKit }, r = n.default.getFirstMatch(/webkit\/(\d+(\.?_?\d+)+)/i, e);
return r && (t.version = r), t;
} }];
t.default = o, e.exports = t.default;
} });
});
});
// ../../node_modules/.bun/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-cjs/submodules/client/index.js
var require_client2 = __commonJS(function(exports) {
var { Retry, RETRY_MODES } = require_retry();
var { HttpRequest, parseUrl } = require_protocols();
var { InvokeStore } = require_invoke_store();
var { normalizeProvider } = require_dist_cjs2();
var { platform, release } = __require("os");
var { versions, env } = __require("process");
var { isValidHostLabel, isIpAddress, customEndpointFunctions } = require_endpoints();
var { EndpointError, resolveEndpoint } = require_endpoints();
exports.EndpointError = EndpointError;
exports.isIpAddress = isIpAddress;
exports.resolveEndpoint = resolveEndpoint;
var { loadConfig, NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS } = require_config();
var { REGION_ENV_NAME, REGION_INI_NAME, resolveRegionConfig } = require_config();
exports.NODE_REGION_CONFIG_FILE_OPTIONS = NODE_REGION_CONFIG_FILE_OPTIONS;
exports.NODE_REGION_CONFIG_OPTIONS = NODE_REGION_CONFIG_OPTIONS;
exports.REGION_ENV_NAME = REGION_ENV_NAME;
exports.REGION_INI_NAME = REGION_INI_NAME;
exports.resolveRegionConfig = resolveRegionConfig;
var state = {
warningEmitted: false
};
var emitWarningIfUnsupportedVersion = (version) => {
if (version && !state.warningEmitted) {
if (process.env.AWS_SDK_JS_NODE_VERSION_SUPPORT_WARNING_DISABLED === "true") {
state.warningEmitted = true;
return;
}
const userMajorVersion = parseInt(version.substring(1, version.indexOf(".")));
const vv = 22;
if (userMajorVersion < vv) {
state.warningEmitted = true;
process.emitWarning(`NodeVersionSupportWarning: The AWS SDK for JavaScript (v3)
versions published after the first week of January 2027
will require node >=${vv}. You are running node ${version}.
To continue receiving updates to AWS services, bug fixes,
and security updates please upgrade to node >=${vv}.
More information can be found at: https://a.co/c895JFp`);
}
}
};
var longPollMiddleware = () => (next, context) => async (args) => {
context.__retryLongPoll = true;
return next(args);
};
var longPollMiddlewareOptions = {
name: "longPollMiddleware",
tags: ["RETRY"],
step: "initialize",
override: true
};
var getLongPollPlugin = (options) => ({
applyToStack: (clientStack) => {
clientStack.add(longPollMiddleware(), longPollMiddlewareOptions);
}
});
function setCredentialFeature(credentials, feature, value) {
if (!credentials.$source) {
credentials.$source = {};
}
credentials.$source[feature] = value;
return credentials;
}
Retry.v2026 ||= typeof process === "object" && process.env?.AWS_NEW_RETRIES_2026 === "true";
function setFeature(context, feature, value) {
if (!context.__aws_sdk_context) {
context.__aws_sdk_context = {
features: {}
};
} else if (!context.__aws_sdk_context.features) {
context.__aws_sdk_context.features = {};
}
context.__aws_sdk_context.features[feature] = value;
}
function setTokenFeature(token, feature, value) {
if (!token.$source) {
token.$source = {};
}
token.$source[feature] = value;
return token;
}
function resolveHostHeaderConfig(input) {
return input;
}
var hostHeaderMiddleware = (options) => (next) => async (args) => {
if (!HttpRequest.isInstance(args.request))
return next(args);
const { request } = args;
const { handlerProtocol = "" } = options.requestHandler.metadata || {};
if (handlerProtocol.indexOf("h2") >= 0 && !request.headers[":authority"]) {
delete request.headers["host"];
request.headers[":authority"] = request.hostname + (request.port ? ":" + request.port : "");
} else if (!request.headers["host"]) {
let host = request.hostname;
if (request.port != null)
host += `:${request.port}`;
request.headers["host"] = host;
}
return next(args);
};
var hostHeaderMiddlewareOptions = {
name: "hostHeaderMiddleware",
step: "build",
priority: "low",
tags: ["HOST"],
override: true
};
var getHostHeaderPlugin = (options) => ({
applyToStack: (clientStack) => {
clientStack.add(hostHeaderMiddleware(options), hostHeaderMiddlewareOptions);
}
});
var loggerMiddleware = () => (next, context) => async (args) => {
try {
const response = await next(args);
const { clientName, commandName, logger, dynamoDbDocumentClientOptions = {} } = context;
const { overrideInputFilterSensitiveLog, overrideOutputFilterSensitiveLog } = dynamoDbDocumentClientOptions;
const inputFilterSensitiveLog = overrideInputFilterSensitiveLog ?? context.inputFilterSensitiveLog;
const outputFilterSensitiveLog = overrideOutputFilterSensitiveLog ?? context.outputFilterSensitiveLog;
const { $metadata, ...outputWithoutMetadata } = response.output;
logger?.info?.({
clientName,
commandName,
input: inputFilterSensitiveLog(args.input),
output: outputFilterSensitiveLog(outputWithoutMetadata),
metadata: $metadata
});
return response;
} catch (error) {
const { clientName, commandName, logger, dynamoDbDocumentClientOptions = {} } = context;
const { overrideInputFilterSensitiveLog } = dynamoDbDocumentClientOptions;
const inputFilterSensitiveLog = overrideInputFilterSensitiveLog ?? context.inputFilterSensitiveLog;
logger?.error?.({
clientName,
commandName,
input: inputFilterSensitiveLog(args.input),
error,
metadata: error.$metadata
});
throw error;
}
};
var loggerMiddlewareOptions = {
name: "loggerMiddleware",
tags: ["LOGGER"],
step: "initialize",
override: true
};
var getLoggerPlugin = (options) => ({
applyToStack: (clientStack) => {
clientStack.add(loggerMiddleware(), loggerMiddlewareOptions);
}
});
var recursionDetectionMiddlewareOptions = {
step: "build",
tags: ["RECURSION_DETECTION", "TRACE_CONTEXT_PROPAGATION"],
name: "recursionDetectionMiddleware",
override: true,
priority: "low"
};
var AWS_LAMBDA_FUNCTION_NAME = "AWS_LAMBDA_FUNCTION_NAME";
var _X_AMZN_TRACE_ID = "_X_AMZN_TRACE_ID";
var X_AMZN_TRACE_ID = "X-Amzn-Trace-Id";
var TRACEPARENT = "traceparent";
var TRACESTATE = "tracestate";
var BAGGAGE = "baggage";
var recursionDetectionMiddleware = () => (next) => async (args) => {
const { request } = args;
if (!HttpRequest.isInstance(request)) {
return next(args);
}
let invokeStore;
{
const traceIdHeader = Object.keys(request.headers ?? {}).find((h) => h.toLowerCase() === X_AMZN_TRACE_ID.toLowerCase()) ?? X_AMZN_TRACE_ID;
if (!request.headers.hasOwnProperty(traceIdHeader)) {
const functionName = process.env[AWS_LAMBDA_FUNCTION_NAME];
const traceIdFromEnv = process.env[_X_AMZN_TRACE_ID];
invokeStore ??= await InvokeStore.getInstanceAsync();
const traceIdFromInvokeStore = invokeStore?.getXRayTraceId();
const traceId = traceIdFromInvokeStore ?? traceIdFromEnv;
const nonEmptyString = (str) => typeof str === "string" && str.length > 0;
if (nonEmptyString(functionName) && nonEmptyString(traceId)) {
request.headers[X_AMZN_TRACE_ID] = traceId;
}
}
}
{
sanitizeTraceHeaders(request.headers);
const existingTraceparent = request.headers[TRACEPARENT];
if (!existingTraceparent) {
const traceparent = (invokeStore ??= await InvokeStore.getInstanceAsync())?.getTraceparent?.();
if (traceparent) {
request.headers[TRACEPARENT] = traceparent;
const tracestate = invokeStore?.getTracestate?.();
if (tracestate) {
request.headers[TRACESTATE] = tracestate;
}
const baggage = invokeStore?.getBaggage?.();
if (baggage) {
request.headers[BAGGAGE] = baggage;
}
}
}
}
return next(args);
};
function sanitizeTraceHeaders(headers) {
for (const header of Object.keys(headers)) {
const lower = header.toLowerCase();
if (header !== lower && (lower === TRACEPARENT || lower === TRACESTATE || lower === BAGGAGE)) {
headers[lower] = headers[header];
delete headers[header];
}
}
}
var getRecursionDetectionPlugin = (options) => ({
applyToStack: (clientStack) => {
clientStack.add(recursionDetectionMiddleware(), recursionDetectionMiddlewareOptions);
}
});
var DEFAULT_UA_APP_ID = undefined;
function isValidUserAgentAppId(appId) {
if (appId === undefined) {
return true;
}
return typeof appId === "string" && appId.length <= 50;
}
function resolveUserAgentConfig(input) {
const normalizedAppIdProvider = normalizeProvider(input.userAgentAppId ?? DEFAULT_UA_APP_ID);
const { customUserAgent } = input;
return Object.assign(input, {
customUserAgent: typeof customUserAgent === "string" ? [[customUserAgent]] : customUserAgent,
userAgentAppId: async () => {
const appId = await normalizedAppIdProvider();
if (!isValidUserAgentAppId(appId)) {
const logger = input.logger?.constructor?.name === "NoOpLogger" || !input.logger ? console : input.logger;
if (typeof appId !== "string") {
logger?.warn("userAgentAppId must be a string or undefined.");
} else if (appId.length > 50) {
logger?.warn("The provided userAgentAppId exceeds the maximum length of 50 characters.");
}
}
return appId;
}
});
}
var partitionsInfo = {
partitions: [
{
id: "aws",
outputs: {
dnsSuffix: "amazonaws.com",
dualStackDnsSuffix: "api.aws",
implicitGlobalRegion: "us-east-1",
name: "aws",
supportsDualStack: true,
supportsFIPS: true
},
regionRegex: "^(us|eu|ap|sa|ca|me|af|il|mx)\\-\\w+\\-\\d+$",
regions: {
"af-south-1": {
description: "Africa (Cape Town)"
},
"ap-east-1": {
description: "Asia Pacific (Hong Kong)"
},
"ap-east-2": {
description: "Asia Pacific (Taipei)"
},
"ap-northeast-1": {
description: "Asia Pacific (Tokyo)"
},
"ap-northeast-2": {
description: "Asia Pacific (Seoul)"
},
"ap-northeast-3": {
description: "Asia Pacific (Osaka)"
},
"ap-south-1": {
description: "Asia Pacific (Mumbai)"
},
"ap-south-2": {
description: "Asia Pacific (Hyderabad)"
},
"ap-southeast-1": {
description: "Asia Pacific (Singapore)"
},
"ap-southeast-2": {
description: "Asia Pacific (Sydney)"
},
"ap-southeast-3": {
description: "Asia Pacific (Jakarta)"
},
"ap-southeast-4": {
description: "Asia Pacific (Melbourne)"
},
"ap-southeast-5": {
description: "Asia Pacific (Malaysia)"
},
"ap-southeast-6": {
description: "Asia Pacific (New Zealand)"
},
"ap-southeast-7": {
description: "Asia Pacific (Thailand)"
},
"aws-global": {
description: "aws global region"
},
"ca-central-1": {
description: "Canada (Central)"
},
"ca-west-1": {
description: "Canada West (Calgary)"
},
"eu-central-1": {
description: "Europe (Frankfurt)"
},
"eu-central-2": {
description: "Europe (Zurich)"
},
"eu-north-1": {
description: "Europe (Stockholm)"
},
"eu-south-1": {
description: "Europe (Milan)"
},
"eu-south-2": {
description: "Europe (Spain)"
},
"eu-west-1": {
description: "Europe (Ireland)"
},
"eu-west-2": {
description: "Europe (London)"
},
"eu-west-3": {
description: "Europe (Paris)"
},
"il-central-1": {
description: "Israel (Tel Aviv)"
},
"me-central-1": {
description: "Middle East (UAE)"
},
"me-south-1": {
description: "Middle East (Bahrain)"
},
"mx-central-1": {
description: "Mexico (Central)"
},
"sa-east-1": {
description: "South America (Sao Paulo)"
},
"us-east-1": {
description: "US East (N. Virginia)"
},
"us-east-2": {
description: "US East (Ohio)"
},
"us-west-1": {
description: "US West (N. California)"
},
"us-west-2": {
description: "US West (Oregon)"
}
}
},
{
id: "aws-cn",
outputs: {
dnsSuffix: "amazonaws.com.cn",
dualStackDnsSuffix: "api.amazonwebservices.com.cn",
implicitGlobalRegion: "cn-northwest-1",
name: "aws-cn",
supportsDualStack: true,
supportsFIPS: true
},
regionRegex: "^cn\\-\\w+\\-\\d+$",
regions: {
"aws-cn-global": {
description: "aws-cn global region"
},
"cn-north-1": {
description: "China (Beijing)"
},
"cn-northwest-1": {
description: "China (Ningxia)"
}
}
},
{
id: "aws-eusc",
outputs: {
dnsSuffix: "amazonaws.eu",
dualStackDnsSuffix: "api.amazonwebservices.eu",
implicitGlobalRegion: "eusc-de-east-1",
name: "aws-eusc",
supportsDualStack: true,
supportsFIPS: true
},
regionRegex: "^eusc\\-(de)\\-\\w+\\-\\d+$",
regions: {
"eusc-de-east-1": {
description: "AWS European Sovereign Cloud (Germany)"
}
}
},
{
id: "aws-iso",
outputs: {
dnsSuffix: "c2s.ic.gov",
dualStackDnsSuffix: "api.aws.ic.gov",
implicitGlobalRegion: "us-iso-east-1",
name: "aws-iso",
supportsDualStack: true,
supportsFIPS: true
},
regionRegex: "^us\\-iso\\-\\w+\\-\\d+$",
regions: {
"aws-iso-global": {
description: "aws-iso global region"
},
"us-iso-east-1": {
description: "US ISO East"
},
"us-iso-west-1": {
description: "US ISO WEST"
}
}
},
{
id: "aws-iso-b",
outputs: {
dnsSuffix: "sc2s.sgov.gov",
dualStackDnsSuffix: "api.aws.scloud",
implicitGlobalRegion: "us-isob-east-1",
name: "aws-iso-b",
supportsDualStack: true,
supportsFIPS: true
},
regionRegex: "^us\\-isob\\-\\w+\\-\\d+$",
regions: {
"aws-iso-b-global": {
description: "aws-iso-b global region"
},
"us-isob-east-1": {
description: "US ISOB East (Ohio)"
},
"us-isob-west-1": {
description: "US ISOB West"
}
}
},
{
id: "aws-iso-e",
outputs: {
dnsSuffix: "cloud.adc-e.uk",
dualStackDnsSuffix: "api.cloud-aws.adc-e.uk",
implicitGlobalRegion: "eu-isoe-west-1",
name: "aws-iso-e",
supportsDualStack: true,
supportsFIPS: true
},
regionRegex: "^eu\\-isoe\\-\\w+\\-\\d+$",
regions: {
"aws-iso-e-global": {
description: "aws-iso-e global region"
},
"eu-isoe-west-1": {
description: "EU ISOE West"
}
}
},
{
id: "aws-iso-f",
outputs: {
dnsSuffix: "csp.hci.ic.gov",
dualStackDnsSuffix: "api.aws.hci.ic.gov",
implicitGlobalRegion: "us-isof-south-1",
name: "aws-iso-f",
supportsDualStack: true,
supportsFIPS: true
},
regionRegex: "^us\\-isof\\-\\w+\\-\\d+$",
regions: {
"aws-iso-f-global": {
description: "aws-iso-f global region"
},
"us-isof-east-1": {
description: "US ISOF EAST"
},
"us-isof-south-1": {
description: "US ISOF SOUTH"
}
}
},
{
id: "aws-us-gov",
outputs: {
dnsSuffix: "amazonaws.com",
dualStackDnsSuffix: "api.aws",
implicitGlobalRegion: "us-gov-west-1",
name: "aws-us-gov",
supportsDualStack: true,
supportsFIPS: true
},
regionRegex: "^us\\-gov\\-\\w+\\-\\d+$",
regions: {
"aws-us-gov-global": {
description: "aws-us-gov global region"
},
"us-gov-east-1": {
description: "AWS GovCloud (US-East)"
},
"us-gov-west-1": {
description: "AWS GovCloud (US-West)"
}
}
}
],
version: "1.1"
};
var selectedPartitionsInfo = partitionsInfo;
var selectedUserAgentPrefix = "";
var partition = (value) => {
const { partitions } = selectedPartitionsInfo;
for (const partition of partitions) {
const { regions, outputs } = partition;
for (const [region, regionData] of Object.entries(regions)) {
if (region === value) {
return {
...outputs,
...regionData
};
}
}
}
for (const partition of partitions) {
const { regionRegex, outputs } = partition;
if (new RegExp(regionRegex).test(value)) {
return {
...outputs
};
}
}
const DEFAULT_PARTITION = partitions.find((partition) => partition.id === "aws");
if (!DEFAULT_PARTITION) {
throw new Error("Provided region was not found in the partition array or regex," + " and default partition with id 'aws' doesn't exist.");
}
return {
...DEFAULT_PARTITION.outputs
};
};
var setPartitionInfo = (partitionsInfo, userAgentPrefix = "") => {
selectedPartitionsInfo = partitionsInfo;
selectedUserAgentPrefix = userAgentPrefix;
};
var useDefaultPartitionInfo = () => {
setPartitionInfo(partitionsInfo, "");
};
var getUserAgentPrefix = () => selectedUserAgentPrefix;
var ACCOUNT_ID_ENDPOINT_REGEX = /\d{12}\.ddb/;
async function checkFeatures(context, config, args) {
const request = args.request;
if (request?.headers?.["smithy-protocol"] === "rpc-v2-cbor") {
setFeature(context, "PROTOCOL_RPC_V2_CBOR", "M");
}
if (typeof config.retryStrategy === "function") {
const retryStrategy = await config.retryStrategy();
if (typeof retryStrategy.mode === "string") {
switch (retryStrategy.mode) {
case RETRY_MODES.ADAPTIVE:
setFeature(context, "RETRY_MODE_ADAPTIVE", "F");
break;
case RETRY_MODES.STANDARD:
setFeature(context, "RETRY_MODE_STANDARD", "E");
break;
}
}
}
if (typeof config.accountIdEndpointMode === "function") {
const endpointV2 = context.endpointV2;
if (String(endpointV2?.url?.hostname).match(ACCOUNT_ID_ENDPOINT_REGEX)) {
setFeature(context, "ACCOUNT_ID_ENDPOINT", "O");
}
switch (await config.accountIdEndpointMode?.()) {
case "disabled":
setFeature(context, "ACCOUNT_ID_MODE_DISABLED", "Q");
break;
case "preferred":
setFeature(context, "ACCOUNT_ID_MODE_PREFERRED", "P");
break;
case "required":
setFeature(context, "ACCOUNT_ID_MODE_REQUIRED", "R");
break;
}
}
const identity = context.__smithy_context?.selectedHttpAuthScheme?.identity;
if (identity?.$source) {
const credentials = identity;
if (credentials.accountId) {
setFeature(context, "RESOLVED_ACCOUNT_ID", "T");
}
for (const [key, value] of Object.entries(credentials.$source ?? {})) {
setFeature(context, key, value);
}
}
}
var USER_AGENT = "user-agent";
var X_AMZ_USER_AGENT = "x-amz-user-agent";
var SPACE = " ";
var UA_NAME_SEPARATOR = "/";
var UA_NAME_ESCAPE_REGEX = /[^!$%&'*+\-.^_`|~\w]/g;
var UA_VALUE_ESCAPE_REGEX = /[^!$%&'*+\-.^_`|~\w#]/g;
var UA_ESCAPE_CHAR = "-";
var BYTE_LIMIT = 1024;
function encodeFeatures(features) {
let buffer = "";
for (const key in features) {
const val = features[key];
if (buffer.length + val.length + 1 <= BYTE_LIMIT) {
if (buffer.length) {
buffer += "," + val;
} else {
buffer += val;
}
continue;
}
break;
}
return buffer;
}
var userAgentMiddleware = (options) => (next, context) => async (args) => {
const { request } = args;
if (!HttpRequest.isInstance(request)) {
return next(args);
}
const { headers } = request;
const userAgent = context?.userAgent?.map(escapeUserAgent) || [];
const defaultUserAgent = (await options.defaultUserAgentProvider()).map(escapeUserAgent);
await checkFeatures(context, options, args);
const awsContext = context;
defaultUserAgent.push(`m/${encodeFeatures(Object.assign({}, context.__smithy_context?.features, awsContext.__aws_sdk_context?.features))}`);
const customUserAgent = options?.customUserAgent?.map(escapeUserAgent) || [];
const appId = await options.userAgentAppId();
if (appId) {
defaultUserAgent.push(escapeUserAgent([`app`, `${appId}`]));
}
const prefix = getUserAgentPrefix();
const sdkUserAgentValue = (prefix ? [prefix] : []).concat([...defaultUserAgent, ...userAgent, ...customUserAgent]).join(SPACE);
const normalUAValue = [
...defaultUserAgent.filter((section) => section.startsWith("aws-sdk-")),
...customUserAgent
].join(SPACE);
if (options.runtime !== "browser") {
if (normalUAValue) {
headers[X_AMZ_USER_AGENT] = headers[X_AMZ_USER_AGENT] ? `${headers[USER_AGENT]} ${normalUAValue}` : normalUAValue;
}
headers[USER_AGENT] = sdkUserAgentValue;
} else {
headers[X_AMZ_USER_AGENT] = sdkUserAgentValue;
}
return next({
...args,
request
});
};
var escapeUserAgent = (userAgentPair) => {
const name = userAgentPair[0].split(UA_NAME_SEPARATOR).map((part) => part.replace(UA_NAME_ESCAPE_REGEX, UA_ESCAPE_CHAR)).join(UA_NAME_SEPARATOR);
const version = userAgentPair[1]?.replace(UA_VALUE_ESCAPE_REGEX, UA_ESCAPE_CHAR);
const prefixSeparatorIndex = name.indexOf(UA_NAME_SEPARATOR);
const prefix = name.substring(0, prefixSeparatorIndex);
let uaName = name.substring(prefixSeparatorIndex + 1);
if (prefix === "api") {
uaName = uaName.toLowerCase();
}
return [prefix, uaName, version].filter((item) => item && item.length > 0).reduce((acc, item, index) => {
switch (index) {
case 0:
return item;
case 1:
return `${acc}/${item}`;
default:
return `${acc}#${item}`;
}
}, "");
};
var getUserAgentMiddlewareOptions = {
name: "getUserAgentMiddleware",
step: "build",
priority: "low",
tags: ["SET_USER_AGENT", "USER_AGENT"],
override: true
};
var getUserAgentPlugin = (config) => ({
applyToStack: (clientStack) => {
clientStack.add(userAgentMiddleware(config), getUserAgentMiddlewareOptions);
}
});
var getRuntimeUserAgentPair = () => {
const runtimesToCheck = ["deno", "bun", "llrt"];
for (const runtime of runtimesToCheck) {
if (versions[runtime]) {
return [`md/${runtime}`, versions[runtime]];
}
}
return ["md/nodejs", versions.node];
};
var crtAvailability = {
isCrtAvailable: false
};
var isCrtAvailable = () => {
if (crtAvailability.isCrtAvailable) {
return ["md/crt-avail"];
}
return null;
};
var createDefaultUserAgentProvider = ({ serviceId, clientVersion }) => {
const runtimeUserAgentPair = getRuntimeUserAgentPair();
return async (config) => {
const sections = [
["aws-sdk-js", clientVersion],
["ua", "2.1"],
[`os/${platform()}`, release()],
["lang/js"],
runtimeUserAgentPair
];
const crtAvailable = isCrtAvailable();
if (crtAvailable) {
sections.push(crtAvailable);
}
if (serviceId) {
sections.push([`api/${serviceId}`, clientVersion]);
}
if (env.AWS_EXECUTION_ENV) {
sections.push([`exec-env/${env.AWS_EXECUTION_ENV}`]);
}
const appId = await config?.userAgentAppId?.();
const resolvedUserAgent = appId ? [...sections, [`app/${appId}`]] : [...sections];
return resolvedUserAgent;
};
};
var defaultUserAgent = createDefaultUserAgentProvider;
var UA_APP_ID_ENV_NAME = "AWS_SDK_UA_APP_ID";
var UA_APP_ID_INI_NAME = "sdk_ua_app_id";
var UA_APP_ID_INI_NAME_DEPRECATED = "sdk-ua-app-id";
var NODE_APP_ID_CONFIG_OPTIONS = {
environmentVariableSelector: (env2) => env2[UA_APP_ID_ENV_NAME],
configFileSelector: (profile) => profile[UA_APP_ID_INI_NAME] ?? profile[UA_APP_ID_INI_NAME_DEPRECATED],
default: DEFAULT_UA_APP_ID
};
var createUserAgentStringParsingProvider = ({ serviceId, clientVersion }) => async (config) => {
const module2 = require_es5();
const parse2 = module2.parse ?? module2.default.parse ?? (() => "");
const parsedUA = typeof window !== "undefined" && window?.navigator?.userAgent ? parse2(window.navigator.userAgent) : undefined;
const sections = [
["aws-sdk-js", clientVersion],
["ua", "2.1"],
[`os/${parsedUA?.os?.name || "other"}`, parsedUA?.os?.version],
["lang/js"],
["md/browser", `${parsedUA?.browser?.name ?? "unknown"}_${parsedUA?.browser?.version ?? "unknown"}`]
];
if (serviceId) {
sections.push([`api/${serviceId}`, clientVersion]);
}
const appId = await config?.userAgentAppId?.();
if (appId) {
sections.push([`app/${appId}`]);
}
return sections;
};
var fallback = {
os(ua) {
if (/iPhone|iPad|iPod/.test(ua))
return "iOS";
if (/Macintosh|Mac OS X/.test(ua))
return "macOS";
if (/Windows NT/.test(ua))
return "Windows";
if (/Android/.test(ua))
return "Android";
if (/Linux/.test(ua))
return "Linux";
return;
},
browser(ua) {
if (/EdgiOS|EdgA|Edg\//.test(ua))
return "Microsoft Edge";
if (/Firefox\//.test(ua))
return "Firefox";
if (/Chrome\//.test(ua))
return "Chrome";
if (/Safari\//.test(ua))
return "Safari";
return;
}
};
var isVirtualHostableS3Bucket = (value, allowSubDomains = false) => {
if (allowSubDomains) {
for (const label of value.split(".")) {
if (!isVirtualHostableS3Bucket(label)) {
return false;
}
}
return true;
}
if (!isValidHostLabel(value)) {
return false;
}
if (value.length < 3 || value.length > 63) {
return false;
}
if (value !== value.toLowerCase()) {
return false;
}
if (isIpAddress(value)) {
return false;
}
return true;
};
var ARN_DELIMITER = ":";
var RESOURCE_DELIMITER = "/";
var parseArn = (value) => {
const segments = value.split(ARN_DELIMITER);
if (segments.length < 6)
return null;
const [arn, partition, service, region, accountId, ...resourcePath] = segments;
if (arn !== "arn" || partition === "" || service === "" || resourcePath.join(ARN_DELIMITER) === "")
return null;
const resourceId = resourcePath.map((resource) => resource.split(RESOURCE_DELIMITER)).flat();
return {
partition,
service,
region,
accountId,
resourceId
};
};
var awsEndpointFunctions = {
isVirtualHostableS3Bucket,
parseArn,
partition
};
customEndpointFunctions.aws = awsEndpointFunctions;
var resolveDefaultAwsRegionalEndpointsConfig = (input) => {
if (typeof input.endpointProvider !== "function") {
throw new Error("@aws-sdk/util-endpoint - endpointProvider and endpoint missing in config for this client.");
}
const { endpoint } = input;
if (endpoint === undefined) {
input.endpoint = async () => {
return toEndpointV1(input.endpointProvider({
Region: typeof input.region === "function" ? await input.region() : input.region,
UseDualStack: typeof input.useDualstackEndpoint === "function" ? await input.useDualstackEndpoint() : input.useDualstackEndpoint,
UseFIPS: typeof input.useFipsEndpoint === "function" ? await input.useFipsEndpoint() : input.useFipsEndpoint,
Endpoint: undefined
}, { logger: input.logger }));
};
}
return input;
};
var toEndpointV1 = (endpoint) => parseUrl(endpoint.url);
function stsRegionDefaultResolver(loaderConfig = {}) {
return loadConfig({
...NODE_REGION_CONFIG_OPTIONS,
async default() {
if (!warning.silence) {
console.warn("@aws-sdk - WARN - default STS region of us-east-1 used. See @aws-sdk/credential-providers README and set a region explicitly.");
}
return "us-east-1";
}
}, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig });
}
var warning = {
silence: false
};
var getAwsRegionExtensionConfiguration = (runtimeConfig) => {
return {
setRegion(region) {
runtimeConfig.region = region;
},
region() {
return runtimeConfig.region;
}
};
};
var resolveAwsRegionExtensionConfiguration = (awsRegionExtensionConfiguration) => {
return {
region: awsRegionExtensionConfiguration.region()
};
};
exports.DEFAULT_UA_APP_ID = DEFAULT_UA_APP_ID;
exports.NODE_APP_ID_CONFIG_OPTIONS = NODE_APP_ID_CONFIG_OPTIONS;
exports.UA_APP_ID_ENV_NAME = UA_APP_ID_ENV_NAME;
exports.UA_APP_ID_INI_NAME = UA_APP_ID_INI_NAME;
exports.awsEndpointFunctions = awsEndpointFunctions;
exports.createDefaultUserAgentProvider = createDefaultUserAgentProvider;
exports.createUserAgentStringParsingProvider = createUserAgentStringParsingProvider;
exports.crtAvailability = crtAvailability;
exports.defaultUserAgent = defaultUserAgent;
exports.emitWarningIfUnsupportedVersion = emitWarningIfUnsupportedVersion;
exports.fallback = fallback;
exports.getAwsRegionExtensionConfiguration = getAwsRegionExtensionConfiguration;
exports.getHostHeaderPlugin = getHostHeaderPlugin;
exports.getLoggerPlugin = getLoggerPlugin;
exports.getLongPollPlugin = getLongPollPlugin;
exports.getRecursionDetectionPlugin = getRecursionDetectionPlugin;
exports.getUserAgentMiddlewareOptions = getUserAgentMiddlewareOptions;
exports.getUserAgentPlugin = getUserAgentPlugin;
exports.getUserAgentPrefix = getUserAgentPrefix;
exports.hostHeaderMiddleware = hostHeaderMiddleware;
exports.hostHeaderMiddlewareOptions = hostHeaderMiddlewareOptions;
exports.isVirtualHostableS3Bucket = isVirtualHostableS3Bucket;
exports.loggerMiddleware = loggerMiddleware;
exports.loggerMiddlewareOptions = loggerMiddlewareOptions;
exports.parseArn = parseArn;
exports.partition = partition;
exports.recursionDetectionMiddleware = recursionDetectionMiddleware;
exports.recursionDetectionMiddlewareOptions = recursionDetectionMiddlewareOptions;
exports.resolveAwsRegionExtensionConfiguration = resolveAwsRegionExtensionConfiguration;
exports.resolveDefaultAwsRegionalEndpointsConfig = resolveDefaultAwsRegionalEndpointsConfig;
exports.resolveHostHeaderConfig = resolveHostHeaderConfig;
exports.resolveUserAgentConfig = resolveUserAgentConfig;
exports.setCredentialFeature = setCredentialFeature;
exports.setFeature = setFeature;
exports.setPartitionInfo = setPartitionInfo;
exports.setTokenFeature = setTokenFeature;
exports.state = state;
exports.stsRegionDefaultResolver = stsRegionDefaultResolver;
exports.stsRegionWarning = warning;
exports.toEndpointV1 = toEndpointV1;
exports.useDefaultPartitionInfo = useDefaultPartitionInfo;
exports.userAgentMiddleware = userAgentMiddleware;
});
// ../../node_modules/.bun/@smithy+signature-v4@5.7.3/node_modules/@smithy/signature-v4/dist-cjs/index.js
var require_dist_cjs3 = __commonJS(function(exports) {
var { hasOwn, fromUtf8, fromHex, toHex, toUint8Array, isArrayBuffer } = require_serde();
var { normalizeProvider } = require_client();
var { escapeUri, HttpRequest } = require_protocols();
class HeaderFormatter {
format(headers) {
const chunks = [];
for (const headerName in headers) {
if (!hasOwn(headers, headerName))
continue;
const bytes = 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 = new DataView(new ArrayBuffer(3));
shortView.setUint8(0, 3);
shortView.setInt16(1, header.value, false);
return new Uint8Array(shortView.buffer);
case "integer":
const intView = new DataView(new ArrayBuffer(5));
intView.setUint8(0, 4);
intView.setInt32(1, header.value, false);
return new Uint8Array(intView.buffer);
case "long":
const longBytes = 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 = 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 = 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 = new Uint8Array(17);
uuidBytes[0] = 9;
uuidBytes.set(fromHex(header.value.replace(/-/g, "")), 1);
return uuidBytes;
}
}
}
var HEADER_VALUE_TYPE;
(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 = {}));
var UUID_PATTERN = /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
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 > 9223372036854776000 || number < -9223372036854776000) {
throw new Error(`${number} is too large (or, if negative, too small) to represent as an Int64`);
}
const bytes = 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());
}
}
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 ALGORITHM_QUERY_PARAM = "X-Amz-Algorithm";
var CREDENTIAL_QUERY_PARAM = "X-Amz-Credential";
var AMZ_DATE_QUERY_PARAM = "X-Amz-Date";
var SIGNED_HEADERS_QUERY_PARAM = "X-Amz-SignedHeaders";
var EXPIRES_QUERY_PARAM = "X-Amz-Expires";
var SIGNATURE_QUERY_PARAM = "X-Amz-Signature";
var TOKEN_QUERY_PARAM = "X-Amz-Security-Token";
var REGION_SET_PARAM = "X-Amz-Region-Set";
var AUTH_HEADER = "authorization";
var AMZ_DATE_HEADER = AMZ_DATE_QUERY_PARAM.toLowerCase();
var DATE_HEADER = "date";
var GENERATED_HEADERS = [AUTH_HEADER, AMZ_DATE_HEADER, DATE_HEADER];
var SIGNATURE_HEADER = SIGNATURE_QUERY_PARAM.toLowerCase();
var SHA256_HEADER = "x-amz-content-sha256";
var TOKEN_HEADER = TOKEN_QUERY_PARAM.toLowerCase();
var HOST_HEADER = "host";
var ALWAYS_UNSIGNABLE_HEADERS = {
authorization: true,
"cache-control": true,
connection: true,
expect: true,
from: true,
"keep-alive": true,
"max-forwards": true,
pragma: true,
referer: true,
te: true,
trailer: true,
"transfer-encoding": true,
upgrade: true,
"user-agent": true,
"x-amzn-trace-id": true
};
var PROXY_HEADER_PATTERN = /^proxy-/;
var SEC_HEADER_PATTERN = /^sec-/;
var UNSIGNABLE_PATTERNS = [/^proxy-/i, /^sec-/i];
var ALGORITHM_IDENTIFIER = "AWS4-HMAC-SHA256";
var ALGORITHM_IDENTIFIER_V4A = "AWS4-ECDSA-P256-SHA256";
var EVENT_ALGORITHM_IDENTIFIER = "AWS4-HMAC-SHA256-PAYLOAD";
var UNSIGNED_PAYLOAD = "UNSIGNED-PAYLOAD";
var MAX_CACHE_SIZE = 50;
var KEY_TYPE_IDENTIFIER = "aws4_request";
var MAX_PRESIGNED_TTL = 60 * 60 * 24 * 7;
var getCanonicalQuery = ({ query = {} }) => {
const keys = [];
const serialized = {};
for (const key in query) {
if (!hasOwn(query, key))
continue;
if (key.toLowerCase() === SIGNATURE_HEADER) {
continue;
}
const encodedKey = escapeUri(key);
keys.push(encodedKey);
const value = query[key];
if (typeof value === "string") {
serialized[encodedKey] = `${encodedKey}=${escapeUri(value)}`;
} else if (Array.isArray(value)) {
serialized[encodedKey] = value.slice(0).reduce((encoded, value) => encoded.concat([`${encodedKey}=${escapeUri(value)}`]), []).sort().join("&");
}
}
return keys.sort().map((key) => serialized[key]).filter((serialized) => serialized).join("&");
};
var iso8601 = (time) => toDate(time).toISOString().replace(/\.\d{3}Z$/, "Z");
var toDate = (time) => {
if (typeof time === "number") {
return new Date(time * 1000);
}
if (typeof time === "string") {
if (Number(time)) {
return new Date(Number(time) * 1000);
}
return new Date(time);
}
return time;
};
class SignatureV4Base {
service;
regionProvider;
credentialProvider;
sha256;
uriEscapePath;
applyChecksum;
constructor({ applyChecksum, credentials, region, service, sha256, uriEscapePath = true }) {
this.service = service;
this.sha256 = sha256;
this.uriEscapePath = uriEscapePath;
this.applyChecksum = typeof applyChecksum === "boolean" ? applyChecksum : true;
this.regionProvider = normalizeProvider(region);
this.credentialProvider = normalizeProvider(credentials);
}
createCanonicalRequest(request, canonicalHeaders, payloadHash) {
const sortedHeaders = Object.keys(canonicalHeaders).sort();
return `${request.method}
${this.getCanonicalPath(request)}
${getCanonicalQuery(request)}
${sortedHeaders.map((name) => `${name}:${canonicalHeaders[name]}`).join(`
`)}
${sortedHeaders.join(";")}
${payloadHash}`;
}
async createStringToSign(longDate, credentialScope, canonicalRequest, algorithmIdentifier) {
const hash = new this.sha256;
hash.update(toUint8Array(canonicalRequest));
const hashedRequest = await hash.digest();
return `${algorithmIdentifier}
${longDate}
${credentialScope}
${toHex(hashedRequest)}`;
}
getCanonicalPath({ path }) {
if (this.uriEscapePath) {
const normalizedPathSegments = [];
for (const pathSegment of path.split("/")) {
if (pathSegment?.length === 0)
continue;
if (pathSegment === ".")
continue;
if (pathSegment === "..") {
normalizedPathSegments.pop();
} else {
normalizedPathSegments.push(pathSegment);
}
}
const normalizedPath = `${path?.startsWith("/") ? "/" : ""}${normalizedPathSegments.join("/")}${normalizedPathSegments.length > 0 && path?.endsWith("/") ? "/" : ""}`;
const doubleEncoded = escapeUri(normalizedPath);
return doubleEncoded.replace(/%2F/g, "/");
}
return path;
}
validateResolvedCredentials(credentials) {
if (typeof credentials !== "object" || typeof credentials.accessKeyId !== "string" || typeof credentials.secretAccessKey !== "string") {
throw new Error("Resolved credential object is not valid");
}
}
formatDate(now) {
const longDate = iso8601(now).replace(/[-:]/g, "");
return {
longDate,
shortDate: longDate.slice(0, 8)
};
}
getCanonicalHeaderList(headers) {
return Object.keys(headers).sort().join(";");
}
}
var signingKeyCache = {};
var cacheQueue = [];
var createScope = (shortDate, region, service) => `${shortDate}/${region}/${service}/${KEY_TYPE_IDENTIFIER}`;
var getSigningKey = async (sha256Constructor, credentials, shortDate, region, service) => {
const credsHash = await hmac(sha256Constructor, credentials.secretAccessKey, credentials.accessKeyId);
const cacheKey = `${shortDate}:${region}:${service}:${toHex(credsHash)}:${credentials.sessionToken}`;
if (cacheKey in signingKeyCache) {
return signingKeyCache[cacheKey];
}
cacheQueue.push(cacheKey);
while (cacheQueue.length > MAX_CACHE_SIZE) {
delete signingKeyCache[cacheQueue.shift()];
}
let key = `AWS4${credentials.secretAccessKey}`;
for (const signable of [shortDate, region, service, KEY_TYPE_IDENTIFIER]) {
key = await hmac(sha256Constructor, key, signable);
}
return signingKeyCache[cacheKey] = key;
};
var clearCredentialCache = () => {
cacheQueue.length = 0;
Object.keys(signingKeyCache).forEach((cacheKey) => {
delete signingKeyCache[cacheKey];
});
};
var hmac = (ctor, secret, data) => {
const hash = new ctor(secret);
hash.update(toUint8Array(data));
return hash.digest();
};
var getCanonicalHeaders = ({ headers }, unsignableHeaders, signableHeaders) => {
const canonical = {};
for (const headerName of Object.keys(headers).sort()) {
if (headers[headerName] == undefined) {
continue;
}
const canonicalHeaderName = headerName.toLowerCase();
if (canonicalHeaderName in ALWAYS_UNSIGNABLE_HEADERS || unsignableHeaders?.has(canonicalHeaderName) || PROXY_HEADER_PATTERN.test(canonicalHeaderName) || SEC_HEADER_PATTERN.test(canonicalHeaderName)) {
if (!signableHeaders || signableHeaders && !signableHeaders.has(canonicalHeaderName)) {
continue;
}
}
canonical[canonicalHeaderName] = headers[headerName].trim().replace(/\s+/g, " ");
}
return canonical;
};
var getPayloadHash = async ({ headers, body }, hashConstructor) => {
for (const headerName in headers) {
if (!hasOwn(headers, headerName))
continue;
if (headerName.toLowerCase() === SHA256_HEADER) {
return headers[headerName];
}
}
if (body == undefined) {
return "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
} else if (typeof body === "string" || ArrayBuffer.isView(body) || isArrayBuffer(body)) {
const hashCtor = new hashConstructor;
hashCtor.update(toUint8Array(body));
return toHex(await hashCtor.digest());
}
return UNSIGNED_PAYLOAD;
};
var hasHeader = (soughtHeader, headers) => {
soughtHeader = soughtHeader.toLowerCase();
for (const headerName in headers) {
if (!hasOwn(headers, headerName))
continue;
if (soughtHeader === headerName.toLowerCase()) {
return true;
}
}
return false;
};
var moveHeadersToQuery = (request, options = {}) => {
const { headers, query = {} } = HttpRequest.clone(request);
for (const name in headers) {
if (!hasOwn(headers, name))
continue;
const lname = name.toLowerCase();
if (lname.slice(0, 6) === "x-amz-" && !options.unhoistableHeaders?.has(lname) || options.hoistableHeaders?.has(lname)) {
query[name] = headers[name];
delete headers[name];
}
}
return {
...request,
headers,
query
};
};
var prepareRequest = (request) => {
request = HttpRequest.clone(request);
for (const headerName in request.headers) {
if (!hasOwn(request.headers, headerName))
continue;
if (GENERATED_HEADERS.indexOf(headerName.toLowerCase()) > -1) {
delete request.headers[headerName];
}
}
return request;
};
class SignatureV4 extends SignatureV4Base {
headerFormatter = new HeaderFormatter;
constructor({ applyChecksum, credentials, region, service, sha256, uriEscapePath = true }) {
super({
applyChecksum,
credentials,
region,
service,
sha256,
uriEscapePath
});
}
async presign(originalRequest, options = {}) {
const { signingDate = new Date, expiresIn = 3600, unsignableHeaders, unhoistableHeaders, signableHeaders, hoistableHeaders, signingRegion, signingService } = options;
const credentials = await this.credentialProvider();
this.validateResolvedCredentials(credentials);
const region = signingRegion ?? await this.regionProvider();
const { longDate, shortDate } = this.formatDate(signingDate);
if (expiresIn > MAX_PRESIGNED_TTL) {
return Promise.reject("Signature version 4 presigned URLs" + " must have an expiration date less than one week in" + " the future");
}
const scope = createScope(shortDate, region, signingService ?? this.service);
const request = moveHeadersToQuery(prepareRequest(originalRequest), { unhoistableHeaders, hoistableHeaders });
if (credentials.sessionToken) {
request.query[TOKEN_QUERY_PARAM] = credentials.sessionToken;
}
request.query[ALGORITHM_QUERY_PARAM] = ALGORITHM_IDENTIFIER;
request.query[CREDENTIAL_QUERY_PARAM] = `${credentials.accessKeyId}/${scope}`;
request.query[AMZ_DATE_QUERY_PARAM] = longDate;
request.query[EXPIRES_QUERY_PARAM] = expiresIn.toString(10);
const canonicalHeaders = getCanonicalHeaders(request, unsignableHeaders, signableHeaders);
request.query[SIGNED_HEADERS_QUERY_PARAM] = this.getCanonicalHeaderList(canonicalHeaders);
request.query[SIGNATURE_QUERY_PARAM] = await this.getSignature(longDate, scope, this.getSigningKey(credentials, region, shortDate, signingService), this.createCanonicalRequest(request, canonicalHeaders, await getPayloadHash(originalRequest, this.sha256)));
return request;
}
async sign(toSign, options) {
if (typeof toSign === "string") {
return this.signString(toSign, options);
} else if (toSign.headers && toSign.payload) {
return this.signEvent(toSign, options);
} else if (toSign.message) {
return this.signMessage(toSign, options);
} else {
return this.signRequest(toSign, options);
}
}
async signEvent({ headers, payload }, { signingDate = new Date, priorSignature, signingRegion, signingService, eventStreamCredentials }) {
const region = signingRegion ?? await this.regionProvider();
const { shortDate, longDate } = this.formatDate(signingDate);
const scope = createScope(shortDate, region, signingService ?? this.service);
const hashedPayload = await getPayloadHash({ headers: {}, body: payload }, this.sha256);
const hash = new this.sha256;
hash.update(headers);
const hashedHeaders = toHex(await hash.digest());
const stringToSign = [
EVENT_ALGORITHM_IDENTIFIER,
longDate,
scope,
priorSignature,
hashedHeaders,
hashedPayload
].join(`
`);
return this.signString(stringToSign, {
signingDate,
signingRegion: region,
signingService,
eventStreamCredentials
});
}
async signMessage(signableMessage, { signingDate = new Date, signingRegion, signingService, eventStreamCredentials }) {
const promise = this.signEvent({
headers: this.headerFormatter.format(signableMessage.message.headers),
payload: signableMessage.message.body
}, {
signingDate,
signingRegion,
signingService,
priorSignature: signableMessage.priorSignature,
eventStreamCredentials
});
return promise.then((signature) => {
return { message: signableMessage.message, signature };
});
}
async signString(stringToSign, { signingDate = new Date, signingRegion, signingService, eventStreamCredentials } = {}) {
const credentials = eventStreamCredentials ?? await this.credentialProvider();
this.validateResolvedCredentials(credentials);
const region = signingRegion ?? await this.regionProvider();
const { shortDate } = this.formatDate(signingDate);
const hash = new this.sha256(await this.getSigningKey(credentials, region, shortDate, signingService));
hash.update(toUint8Array(stringToSign));
return toHex(await hash.digest());
}
async signRequest(requestToSign, { signingDate = new Date, signableHeaders, unsignableHeaders, signingRegion, signingService } = {}) {
const credentials = await this.credentialProvider();
this.validateResolvedCredentials(credentials);
const region = signingRegion ?? await this.regionProvider();
const request = prepareRequest(requestToSign);
const { longDate, shortDate } = this.formatDate(signingDate);
const scope = createScope(shortDate, region, signingService ?? this.service);
request.headers[AMZ_DATE_HEADER] = longDate;
if (credentials.sessionToken) {
request.headers[TOKEN_HEADER] = credentials.sessionToken;
}
const payloadHash = await getPayloadHash(request, this.sha256);
if (!hasHeader(SHA256_HEADER, request.headers) && this.applyChecksum) {
request.headers[SHA256_HEADER] = payloadHash;
}
const canonicalHeaders = getCanonicalHeaders(request, unsignableHeaders, signableHeaders);
const signature = await this.getSignature(longDate, scope, this.getSigningKey(credentials, region, shortDate, signingService), this.createCanonicalRequest(request, canonicalHeaders, payloadHash));
request.headers[AUTH_HEADER] = `${ALGORITHM_IDENTIFIER} ` + `Credential=${credentials.accessKeyId}/${scope}, ` + `SignedHeaders=${this.getCanonicalHeaderList(canonicalHeaders)}, ` + `Signature=${signature}`;
return request;
}
async getSignature(longDate, credentialScope, keyPromise, canonicalRequest) {
const stringToSign = await this.createStringToSign(longDate, credentialScope, canonicalRequest, ALGORITHM_IDENTIFIER);
const hash = new this.sha256(await keyPromise);
hash.update(toUint8Array(stringToSign));
return toHex(await hash.digest());
}
getSigningKey(credentials, region, shortDate, service) {
return getSigningKey(this.sha256, credentials, shortDate, region, service || this.service);
}
}
var signatureV4aContainer = {
SignatureV4a: null
};
exports.ALGORITHM_IDENTIFIER = ALGORITHM_IDENTIFIER;
exports.ALGORITHM_IDENTIFIER_V4A = ALGORITHM_IDENTIFIER_V4A;
exports.ALGORITHM_QUERY_PARAM = ALGORITHM_QUERY_PARAM;
exports.ALWAYS_UNSIGNABLE_HEADERS = ALWAYS_UNSIGNABLE_HEADERS;
exports.AMZ_DATE_HEADER = AMZ_DATE_HEADER;
exports.AMZ_DATE_QUERY_PARAM = AMZ_DATE_QUERY_PARAM;
exports.AUTH_HEADER = AUTH_HEADER;
exports.CREDENTIAL_QUERY_PARAM = CREDENTIAL_QUERY_PARAM;
exports.DATE_HEADER = DATE_HEADER;
exports.EVENT_ALGORITHM_IDENTIFIER = EVENT_ALGORITHM_IDENTIFIER;
exports.EXPIRES_QUERY_PARAM = EXPIRES_QUERY_PARAM;
exports.GENERATED_HEADERS = GENERATED_HEADERS;
exports.HOST_HEADER = HOST_HEADER;
exports.KEY_TYPE_IDENTIFIER = KEY_TYPE_IDENTIFIER;
exports.MAX_CACHE_SIZE = MAX_CACHE_SIZE;
exports.MAX_PRESIGNED_TTL = MAX_PRESIGNED_TTL;
exports.PROXY_HEADER_PATTERN = PROXY_HEADER_PATTERN;
exports.REGION_SET_PARAM = REGION_SET_PARAM;
exports.SEC_HEADER_PATTERN = SEC_HEADER_PATTERN;
exports.SHA256_HEADER = SHA256_HEADER;
exports.SIGNATURE_HEADER = SIGNATURE_HEADER;
exports.SIGNATURE_QUERY_PARAM = SIGNATURE_QUERY_PARAM;
exports.SIGNED_HEADERS_QUERY_PARAM = SIGNED_HEADERS_QUERY_PARAM;
exports.SignatureV4 = SignatureV4;
exports.SignatureV4Base = SignatureV4Base;
exports.TOKEN_HEADER = TOKEN_HEADER;
exports.TOKEN_QUERY_PARAM = TOKEN_QUERY_PARAM;
exports.UNSIGNABLE_PATTERNS = UNSIGNABLE_PATTERNS;
exports.UNSIGNED_PAYLOAD = UNSIGNED_PAYLOAD;
exports.clearCredentialCache = clearCredentialCache;
exports.createScope = createScope;
exports.getCanonicalHeaders = getCanonicalHeaders;
exports.getCanonicalQuery = getCanonicalQuery;
exports.getPayloadHash = getPayloadHash;
exports.getSigningKey = getSigningKey;
exports.hasHeader = hasHeader;
exports.moveHeadersToQuery = moveHeadersToQuery;
exports.prepareRequest = prepareRequest;
exports.signatureV4aContainer = signatureV4aContainer;
});
// ../../node_modules/.bun/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-cjs/submodules/httpAuthSchemes/index.js
var require_httpAuthSchemes = __commonJS(function(exports) {
var { ProviderError, booleanSelector, SelectorType, loadConfig } = require_config();
var { setCredentialFeature } = require_client2();
var { normalizeProvider, memoizeIdentityProvider, isIdentityExpired, doesIdentityRequireRefresh } = require_dist_cjs2();
var { SignatureV4 } = require_dist_cjs3();
var { HttpResponse, HttpRequest } = require_protocols();
var getDateHeader = (response) => HttpResponse.isInstance(response) ? response.headers?.date ?? response.headers?.Date : undefined;
var getAgeHeader = (response) => HttpResponse.isInstance(response) ? response.headers?.age ?? response.headers?.Age : undefined;
var getSkewCorrectedDate = (systemClockOffset) => new Date(Date.now() + systemClockOffset);
var getUpdatedSystemClockOffset = (clockTime, currentSystemClockOffset, timeRequestSent, ageHeader) => {
if (ageHeader !== undefined) {
return currentSystemClockOffset;
}
const serverTime = Date.parse(clockTime);
const timeResponseReceived = Date.now();
if (timeRequestSent !== undefined && timeResponseReceived - timeRequestSent > 900000) {
return currentSystemClockOffset;
}
const candidateSkew = timeRequestSent !== undefined ? serverTime - (timeRequestSent + timeResponseReceived) / 2 : serverTime - timeResponseReceived;
return candidateSkew;
};
var throwSigningPropertyError = (name, property) => {
if (!property) {
throw new Error(`Property \`${name}\` is not resolved for AWS SDK SigV4Auth`);
}
return property;
};
var validateSigningProperties = async (signingProperties) => {
const context = throwSigningPropertyError("context", signingProperties.context);
const config = throwSigningPropertyError("config", signingProperties.config);
const authScheme = context.endpointV2?.properties?.authSchemes?.[0];
const signerFunction = throwSigningPropertyError("signer", config.signer);
const signer = await signerFunction(authScheme);
const signingRegion = signingProperties?.signingRegion;
const signingRegionSet = signingProperties?.signingRegionSet;
const signingName = signingProperties?.signingName;
return {
config,
signer,
signingRegion,
signingRegionSet,
signingName
};
};
class AwsSdkSigV4Signer {
async sign(httpRequest, identity, signingProperties) {
if (!HttpRequest.isInstance(httpRequest)) {
throw new Error("The request is not an instance of `HttpRequest` and cannot be signed");
}
const validatedProps = await validateSigningProperties(signingProperties);
const { config, signer } = validatedProps;
let { signingRegion, signingName } = validatedProps;
const handlerExecutionContext = signingProperties.context;
if (handlerExecutionContext?.authSchemes?.length ?? 0 > 1) {
const [first, second] = handlerExecutionContext.authSchemes;
if (first?.name === "sigv4a" && second?.name === "sigv4") {
signingRegion = second?.signingRegion ?? signingRegion;
signingName = second?.signingName ?? signingName;
}
}
const noSkewCorrection = await config.disableClockSkewCorrection?.() === true;
signingProperties._disableClockSkewCorrection = noSkewCorrection;
if (!noSkewCorrection) {
signingProperties._preRequestSystemClockOffset = config.systemClockOffset;
signingProperties._requestSentAt = Date.now();
}
const signedRequest = await signer.sign(httpRequest, {
signingDate: noSkewCorrection ? new Date : getSkewCorrectedDate(config.systemClockOffset),
signingRegion,
signingService: signingName
});
return signedRequest;
}
errorHandler(signingProperties) {
return (error) => {
const errorException = error;
if (!signingProperties._disableClockSkewCorrection) {
const serverTime = errorException.ServerTime ?? getDateHeader(errorException.$response);
if (serverTime) {
const config = throwSigningPropertyError("config", signingProperties.config);
const preRequestOffset = signingProperties._preRequestSystemClockOffset;
const timeRequestSent = signingProperties._requestSentAt;
const ageHeader = getAgeHeader(errorException.$response);
const newOffset = getUpdatedSystemClockOffset(serverTime, config.systemClockOffset, timeRequestSent, ageHeader);
config.systemClockOffset = newOffset;
const skewExceedsThreshold = Math.abs(newOffset) >= 240000;
const isLocalCorrection = newOffset !== preRequestOffset;
const isConcurrentCorrection = preRequestOffset !== undefined && preRequestOffset !== newOffset;
if (skewExceedsThreshold && (isLocalCorrection || isConcurrentCorrection) && errorException.$metadata) {
errorException.$metadata.clockSkewCorrected = true;
}
}
}
throw error;
};
}
successHandler(httpResponse, signingProperties) {
if (signingProperties._disableClockSkewCorrection) {
return;
}
const dateHeader = getDateHeader(httpResponse);
if (dateHeader) {
const config = throwSigningPropertyError("config", signingProperties.config);
const timeRequestSent = signingProperties._requestSentAt;
const ageHeader = getAgeHeader(httpResponse);
config.systemClockOffset = getUpdatedSystemClockOffset(dateHeader, config.systemClockOffset, timeRequestSent, ageHeader);
}
}
}
var AWSSDKSigV4Signer = AwsSdkSigV4Signer;
class AwsSdkSigV4ASigner extends AwsSdkSigV4Signer {
async sign(httpRequest, identity, signingProperties) {
if (!HttpRequest.isInstance(httpRequest)) {
throw new Error("The request is not an instance of `HttpRequest` and cannot be signed");
}
const { config, signer, signingRegion, signingRegionSet, signingName } = await validateSigningProperties(signingProperties);
const configResolvedSigningRegionSet = await config.sigv4aSigningRegionSet?.();
const multiRegionOverride = (configResolvedSigningRegionSet ?? signingRegionSet ?? [signingRegion]).join(",");
const noSkewCorrection = await config.disableClockSkewCorrection?.() === true;
signingProperties._disableClockSkewCorrection = noSkewCorrection;
if (!noSkewCorrection) {
signingProperties._preRequestSystemClockOffset = config.systemClockOffset;
signingProperties._requestSentAt = Date.now();
}
const signedRequest = await signer.sign(httpRequest, {
signingDate: noSkewCorrection ? new Date : getSkewCorrectedDate(config.systemClockOffset),
signingRegion: multiRegionOverride,
signingService: signingName
});
return signedRequest;
}
}
var getArrayForCommaSeparatedString = (str) => typeof str === "string" && str.length > 0 ? str.split(",").map((item) => item.trim()) : [];
var getBearerTokenEnvKey = (signingName) => `AWS_BEARER_TOKEN_${signingName.replace(/[\s-]/g, "_").toUpperCase()}`;
var NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY = "AWS_AUTH_SCHEME_PREFERENCE";
var NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY = "auth_scheme_preference";
var NODE_AUTH_SCHEME_PREFERENCE_OPTIONS = {
environmentVariableSelector: (env, options) => {
if (options?.signingName) {
const bearerTokenKey = getBearerTokenEnvKey(options.signingName);
if (bearerTokenKey in env)
return ["httpBearerAuth"];
}
if (!(NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY in env))
return;
return getArrayForCommaSeparatedString(env[NODE_AUTH_SCHEME_PREFERENCE_ENV_KEY]);
},
configFileSelector: (profile) => {
if (!(NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY in profile))
return;
return getArrayForCommaSeparatedString(profile[NODE_AUTH_SCHEME_PREFERENCE_CONFIG_KEY]);
},
default: []
};
var resolveAwsSdkSigV4AConfig = (config) => {
config.sigv4aSigningRegionSet = normalizeProvider(config.sigv4aSigningRegionSet);
return config;
};
var NODE_SIGV4A_CONFIG_OPTIONS = {
environmentVariableSelector(env) {
if (env.AWS_SIGV4A_SIGNING_REGION_SET) {
return env.AWS_SIGV4A_SIGNING_REGION_SET.split(",").map((_) => _.trim());
}
throw new ProviderError("AWS_SIGV4A_SIGNING_REGION_SET not set in env.", {
tryNextLink: true
});
},
configFileSelector(profile) {
if (profile.sigv4a_signing_region_set) {
return (profile.sigv4a_signing_region_set ?? "").split(",").map((_) => _.trim());
}
throw new ProviderError("sigv4a_signing_region_set not set in profile.", {
tryNextLink: true
});
},
default: undefined
};
var bindResolveAwsSdkSigV4Config = (defaultDisableClockSkewCorrection) => (config) => {
let inputCredentials = config.credentials;
let isUserSupplied = !!config.credentials;
let resolvedCredentials = undefined;
Object.defineProperty(config, "credentials", {
set(credentials) {
if (credentials && credentials !== inputCredentials && credentials !== resolvedCredentials) {
isUserSupplied = true;
}
inputCredentials = credentials;
const memoizedProvider = normalizeCredentialProvider(config, {
credentials: inputCredentials,
credentialDefaultProvider: config.credentialDefaultProvider
});
const boundProvider = bindCallerConfig(config, memoizedProvider);
if (isUserSupplied && !boundProvider.attributed) {
const isCredentialObject = typeof inputCredentials === "object" && inputCredentials !== null;
resolvedCredentials = async (options) => {
const creds = await boundProvider(options);
const attributedCreds = creds;
if (isCredentialObject && (!attributedCreds.$source || Object.keys(attributedCreds.$source).length === 0)) {
return setCredentialFeature(attributedCreds, "CREDENTIALS_CODE", "e");
}
return attributedCreds;
};
resolvedCredentials.memoized = boundProvider.memoized;
resolvedCredentials.configBound = boundProvider.configBound;
resolvedCredentials.attributed = true;
} else {
resolvedCredentials = boundProvider;
}
},
get() {
return resolvedCredentials;
},
enumerable: true,
configurable: true
});
config.credentials = inputCredentials;
const { signingEscapePath = true, systemClockOffset = config.systemClockOffset || 0, sha256 } = config;
let signer;
if (config.signer) {
signer = normalizeProvider(config.signer);
} else if (config.regionInfoProvider) {
signer = () => normalizeProvider(config.region)().then(async (region) => [
await config.regionInfoProvider(region, {
useFipsEndpoint: await config.useFipsEndpoint(),
useDualstackEndpoint: await config.useDualstackEndpoint()
}) || {},
region
]).then(([regionInfo, region]) => {
const { signingRegion, signingService } = regionInfo;
config.signingRegion = config.signingRegion || signingRegion || region;
config.signingName = config.signingName || signingService || config.serviceId;
const params = {
...config,
credentials: config.credentials,
region: config.signingRegion,
service: config.signingName,
sha256,
uriEscapePath: signingEscapePath
};
const SignerCtor = config.signerConstructor || SignatureV4;
return new SignerCtor(params);
});
} else {
signer = async (authScheme) => {
authScheme = Object.assign({}, {
name: "sigv4",
signingName: config.signingName || config.defaultSigningName,
signingRegion: await normalizeProvider(config.region)(),
properties: {}
}, authScheme);
const signingRegion = authScheme.signingRegion;
const signingService = authScheme.signingName;
config.signingRegion = config.signingRegion || signingRegion;
config.signingName = config.signingName || signingService || config.serviceId;
const params = {
...config,
credentials: config.credentials,
region: config.signingRegion,
service: config.signingName,
sha256,
uriEscapePath: signingEscapePath
};
const SignerCtor = config.signerConstructor || SignatureV4;
return new SignerCtor(params);
};
}
const resolvedConfig = Object.assign(config, {
systemClockOffset,
signingEscapePath,
signer,
disableClockSkewCorrection: normalizeProvider(config.disableClockSkewCorrection ?? defaultDisableClockSkewCorrection)
});
return resolvedConfig;
};
function normalizeCredentialProvider(config, { credentials, credentialDefaultProvider }) {
let credentialsProvider;
if (credentials) {
if (!credentials?.memoized) {
credentialsProvider = memoizeIdentityProvider(credentials, isIdentityExpired, doesIdentityRequireRefresh);
} else {
credentialsProvider = credentials;
}
} else {
if (credentialDefaultProvider) {
credentialsProvider = normalizeProvider(credentialDefaultProvider(Object.assign({}, config, {
parentClientConfig: config
})));
} else {
credentialsProvider = async () => {
throw new Error("@aws-sdk/core::resolveAwsSdkSigV4Config - `credentials` not provided and no credentialDefaultProvider was configured.");
};
}
}
credentialsProvider.memoized = true;
return credentialsProvider;
}
function bindCallerConfig(config, credentialsProvider) {
if (credentialsProvider.configBound) {
return credentialsProvider;
}
const fn = async (options) => credentialsProvider({ ...options, callerClientConfig: config });
fn.memoized = credentialsProvider.memoized;
fn.configBound = true;
return fn;
}
var ENV_DISABLE_CLOCK_SKEW_CORRECTION = "AWS_DISABLE_CLOCK_SKEW_CORRECTION";
var CONFIG_DISABLE_CLOCK_SKEW_CORRECTION = "disable_clock_skew_correction";
var NODE_DISABLE_CLOCK_SKEW_CORRECTION_CONFIG_OPTIONS = {
environmentVariableSelector: (env) => booleanSelector(env, ENV_DISABLE_CLOCK_SKEW_CORRECTION, SelectorType.ENV),
configFileSelector: (profile) => booleanSelector(profile, CONFIG_DISABLE_CLOCK_SKEW_CORRECTION, SelectorType.CONFIG),
default: false
};
var DEFAULT_DISABLE_CLOCK_SKEW_CORRECTION = loadConfig(NODE_DISABLE_CLOCK_SKEW_CORRECTION_CONFIG_OPTIONS);
var resolveAwsSdkSigV4Config = bindResolveAwsSdkSigV4Config(DEFAULT_DISABLE_CLOCK_SKEW_CORRECTION);
var resolveAWSSDKSigV4Config = resolveAwsSdkSigV4Config;
exports.AWSSDKSigV4Signer = AWSSDKSigV4Signer;
exports.AwsSdkSigV4ASigner = AwsSdkSigV4ASigner;
exports.AwsSdkSigV4Signer = AwsSdkSigV4Signer;
exports.NODE_AUTH_SCHEME_PREFERENCE_OPTIONS = NODE_AUTH_SCHEME_PREFERENCE_OPTIONS;
exports.NODE_SIGV4A_CONFIG_OPTIONS = NODE_SIGV4A_CONFIG_OPTIONS;
exports.getBearerTokenEnvKey = getBearerTokenEnvKey;
exports.resolveAWSSDKSigV4Config = resolveAWSSDKSigV4Config;
exports.resolveAwsSdkSigV4AConfig = resolveAwsSdkSigV4AConfig;
exports.resolveAwsSdkSigV4Config = resolveAwsSdkSigV4Config;
exports.validateSigningProperties = validateSigningProperties;
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-env@3.972.70/node_modules/@aws-sdk/credential-provider-env/dist-es/fromEnv.js
var import_client4, import_config, ENV_KEY = "AWS_ACCESS_KEY_ID", ENV_SECRET = "AWS_SECRET_ACCESS_KEY", ENV_SESSION = "AWS_SESSION_TOKEN", ENV_EXPIRATION = "AWS_CREDENTIAL_EXPIRATION", ENV_CREDENTIAL_SCOPE = "AWS_CREDENTIAL_SCOPE", ENV_ACCOUNT_ID = "AWS_ACCOUNT_ID", fromEnv = (init) => async () => {
init?.logger?.debug("@aws-sdk/credential-provider-env - fromEnv");
const accessKeyId = process.env[ENV_KEY];
const secretAccessKey = process.env[ENV_SECRET];
const sessionToken = process.env[ENV_SESSION];
const expiry = process.env[ENV_EXPIRATION];
const credentialScope = process.env[ENV_CREDENTIAL_SCOPE];
const accountId = process.env[ENV_ACCOUNT_ID];
if (accessKeyId && secretAccessKey) {
const credentials = {
accessKeyId,
secretAccessKey,
...sessionToken && { sessionToken },
...expiry && { expiration: new Date(expiry) },
...credentialScope && { credentialScope },
...accountId && { accountId }
};
import_client4.setCredentialFeature(credentials, "CREDENTIALS_ENV_VARS", "g");
return credentials;
}
throw new import_config.CredentialsProviderError("Unable to find environment variable credentials.", { logger: init?.logger });
};
var init_fromEnv = __esm(() => {
import_client4 = __toESM(require_client2());
import_config = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-env@3.972.70/node_modules/@aws-sdk/credential-provider-env/dist-es/index.js
var init_dist_es = __esm(() => {
init_fromEnv();
});
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/remoteProvider/ImdsCredentials.js
var isImdsCredentials = (arg) => Boolean(arg) && typeof arg === "object" && typeof arg.AccessKeyId === "string" && typeof arg.SecretAccessKey === "string" && typeof arg.Token === "string" && typeof arg.Expiration === "string", fromImdsCredentials = (creds) => ({
accessKeyId: creds.AccessKeyId,
secretAccessKey: creds.SecretAccessKey,
sessionToken: creds.Token,
expiration: new Date(creds.Expiration),
...creds.AccountId && { accountId: creds.AccountId }
});
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/remoteProvider/RemoteProviderInit.js
var DEFAULT_TIMEOUT = 1000, DEFAULT_MAX_RETRIES = 0, providerConfigFromInit = ({ maxRetries = DEFAULT_MAX_RETRIES, timeout = DEFAULT_TIMEOUT }) => ({ maxRetries, timeout });
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/remoteProvider/node-http.js
import node_http from "http";
var init_node_http = () => {};
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/remoteProvider/httpRequest.js
function httpRequest(options) {
return new Promise((resolve, reject) => {
const req = node_http.request({
method: "GET",
...options,
hostname: options.hostname?.replace(/^\[(.+)\]$/, "$1")
});
req.on("error", (err) => {
reject(Object.assign(new import_config2.ProviderError("Unable to connect to instance metadata service"), err));
req.destroy();
});
req.on("timeout", () => {
reject(new import_config2.ProviderError("TimeoutError from instance metadata service"));
req.destroy();
});
req.on("response", (res) => {
const { statusCode = 400 } = res;
if (statusCode < 200 || 300 <= statusCode) {
reject(Object.assign(new import_config2.ProviderError("Error response received from instance metadata service"), { statusCode }));
req.destroy();
}
const chunks = [];
res.on("data", (chunk) => {
chunks.push(chunk);
});
res.on("end", () => {
resolve(Buffer.concat(chunks));
req.destroy();
});
});
req.end();
});
}
var import_config2;
var init_httpRequest = __esm(() => {
init_node_http();
import_config2 = __toESM(require_config());
});
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/remoteProvider/retry.js
var retry = (toRetry, maxRetries) => {
let promise = toRetry();
for (let i = 0;i < maxRetries; i++) {
promise = promise.catch(toRetry);
}
return promise;
};
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/fromContainerMetadata.js
var import_config3, ENV_CMDS_FULL_URI = "AWS_CONTAINER_CREDENTIALS_FULL_URI", ENV_CMDS_RELATIVE_URI = "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI", ENV_CMDS_AUTH_TOKEN = "AWS_CONTAINER_AUTHORIZATION_TOKEN", fromContainerMetadata = (init = {}) => {
const { timeout, maxRetries } = providerConfigFromInit(init);
return () => retry(async () => {
const requestOptions = await getCmdsUri({ logger: init.logger });
const credsResponse = JSON.parse(await requestFromEcsImds(timeout, requestOptions));
if (!isImdsCredentials(credsResponse)) {
throw new import_config3.CredentialsProviderError("Invalid response received from instance metadata service.", {
logger: init.logger
});
}
return fromImdsCredentials(credsResponse);
}, maxRetries);
}, requestFromEcsImds = async (timeout, options) => {
if (process.env[ENV_CMDS_AUTH_TOKEN]) {
options.headers = {
...options.headers,
Authorization: process.env[ENV_CMDS_AUTH_TOKEN]
};
}
const buffer = await httpRequest({
...options,
timeout
});
return buffer.toString();
}, CMDS_IP = "169.254.170.2", GREENGRASS_HOSTS, GREENGRASS_PROTOCOLS, getCmdsUri = async ({ logger }) => {
if (process.env[ENV_CMDS_RELATIVE_URI]) {
return {
hostname: CMDS_IP,
path: process.env[ENV_CMDS_RELATIVE_URI]
};
}
if (process.env[ENV_CMDS_FULL_URI]) {
let parsed;
try {
parsed = new URL(process.env[ENV_CMDS_FULL_URI]);
} catch {
throw new import_config3.CredentialsProviderError(`${process.env[ENV_CMDS_FULL_URI]} is not a valid container metadata service URL`, { tryNextLink: false, logger });
}
if (!parsed.hostname || !GREENGRASS_HOSTS.has(parsed.hostname)) {
throw new import_config3.CredentialsProviderError(`${parsed.hostname} is not a valid container metadata service hostname`, {
tryNextLink: false,
logger
});
}
if (!parsed.protocol || !GREENGRASS_PROTOCOLS.has(parsed.protocol)) {
throw new import_config3.CredentialsProviderError(`${parsed.protocol} is not a valid container metadata service protocol`, {
tryNextLink: false,
logger
});
}
return {
protocol: parsed.protocol,
hostname: parsed.hostname,
path: parsed.pathname + parsed.search,
port: parsed.port ? parseInt(parsed.port, 10) : undefined
};
}
throw new import_config3.CredentialsProviderError("The container metadata credential provider cannot be used unless" + ` the ${ENV_CMDS_RELATIVE_URI} or ${ENV_CMDS_FULL_URI} environment` + " variable is set", {
tryNextLink: false,
logger
});
};
var init_fromContainerMetadata = __esm(() => {
init_httpRequest();
import_config3 = __toESM(require_config());
GREENGRASS_HOSTS = new Set(["localhost", "127.0.0.1"]);
GREENGRASS_PROTOCOLS = new Set(["http:", "https:"]);
});
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/error/InstanceMetadataV1FallbackError.js
var import_config4, InstanceMetadataV1FallbackError;
var init_InstanceMetadataV1FallbackError = __esm(() => {
import_config4 = __toESM(require_config());
InstanceMetadataV1FallbackError = class InstanceMetadataV1FallbackError extends import_config4.CredentialsProviderError {
tryNextLink;
name = "InstanceMetadataV1FallbackError";
constructor(message, tryNextLink = true) {
super(message, tryNextLink);
this.tryNextLink = tryNextLink;
Object.setPrototypeOf(this, InstanceMetadataV1FallbackError.prototype);
}
};
});
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/config/Endpoint.js
var Endpoint;
var init_Endpoint = __esm(() => {
(function(Endpoint) {
Endpoint["IPv4"] = "http://169.254.169.254";
Endpoint["IPv6"] = "http://[fd00:ec2::254]";
})(Endpoint || (Endpoint = {}));
});
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/config/EndpointConfigOptions.js
var ENV_ENDPOINT_NAME = "AWS_EC2_METADATA_SERVICE_ENDPOINT", CONFIG_ENDPOINT_NAME = "ec2_metadata_service_endpoint", ENDPOINT_CONFIG_OPTIONS;
var init_EndpointConfigOptions = __esm(() => {
ENDPOINT_CONFIG_OPTIONS = {
environmentVariableSelector: (env) => env[ENV_ENDPOINT_NAME],
configFileSelector: (profile) => profile[CONFIG_ENDPOINT_NAME],
default: undefined
};
});
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/config/EndpointMode.js
var EndpointMode;
var init_EndpointMode = __esm(() => {
(function(EndpointMode) {
EndpointMode["IPv4"] = "IPv4";
EndpointMode["IPv6"] = "IPv6";
})(EndpointMode || (EndpointMode = {}));
});
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/config/EndpointModeConfigOptions.js
var ENV_ENDPOINT_MODE_NAME = "AWS_EC2_METADATA_SERVICE_ENDPOINT_MODE", CONFIG_ENDPOINT_MODE_NAME = "ec2_metadata_service_endpoint_mode", ENDPOINT_MODE_CONFIG_OPTIONS;
var init_EndpointModeConfigOptions = __esm(() => {
init_EndpointMode();
ENDPOINT_MODE_CONFIG_OPTIONS = {
environmentVariableSelector: (env) => env[ENV_ENDPOINT_MODE_NAME],
configFileSelector: (profile) => profile[CONFIG_ENDPOINT_MODE_NAME],
default: EndpointMode.IPv4
};
});
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/utils/getInstanceMetadataEndpoint.js
var import_config5, import_protocols, getInstanceMetadataEndpoint = async () => import_protocols.parseUrl(await getFromEndpointConfig() || await getFromEndpointModeConfig()), getFromEndpointConfig = async () => import_config5.loadConfig(ENDPOINT_CONFIG_OPTIONS)(), getFromEndpointModeConfig = async () => {
const endpointMode = await import_config5.loadConfig(ENDPOINT_MODE_CONFIG_OPTIONS)();
switch (endpointMode) {
case EndpointMode.IPv4:
return Endpoint.IPv4;
case EndpointMode.IPv6:
return Endpoint.IPv6;
default:
throw new Error(`Unsupported endpoint mode: ${endpointMode}.` + ` Select from ${Object.values(EndpointMode)}`);
}
};
var init_getInstanceMetadataEndpoint = __esm(() => {
init_Endpoint();
init_EndpointConfigOptions();
init_EndpointMode();
init_EndpointModeConfigOptions();
import_config5 = __toESM(require_config());
import_protocols = __toESM(require_protocols());
});
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/utils/getExtendedInstanceMetadataCredentials.js
var STATIC_STABILITY_REFRESH_INTERVAL_SECONDS, STATIC_STABILITY_REFRESH_INTERVAL_JITTER_WINDOW_SECONDS, STATIC_STABILITY_DOC_URL = "https://docs.aws.amazon.com/sdkref/latest/guide/feature-static-credentials.html", getExtendedInstanceMetadataCredentials = (credentials, logger) => {
const refreshInterval = STATIC_STABILITY_REFRESH_INTERVAL_SECONDS + Math.floor(Math.random() * STATIC_STABILITY_REFRESH_INTERVAL_JITTER_WINDOW_SECONDS);
const newExpiration = new Date(Date.now() + refreshInterval * 1000);
logger.warn("Attempting credential expiration extension due to a credential service availability issue. A refresh of these " + `credentials will be attempted after ${new Date(newExpiration)}.
For more information, please visit: ` + STATIC_STABILITY_DOC_URL);
const originalExpiration = credentials.originalExpiration ?? credentials.expiration;
return {
...credentials,
...originalExpiration ? { originalExpiration } : {},
expiration: newExpiration
};
};
var init_getExtendedInstanceMetadataCredentials = __esm(() => {
STATIC_STABILITY_REFRESH_INTERVAL_SECONDS = 5 * 60;
STATIC_STABILITY_REFRESH_INTERVAL_JITTER_WINDOW_SECONDS = 5 * 60;
});
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/utils/staticStabilityProvider.js
var staticStabilityProvider = (provider, options = {}) => {
const logger = options?.logger || console;
let pastCredentials;
return async () => {
let credentials;
try {
credentials = await provider();
if (credentials.expiration && credentials.expiration.getTime() < Date.now()) {
credentials = getExtendedInstanceMetadataCredentials(credentials, logger);
}
} catch (e) {
if (pastCredentials) {
logger.warn("Credential renew failed: ", e);
credentials = getExtendedInstanceMetadataCredentials(pastCredentials, logger);
} else {
throw e;
}
}
pastCredentials = credentials;
return credentials;
};
};
var init_staticStabilityProvider = __esm(() => {
init_getExtendedInstanceMetadataCredentials();
});
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/fromInstanceMetadata.js
var import_config6, IMDS_PATH = "/latest/meta-data/iam/security-credentials/", IMDS_TOKEN_PATH = "/latest/api/token", AWS_EC2_METADATA_V1_DISABLED = "AWS_EC2_METADATA_V1_DISABLED", PROFILE_AWS_EC2_METADATA_V1_DISABLED = "ec2_metadata_v1_disabled", X_AWS_EC2_METADATA_TOKEN = "x-aws-ec2-metadata-token", fromInstanceMetadata = (init = {}) => staticStabilityProvider(getInstanceMetadataProvider(init), { logger: init.logger }), getInstanceMetadataProvider = (init = {}) => {
let disableFetchToken = false;
const { logger, profile } = init;
const { timeout, maxRetries } = providerConfigFromInit(init);
const getCredentials = async (maxRetries, options) => {
const isImdsV1Fallback = disableFetchToken || options.headers?.[X_AWS_EC2_METADATA_TOKEN] == null;
if (isImdsV1Fallback) {
let fallbackBlockedFromProfile = false;
let fallbackBlockedFromProcessEnv = false;
const configValue = await import_config6.loadConfig({
environmentVariableSelector: (env) => {
const envValue = env[AWS_EC2_METADATA_V1_DISABLED];
fallbackBlockedFromProcessEnv = !!envValue && envValue !== "false";
if (envValue === undefined) {
throw new import_config6.CredentialsProviderError(`${AWS_EC2_METADATA_V1_DISABLED} not set in env, checking config file next.`, { logger: init.logger });
}
return fallbackBlockedFromProcessEnv;
},
configFileSelector: (profile) => {
const profileValue = profile[PROFILE_AWS_EC2_METADATA_V1_DISABLED];
fallbackBlockedFromProfile = !!profileValue && profileValue !== "false";
return fallbackBlockedFromProfile;
},
default: false
}, {
profile
})();
if (init.ec2MetadataV1Disabled || configValue) {
const causes = [];
if (init.ec2MetadataV1Disabled)
causes.push("credential provider initialization (runtime option ec2MetadataV1Disabled)");
if (fallbackBlockedFromProfile)
causes.push(`config file profile (${PROFILE_AWS_EC2_METADATA_V1_DISABLED})`);
if (fallbackBlockedFromProcessEnv)
causes.push(`process environment variable (${AWS_EC2_METADATA_V1_DISABLED})`);
throw new InstanceMetadataV1FallbackError(`AWS EC2 Metadata v1 fallback has been blocked by AWS SDK configuration in the following: [${causes.join(", ")}].`);
}
}
const imdsProfile = (await retry(async () => {
let profile;
try {
profile = await getProfile(options);
} catch (err) {
if (err.statusCode === 401) {
disableFetchToken = false;
}
throw err;
}
return profile;
}, maxRetries)).trim();
return retry(async () => {
let creds;
try {
creds = await getCredentialsFromProfile(imdsProfile, options, init);
} catch (err) {
if (err.statusCode === 401) {
disableFetchToken = false;
}
throw err;
}
return creds;
}, maxRetries);
};
return async () => {
const endpoint = await getInstanceMetadataEndpoint();
if (disableFetchToken) {
logger?.debug("AWS SDK Instance Metadata", "using v1 fallback (no token fetch)");
return getCredentials(maxRetries, { ...endpoint, timeout });
} else {
let token;
try {
token = (await getMetadataToken({ ...endpoint, timeout })).toString();
} catch (error) {
if (error?.statusCode === 400) {
throw Object.assign(error, {
message: "EC2 Metadata token request returned error"
});
} else if (error.message === "TimeoutError" || [403, 404, 405].includes(error.statusCode)) {
disableFetchToken = true;
}
logger?.debug("AWS SDK Instance Metadata", "using v1 fallback (initial)");
return getCredentials(maxRetries, { ...endpoint, timeout });
}
return getCredentials(maxRetries, {
...endpoint,
headers: {
[X_AWS_EC2_METADATA_TOKEN]: token
},
timeout
});
}
};
}, getMetadataToken = async (options) => httpRequest({
...options,
path: IMDS_TOKEN_PATH,
method: "PUT",
headers: {
"x-aws-ec2-metadata-token-ttl-seconds": "21600"
}
}), getProfile = async (options) => (await httpRequest({ ...options, path: IMDS_PATH })).toString(), getCredentialsFromProfile = async (profile, options, init) => {
const credentialsResponse = JSON.parse((await httpRequest({
...options,
path: IMDS_PATH + profile
})).toString());
if (!isImdsCredentials(credentialsResponse)) {
throw new import_config6.CredentialsProviderError("Invalid response received from instance metadata service.", {
logger: init.logger
});
}
return fromImdsCredentials(credentialsResponse);
};
var init_fromInstanceMetadata = __esm(() => {
init_InstanceMetadataV1FallbackError();
init_httpRequest();
init_getInstanceMetadataEndpoint();
init_staticStabilityProvider();
import_config6 = __toESM(require_config());
});
// ../../node_modules/.bun/@smithy+credential-provider-imds@4.5.2/node_modules/@smithy/credential-provider-imds/dist-es/index.js
var init_dist_es2 = __esm(() => {
init_fromContainerMetadata();
init_fromInstanceMetadata();
});
// ../../node_modules/.bun/@smithy+node-http-handler@4.12.1/node_modules/@smithy/node-http-handler/dist-cjs/index.js
var require_dist_cjs4 = __commonJS(function(exports) {
var { hasOwn } = require_serde();
var { streamCollector } = require_serde();
exports.streamCollector = streamCollector;
var { buildQueryString, HttpResponse } = require_protocols();
var node_https = __require("https");
var { Readable } = __require("stream");
var http2 = __require("http2");
function buildAbortError(abortSignal) {
const reason = abortSignal && typeof abortSignal === "object" && "reason" in abortSignal ? abortSignal.reason : undefined;
if (reason) {
if (reason instanceof Error) {
const abortError = new Error("Request aborted");
abortError.name = "AbortError";
abortError.cause = reason;
return abortError;
}
const abortError = new Error(String(reason));
abortError.name = "AbortError";
return abortError;
}
const abortError = new Error("Request aborted");
abortError.name = "AbortError";
return abortError;
}
var NODEJS_TIMEOUT_ERROR_CODES = ["ECONNRESET", "EPIPE", "ETIMEDOUT"];
var getTransformedHeaders = (headers) => {
const transformedHeaders = {};
for (const name in headers) {
if (!hasOwn(headers, name))
continue;
const headerValues = headers[name];
transformedHeaders[name] = Array.isArray(headerValues) ? headerValues.join(",") : headerValues;
}
return transformedHeaders;
};
var timing = {
setTimeout: (cb, ms) => setTimeout(cb, ms),
clearTimeout: (timeoutId) => clearTimeout(timeoutId)
};
var DEFER_EVENT_LISTENER_TIME$2 = 1000;
var setConnectionTimeout = (request, reject, timeoutInMs = 0) => {
if (!timeoutInMs) {
return -1;
}
const registerTimeout = (offset) => {
const timeoutId = timing.setTimeout(() => {
request.destroy();
reject(Object.assign(new Error(`@smithy/node-http-handler - the request socket did not establish a connection with the server within the configured timeout of ${timeoutInMs} ms.`), {
name: "TimeoutError"
}));
}, timeoutInMs - offset);
const doWithSocket = (socket) => {
if (socket?.connecting) {
socket.on("connect", () => {
timing.clearTimeout(timeoutId);
});
} else {
timing.clearTimeout(timeoutId);
}
};
if (request.socket) {
doWithSocket(request.socket);
} else {
request.on("socket", doWithSocket);
}
};
if (timeoutInMs < 2000) {
registerTimeout(0);
return 0;
}
return timing.setTimeout(registerTimeout.bind(null, DEFER_EVENT_LISTENER_TIME$2), DEFER_EVENT_LISTENER_TIME$2);
};
var setRequestTimeout = (req, reject, timeoutInMs = 0, throwOnRequestTimeout, logger) => {
if (timeoutInMs) {
return timing.setTimeout(() => {
let msg = `@smithy/node-http-handler - [${throwOnRequestTimeout ? "ERROR" : "WARN"}] a request has exceeded the configured ${timeoutInMs} ms requestTimeout.`;
if (throwOnRequestTimeout) {
const error = Object.assign(new Error(msg), {
name: "TimeoutError",
code: "ETIMEDOUT"
});
req.destroy(error);
reject(error);
} else {
msg += ` Init client requestHandler with throwOnRequestTimeout=true to turn this into an error.`;
logger?.warn?.(msg);
}
}, timeoutInMs);
}
return -1;
};
var DEFER_EVENT_LISTENER_TIME$1 = 3000;
var setSocketKeepAlive = (request, { keepAlive, keepAliveMsecs }, deferTimeMs = DEFER_EVENT_LISTENER_TIME$1) => {
if (keepAlive !== true) {
return -1;
}
const registerListener = () => {
if (request.socket) {
request.socket.setKeepAlive(keepAlive, keepAliveMsecs || 0);
} else {
request.on("socket", (socket) => {
socket.setKeepAlive(keepAlive, keepAliveMsecs || 0);
});
}
};
if (deferTimeMs === 0) {
registerListener();
return 0;
}
return timing.setTimeout(registerListener, deferTimeMs);
};
var DEFER_EVENT_LISTENER_TIME = 3000;
var setSocketTimeout = (request, reject, timeoutInMs = 0) => {
const registerTimeout = (offset) => {
const timeout = timeoutInMs - offset;
const onTimeout = () => {
request.destroy();
reject(Object.assign(new Error(`@smithy/node-http-handler - the request socket timed out after ${timeoutInMs} ms of inactivity (configured by client requestHandler).`), { name: "TimeoutError" }));
};
if (request.socket) {
request.socket.setTimeout(timeout, onTimeout);
request.on("close", () => request.socket?.removeListener("timeout", onTimeout));
} else {
request.setTimeout(timeout, onTimeout);
}
};
if (0 < timeoutInMs && timeoutInMs < 6000) {
registerTimeout(0);
return 0;
}
return timing.setTimeout(registerTimeout.bind(null, timeoutInMs === 0 ? 0 : DEFER_EVENT_LISTENER_TIME), DEFER_EVENT_LISTENER_TIME);
};
var MIN_WAIT_TIME = 6000;
async function writeRequestBody(httpRequest, request, maxContinueTimeoutMs = MIN_WAIT_TIME, externalAgent = false) {
const headers = request.headers;
const expect = headers ? headers.Expect || headers.expect : undefined;
let timeoutId = -1;
let sendBody = true;
if (!externalAgent && expect === "100-continue") {
sendBody = await Promise.race([
new Promise((resolve) => {
timeoutId = Number(timing.setTimeout(() => resolve(true), Math.max(MIN_WAIT_TIME, maxContinueTimeoutMs)));
}),
new Promise((resolve) => {
httpRequest.on("continue", () => {
timing.clearTimeout(timeoutId);
resolve(true);
});
httpRequest.on("response", () => {
timing.clearTimeout(timeoutId);
resolve(false);
});
httpRequest.on("error", () => {
timing.clearTimeout(timeoutId);
resolve(false);
});
})
]);
}
if (sendBody) {
writeBody(httpRequest, request.body);
}
}
function writeBody(httpRequest, body) {
if (body instanceof Readable) {
body.pipe(httpRequest);
return;
}
if (body) {
const isBuffer = Buffer.isBuffer(body);
const isString = typeof body === "string";
if (isBuffer || isString) {
if (isBuffer && body.byteLength === 0) {
httpRequest.end();
} else {
httpRequest.end(body);
}
return;
}
const uint8 = body;
if (typeof uint8 === "object" && uint8.buffer && typeof uint8.byteOffset === "number" && typeof uint8.byteLength === "number") {
httpRequest.end(Buffer.from(uint8.buffer, uint8.byteOffset, uint8.byteLength));
return;
}
httpRequest.end(Buffer.from(body));
return;
}
httpRequest.end();
}
var DEFAULT_REQUEST_TIMEOUT = 0;
var hAgent = undefined;
var hRequest = undefined;
class NodeHttpHandler {
config;
configProvider;
socketWarningTimestamp = 0;
externalAgent = false;
metadata = { handlerProtocol: "http/1.1" };
static create(instanceOrOptions) {
if (typeof instanceOrOptions?.handle === "function") {
return instanceOrOptions;
}
return new NodeHttpHandler(instanceOrOptions);
}
static checkSocketUsage(agent, socketWarningTimestamp, logger = console) {
const { sockets, requests, maxSockets } = agent;
if (typeof maxSockets !== "number" || maxSockets === Infinity) {
return socketWarningTimestamp;
}
const interval = 15000;
if (Date.now() - interval < socketWarningTimestamp) {
return socketWarningTimestamp;
}
if (sockets && requests) {
for (const origin in sockets) {
if (!hasOwn(sockets, origin))
continue;
const socketsInUse = sockets[origin]?.length ?? 0;
const requestsEnqueued = requests[origin]?.length ?? 0;
if (socketsInUse >= maxSockets && requestsEnqueued >= 2 * maxSockets) {
logger?.warn?.(`@smithy/node-http-handler:WARN - socket usage at capacity=${socketsInUse} and ${requestsEnqueued} additional requests are enqueued.
See https://docs.aws.amazon.com/sdk-for-javascript/v3/developer-guide/node-configuring-maxsockets.html
or increase socketAcquisitionWarningTimeout=(millis) in the NodeHttpHandler config.`);
return Date.now();
}
}
}
return socketWarningTimestamp;
}
constructor(options) {
this.configProvider = new Promise((resolve, reject) => {
if (typeof options === "function") {
options().then((_options) => {
resolve(this.resolveDefaultConfig(_options));
}).catch(reject);
} else {
resolve(this.resolveDefaultConfig(options));
}
});
}
destroy() {
this.config?.httpAgent?.destroy();
this.config?.httpsAgent?.destroy();
}
async handle(request2, { abortSignal, requestTimeout } = {}) {
if (!this.config) {
this.config = await this.configProvider;
}
const config = this.config;
const logger = config.logger;
const isSSL = request2.protocol === "https:";
if (!isSSL && !this.config.httpAgent) {
this.config.httpAgent = await this.config.httpAgentProvider();
}
return new Promise((_resolve, _reject) => {
let writeRequestBodyPromise = undefined;
let socketWarningTimeoutId = -1;
let connectionTimeoutId = -1;
let requestTimeoutId = -1;
let socketTimeoutId = -1;
let keepAliveTimeoutId = -1;
const clearTimeouts = () => {
timing.clearTimeout(socketWarningTimeoutId);
timing.clearTimeout(connectionTimeoutId);
timing.clearTimeout(requestTimeoutId);
timing.clearTimeout(socketTimeoutId);
timing.clearTimeout(keepAliveTimeoutId);
};
const resolve = async (arg) => {
await writeRequestBodyPromise;
clearTimeouts();
_resolve(arg);
};
const reject = async (arg) => {
await writeRequestBodyPromise;
clearTimeouts();
_reject(arg);
};
if (abortSignal?.aborted) {
const abortError = buildAbortError(abortSignal);
reject(abortError);
return;
}
const headers = request2.headers;
const expectContinue = headers ? (headers.Expect ?? headers.expect) === "100-continue" : false;
let agent = isSSL ? config.httpsAgent : config.httpAgent;
if (expectContinue && !this.externalAgent) {
agent = new (isSSL ? node_https.Agent : hAgent)({
keepAlive: false,
maxSockets: Infinity
});
}
socketWarningTimeoutId = timing.setTimeout(() => {
this.socketWarningTimestamp = NodeHttpHandler.checkSocketUsage(agent, this.socketWarningTimestamp, logger);
}, config.socketAcquisitionWarningTimeout ?? (config.requestTimeout ?? 2000) + (config.connectionTimeout ?? 1000));
const queryString = request2.query ? buildQueryString(request2.query) : "";
let auth = undefined;
if (request2.username != null || request2.password != null) {
const username = request2.username ?? "";
const password = request2.password ?? "";
auth = `${username}:${password}`;
}
let path = request2.path;
if (queryString) {
path += `?${queryString}`;
}
if (request2.fragment) {
path += `#${request2.fragment}`;
}
let hostname = request2.hostname ?? "";
if (hostname[0] === "[" && hostname.endsWith("]")) {
hostname = request2.hostname.slice(1, -1);
} else {
hostname = request2.hostname;
}
const nodeHttpsOptions = {
headers: request2.headers,
host: hostname,
method: request2.method,
path,
port: request2.port,
agent,
auth
};
const requestFunc = isSSL ? node_https.request : hRequest;
const req = requestFunc(nodeHttpsOptions, (res) => {
const httpResponse = new HttpResponse({
statusCode: res.statusCode || -1,
reason: res.statusMessage,
headers: getTransformedHeaders(res.headers),
body: res
});
resolve({ response: httpResponse });
});
req.on("error", (err) => {
if (NODEJS_TIMEOUT_ERROR_CODES.includes(err.code)) {
reject(Object.assign(err, { name: "TimeoutError" }));
} else {
reject(err);
}
});
if (abortSignal) {
const onAbort = () => {
req.destroy();
const abortError = buildAbortError(abortSignal);
reject(abortError);
};
if (typeof abortSignal.addEventListener === "function") {
const signal = abortSignal;
signal.addEventListener("abort", onAbort, { once: true });
req.once("close", () => signal.removeEventListener("abort", onAbort));
} else {
abortSignal.onabort = onAbort;
}
}
const effectiveRequestTimeout = requestTimeout ?? config.requestTimeout;
connectionTimeoutId = setConnectionTimeout(req, reject, config.connectionTimeout);
requestTimeoutId = setRequestTimeout(req, reject, effectiveRequestTimeout, config.throwOnRequestTimeout, logger ?? console);
socketTimeoutId = setSocketTimeout(req, reject, config.socketTimeout);
const httpAgent = nodeHttpsOptions.agent;
if (typeof httpAgent === "object" && "keepAlive" in httpAgent) {
keepAliveTimeoutId = setSocketKeepAlive(req, {
keepAlive: httpAgent.keepAlive,
keepAliveMsecs: httpAgent.keepAliveMsecs
});
}
writeRequestBodyPromise = writeRequestBody(req, request2, effectiveRequestTimeout, this.externalAgent).catch((e) => {
clearTimeouts();
return _reject(e);
});
});
}
updateHttpClientConfig(key, value) {
this.config = undefined;
this.configProvider = this.configProvider.then((config) => {
if (key === Symbol.for("logger")) {
return {
...config,
logger: config.logger ?? value
};
}
return {
...config,
[key]: value
};
});
}
httpHandlerConfigs() {
return this.config ?? {};
}
resolveDefaultConfig(options) {
const { requestTimeout, connectionTimeout, socketTimeout, socketAcquisitionWarningTimeout, httpAgent, httpsAgent, throwOnRequestTimeout, logger } = options || {};
const keepAlive = true;
const maxSockets = 50;
return {
connectionTimeout,
requestTimeout,
socketTimeout,
socketAcquisitionWarningTimeout,
throwOnRequestTimeout,
httpAgentProvider: async () => {
const node_http = __require("http");
const { Agent, request } = node_http.default ?? node_http;
hRequest = request;
hAgent = Agent;
if (httpAgent instanceof hAgent || typeof httpAgent?.destroy === "function") {
this.externalAgent = true;
return httpAgent;
}
return new hAgent({ keepAlive, maxSockets, ...httpAgent });
},
httpsAgent: (() => {
if (httpsAgent instanceof node_https.Agent || typeof httpsAgent?.destroy === "function") {
this.externalAgent = true;
return httpsAgent;
}
return new node_https.Agent({ keepAlive, maxSockets, ...httpsAgent });
})(),
logger
};
}
}
var ids = new Uint16Array(1);
class ClientHttp2SessionRef {
id = ids[0]++;
total = 0;
max = 0;
session;
refs = 0;
constructor(session) {
session.unref();
this.session = session;
}
retain() {
if (this.session.destroyed) {
throw new Error("@smithy/node-http-handler - cannot acquire reference to destroyed session.");
}
this.refs += 1;
this.total += 1;
this.max = Math.max(this.refs, this.max);
this.session.ref();
}
free() {
if (this.session.destroyed) {
return;
}
this.refs -= 1;
if (this.refs === 0) {
this.session.unref();
}
if (this.refs < 0) {
throw new Error("@smithy/node-http-handler - ClientHttp2Session refcount at zero, cannot decrement.");
}
}
deref() {
return this.session;
}
close() {
if (!this.session.closed) {
this.session.close();
}
}
destroy() {
this.refs = 0;
if (!this.session.destroyed) {
this.session.setTimeout(0);
this.session.destroy();
}
}
useCount() {
return this.refs;
}
}
class NodeHttp2ConnectionPool {
sessions = [];
maxConcurrency = 0;
constructor(sessions) {
this.sessions = (sessions ?? []).map((session) => new ClientHttp2SessionRef(session));
}
poll() {
let cleanup = false;
for (const session of this.sessions) {
if (session.deref().destroyed) {
cleanup = true;
continue;
}
if (!this.maxConcurrency || session.useCount() < this.maxConcurrency) {
return session;
}
}
if (cleanup) {
for (const session of this.sessions) {
if (session.deref().destroyed) {
this.remove(session);
}
}
}
}
offerLast(ref) {
this.sessions.push(ref);
}
remove(ref) {
const ix = this.sessions.indexOf(ref);
if (ix > -1) {
this.sessions.splice(ix, 1);
}
}
[Symbol.iterator]() {
return this.sessions[Symbol.iterator]();
}
setMaxConcurrency(maxConcurrency) {
this.maxConcurrency = maxConcurrency;
}
destroy(ref) {
this.remove(ref);
ref.destroy();
}
}
class NodeHttp2ConnectionManager {
config;
connectOptions;
connectionPools = new Map;
constructor(config) {
this.config = config;
if (this.config.maxConcurrency && this.config.maxConcurrency <= 0) {
throw new RangeError("maxConcurrency must be greater than zero.");
}
}
lease(requestContext, connectionConfiguration) {
const url = this.getUrlString(requestContext);
const pool = this.getPool(url);
if (!this.config.disableConcurrency && !connectionConfiguration.isEventStream) {
const available = pool.poll();
if (available) {
available.retain();
return available;
}
}
const ref = new ClientHttp2SessionRef(this.connect(url));
const session = ref.deref();
if (this.config.maxConcurrency) {
session.settings({ maxConcurrentStreams: this.config.maxConcurrency }, (err) => {
if (err) {
throw new Error("Fail to set maxConcurrentStreams to " + this.config.maxConcurrency + "when creating new session for " + requestContext.destination.toString());
}
});
}
const graceful = () => {
this.removeFromPoolAndClose(url, ref);
};
const ensureDestroyed = () => {
this.removeFromPoolAndCheckedDestroy(url, ref);
};
session.on("goaway", graceful);
session.on("error", ensureDestroyed);
session.on("frameError", ensureDestroyed);
session.on("close", ensureDestroyed);
if (connectionConfiguration.requestTimeout) {
session.setTimeout(connectionConfiguration.requestTimeout, ensureDestroyed);
}
pool.offerLast(ref);
ref.retain();
return ref;
}
release(_requestContext, ref) {
ref.free();
}
createIsolatedSession(requestContext, connectionConfiguration) {
const url = this.getUrlString(requestContext);
const ref = new ClientHttp2SessionRef(this.connect(url));
const session = ref.deref();
session.settings({ maxConcurrentStreams: 1 });
const ensureDestroyed = () => {
ref.destroy();
};
session.on("error", ensureDestroyed);
session.on("frameError", ensureDestroyed);
session.on("close", ensureDestroyed);
const timeout = connectionConfiguration.requestTimeout ?? 300000;
session.setTimeout(timeout, ensureDestroyed);
ref.retain();
return ref;
}
destroy() {
for (const [url, connectionPool] of this.connectionPools) {
for (const session of [...connectionPool]) {
session.destroy();
}
this.connectionPools.delete(url);
}
}
setMaxConcurrentStreams(maxConcurrentStreams) {
if (maxConcurrentStreams && maxConcurrentStreams <= 0) {
throw new RangeError("maxConcurrentStreams must be greater than zero.");
}
this.config.maxConcurrency = maxConcurrentStreams;
for (const pool of this.connectionPools.values()) {
pool.setMaxConcurrency(maxConcurrentStreams);
}
}
setDisableConcurrentStreams(disableConcurrentStreams) {
this.config.disableConcurrency = disableConcurrentStreams;
}
setNodeHttp2ConnectOptions(nodeHttp2ConnectOptions) {
this.connectOptions = nodeHttp2ConnectOptions;
}
debug() {
const pools = {};
for (const [url, pool] of this.connectionPools) {
const sessions = [];
for (const ref of pool) {
sessions.push({
id: ref.id,
active: ref.useCount(),
maxConcurrent: ref.max,
totalRequests: ref.total
});
}
pools[url] = { sessions };
}
return pools;
}
removeFromPoolAndClose(authority, ref) {
this.connectionPools.get(authority)?.remove(ref);
ref.close();
}
removeFromPoolAndCheckedDestroy(authority, ref) {
this.connectionPools.get(authority)?.remove(ref);
ref.destroy();
}
getPool(url) {
if (!this.connectionPools.has(url)) {
const pool = new NodeHttp2ConnectionPool;
if (this.config.maxConcurrency) {
pool.setMaxConcurrency(this.config.maxConcurrency);
}
this.connectionPools.set(url, pool);
}
return this.connectionPools.get(url);
}
getUrlString(request) {
return request.destination.toString();
}
connect(url) {
return this.connectOptions === undefined ? http2.connect(url) : http2.connect(url, this.connectOptions);
}
}
var { constants } = http2;
class NodeHttp2Handler {
config;
configProvider;
metadata = { handlerProtocol: "h2" };
connectionManager = new NodeHttp2ConnectionManager({});
static create(instanceOrOptions) {
if (typeof instanceOrOptions?.handle === "function") {
return instanceOrOptions;
}
return new NodeHttp2Handler(instanceOrOptions);
}
constructor(options) {
this.configProvider = new Promise((resolve, reject) => {
if (typeof options === "function") {
options().then((opts) => {
resolve(opts || {});
}).catch(reject);
} else {
resolve(options || {});
}
});
}
destroy() {
this.connectionManager.destroy();
}
async handle(request, { abortSignal, requestTimeout, isEventStream } = {}) {
if (!this.config) {
this.config = await this.configProvider;
const { disableConcurrentStreams, maxConcurrentStreams, nodeHttp2ConnectOptions } = this.config;
this.connectionManager.setDisableConcurrentStreams(disableConcurrentStreams ?? false);
if (maxConcurrentStreams) {
this.connectionManager.setMaxConcurrentStreams(maxConcurrentStreams);
}
if (nodeHttp2ConnectOptions) {
this.connectionManager.setNodeHttp2ConnectOptions(nodeHttp2ConnectOptions);
}
}
const { requestTimeout: configRequestTimeout, disableConcurrentStreams } = this.config;
const useIsolatedSession = disableConcurrentStreams || isEventStream;
const effectiveRequestTimeout = requestTimeout ?? configRequestTimeout;
return new Promise((_resolve, _reject) => {
let fulfilled = false;
let writeRequestBodyPromise = undefined;
const resolve = async (arg) => {
await writeRequestBodyPromise;
_resolve(arg);
};
const reject = async (arg) => {
await writeRequestBodyPromise;
_reject(arg);
};
if (abortSignal?.aborted) {
fulfilled = true;
const abortError = buildAbortError(abortSignal);
reject(abortError);
return;
}
const { hostname, method, port, protocol, query } = request;
let auth = "";
if (request.username != null || request.password != null) {
const username = request.username ?? "";
const password = request.password ?? "";
auth = `${username}:${password}@`;
}
const authority = `${protocol}//${auth}${hostname}${port ? `:${port}` : ""}`;
const requestContext = { destination: new URL(authority) };
const connectConfig = {
requestTimeout: this.config?.sessionTimeout,
isEventStream
};
const ref = useIsolatedSession ? this.connectionManager.createIsolatedSession(requestContext, connectConfig) : this.connectionManager.lease(requestContext, connectConfig);
const session = ref.deref();
const rejectWithDestroy = (err) => {
if (useIsolatedSession) {
ref.destroy();
}
fulfilled = true;
reject(err);
};
const queryString = query ? buildQueryString(query) : "";
let path = request.path;
if (queryString) {
path += `?${queryString}`;
}
if (request.fragment) {
path += `#${request.fragment}`;
}
const clientHttp2Stream = session.request({
...request.headers,
[constants.HTTP2_HEADER_PATH]: path,
[constants.HTTP2_HEADER_METHOD]: method
});
if (effectiveRequestTimeout) {
clientHttp2Stream.setTimeout(effectiveRequestTimeout, () => {
clientHttp2Stream.close();
const timeoutError = new Error(`Stream timed out because of no activity for ${effectiveRequestTimeout} ms`);
timeoutError.name = "TimeoutError";
rejectWithDestroy(timeoutError);
});
}
if (abortSignal) {
const onAbort = () => {
clientHttp2Stream.close();
const abortError = buildAbortError(abortSignal);
rejectWithDestroy(abortError);
};
if (typeof abortSignal.addEventListener === "function") {
const signal = abortSignal;
signal.addEventListener("abort", onAbort, { once: true });
clientHttp2Stream.once("close", () => signal.removeEventListener("abort", onAbort));
} else {
abortSignal.onabort = onAbort;
}
}
clientHttp2Stream.on("frameError", (type, code, id) => {
rejectWithDestroy(new Error(`Frame type id ${type} in stream id ${id} has failed with code ${code}.`));
});
clientHttp2Stream.on("error", rejectWithDestroy);
clientHttp2Stream.on("aborted", () => {
rejectWithDestroy(new Error(`HTTP/2 stream is abnormally aborted in mid-communication with result code ${clientHttp2Stream.rstCode}.`));
});
clientHttp2Stream.on("response", (headers) => {
const httpResponse = new HttpResponse({
statusCode: headers[":status"] ?? -1,
headers: getTransformedHeaders(headers),
body: clientHttp2Stream
});
fulfilled = true;
resolve({ response: httpResponse });
if (useIsolatedSession) {
session.close();
clientHttp2Stream.on("end", () => {
ref.destroy();
});
}
});
clientHttp2Stream.on("close", () => {
if (useIsolatedSession) {
ref.destroy();
} else {
this.connectionManager.release(requestContext, ref);
}
if (!fulfilled) {
const error = new Error("Unexpected error: http2 request did not get a response");
if (session.destroyed) {
error.name = "TimeoutError";
}
rejectWithDestroy(error);
}
});
writeRequestBodyPromise = writeRequestBody(clientHttp2Stream, request, effectiveRequestTimeout);
});
}
updateHttpClientConfig(key, value) {
this.config = undefined;
this.configProvider = this.configProvider.then((config) => {
return {
...config,
[key]: value
};
});
}
httpHandlerConfigs() {
return this.config ?? {};
}
}
exports.DEFAULT_REQUEST_TIMEOUT = DEFAULT_REQUEST_TIMEOUT;
exports.NodeHttp2Handler = NodeHttp2Handler;
exports.NodeHttpHandler = NodeHttpHandler;
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-http@3.972.72/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/checkUrl.js
var import_config7, ECS_CONTAINER_HOST = "169.254.170.2", EKS_CONTAINER_HOST_IPv4 = "169.254.170.23", EKS_CONTAINER_HOST_IPv6 = "[fd00:ec2::23]", checkUrl = (url, logger) => {
if (url.protocol === "https:") {
return;
}
if (url.hostname === ECS_CONTAINER_HOST || url.hostname === EKS_CONTAINER_HOST_IPv4 || url.hostname === EKS_CONTAINER_HOST_IPv6) {
return;
}
if (url.hostname.includes("[")) {
if (url.hostname === "[::1]" || url.hostname === "[0000:0000:0000:0000:0000:0000:0000:0001]") {
return;
}
} else {
if (url.hostname === "localhost") {
return;
}
const ipComponents = url.hostname.split(".");
const inRange = (component) => {
const num = parseInt(component, 10);
return 0 <= num && num <= 255;
};
if (ipComponents[0] === "127" && inRange(ipComponents[1]) && inRange(ipComponents[2]) && inRange(ipComponents[3]) && ipComponents.length === 4) {
return;
}
}
throw new import_config7.CredentialsProviderError(`URL not accepted. It must either be HTTPS or match one of the following:
- loopback CIDR 127.0.0.0/8 or [::1/128]
- ECS container host 169.254.170.2
- EKS container host 169.254.170.23 or [fd00:ec2::23]`, { logger });
};
var init_checkUrl = __esm(() => {
import_config7 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-http@3.972.72/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/requestHelpers.js
function createGetRequest(url) {
return new import_protocols2.HttpRequest({
protocol: url.protocol,
hostname: url.hostname,
port: Number(url.port),
path: url.pathname,
query: Array.from(url.searchParams.entries()).reduce((acc, [k, v]) => {
acc[k] = v;
return acc;
}, {}),
fragment: url.hash
});
}
async function getCredentials2(response, logger) {
const stream = import_serde2.sdkStreamMixin(response.body);
const str = await stream.transformToString();
if (response.statusCode === 200) {
const parsed = JSON.parse(str);
if (typeof parsed.AccessKeyId !== "string" || typeof parsed.SecretAccessKey !== "string" || typeof parsed.Token !== "string" || typeof parsed.Expiration !== "string") {
throw new import_config8.CredentialsProviderError("HTTP credential provider response not of the required format, an object matching: " + "{ AccessKeyId: string, SecretAccessKey: string, Token: string, Expiration: string(rfc3339) }", { logger });
}
return {
accessKeyId: parsed.AccessKeyId,
secretAccessKey: parsed.SecretAccessKey,
sessionToken: parsed.Token,
expiration: import_serde.parseRfc3339DateTime(parsed.Expiration)
};
}
if (response.statusCode >= 400 && response.statusCode < 500) {
let parsedBody = {};
try {
parsedBody = JSON.parse(str);
} catch (e) {}
throw Object.assign(new import_config8.CredentialsProviderError(`Server responded with status: ${response.statusCode}`, { logger }), {
Code: parsedBody.Code,
Message: parsedBody.Message
});
}
throw new import_config8.CredentialsProviderError(`Server responded with status: ${response.statusCode}`, { logger });
}
var import_config8, import_protocols2, import_serde, import_serde2;
var init_requestHelpers = __esm(() => {
import_config8 = __toESM(require_config());
import_protocols2 = __toESM(require_protocols());
import_serde = __toESM(require_serde());
import_serde2 = __toESM(require_serde());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-http@3.972.72/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/retry-wrapper.js
var retryWrapper = (toRetry, maxRetries, delayMs) => {
return async () => {
for (let i = 0;i < maxRetries; ++i) {
try {
return await toRetry();
} catch (e) {
await new Promise((resolve) => setTimeout(resolve, delayMs));
}
}
return await toRetry();
};
};
// ../../node_modules/.bun/@aws-sdk+credential-provider-http@3.972.72/node_modules/@aws-sdk/credential-provider-http/dist-es/fromHttp/fromHttp.js
import fs from "fs/promises";
var import_client5, import_config9, import_node_http_handler, AWS_CONTAINER_CREDENTIALS_RELATIVE_URI = "AWS_CONTAINER_CREDENTIALS_RELATIVE_URI", DEFAULT_LINK_LOCAL_HOST = "http://169.254.170.2", AWS_CONTAINER_CREDENTIALS_FULL_URI = "AWS_CONTAINER_CREDENTIALS_FULL_URI", AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE = "AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE", AWS_CONTAINER_AUTHORIZATION_TOKEN = "AWS_CONTAINER_AUTHORIZATION_TOKEN", fromHttp = (options = {}) => {
options.logger?.debug("@aws-sdk/credential-provider-http - fromHttp");
let host;
const relative = options.awsContainerCredentialsRelativeUri ?? process.env[AWS_CONTAINER_CREDENTIALS_RELATIVE_URI];
const full = options.awsContainerCredentialsFullUri ?? process.env[AWS_CONTAINER_CREDENTIALS_FULL_URI];
const token = options.awsContainerAuthorizationToken ?? process.env[AWS_CONTAINER_AUTHORIZATION_TOKEN];
const tokenFile = options.awsContainerAuthorizationTokenFile ?? process.env[AWS_CONTAINER_AUTHORIZATION_TOKEN_FILE];
const warn = options.logger?.constructor?.name === "NoOpLogger" || !options.logger?.warn ? console.warn : options.logger.warn.bind(options.logger);
if (relative && full) {
warn("@aws-sdk/credential-provider-http: " + "you have set both awsContainerCredentialsRelativeUri and awsContainerCredentialsFullUri.");
warn("awsContainerCredentialsRelativeUri will take precedence.");
}
if (token && tokenFile) {
warn("@aws-sdk/credential-provider-http: " + "you have set both awsContainerAuthorizationToken and awsContainerAuthorizationTokenFile.");
warn("awsContainerAuthorizationTokenFile will take precedence.");
}
if (relative) {
host = `${DEFAULT_LINK_LOCAL_HOST}${relative}`;
} else if (full) {
host = full;
} else {
throw new import_config9.CredentialsProviderError(`No HTTP credential provider host provided.
Set AWS_CONTAINER_CREDENTIALS_FULL_URI or AWS_CONTAINER_CREDENTIALS_RELATIVE_URI.`, { logger: options.logger });
}
const url = new URL(host);
checkUrl(url, options.logger);
const requestHandler = import_node_http_handler.NodeHttpHandler.create({ connectionTimeout: options.timeout ?? 1000 });
const requestTimeout = options.timeout ?? 1000;
const provider = retryWrapper(async () => {
const request = createGetRequest(url);
if (tokenFile) {
request.headers.Authorization = validateToken((await fs.readFile(tokenFile)).toString());
} else if (token) {
request.headers.Authorization = validateToken(token);
}
try {
const result = await requestHandler.handle(request, { requestTimeout });
return getCredentials2(result.response).then((creds) => import_client5.setCredentialFeature(creds, "CREDENTIALS_HTTP", "z"));
} catch (e) {
throw new import_config9.CredentialsProviderError(String(e), { logger: options.logger });
}
}, options.maxRetries ?? 3, options.timeout ?? 1000);
return async () => {
try {
return await provider();
} finally {
requestHandler.destroy?.();
}
};
}, validateToken = (token) => {
if (token.includes(`\r
`)) {
throw new import_config9.CredentialsProviderError("Authorization token contains invalid \\r\\n sequence.");
}
return token;
};
var init_fromHttp = __esm(() => {
init_checkUrl();
init_requestHelpers();
import_client5 = __toESM(require_client2());
import_config9 = __toESM(require_config());
import_node_http_handler = __toESM(require_dist_cjs4());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-http@3.972.72/node_modules/@aws-sdk/credential-provider-http/dist-es/index.js
var init_dist_es3 = __esm(() => {
init_fromHttp();
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-sso@3.973.14/node_modules/@aws-sdk/credential-provider-sso/dist-es/isSsoProfile.js
var isSsoProfile = (arg) => arg && (typeof arg.sso_start_url === "string" || typeof arg.sso_account_id === "string" || typeof arg.sso_session === "string" || typeof arg.sso_region === "string" || typeof arg.sso_role_name === "string");
// ../../node_modules/.bun/@aws-sdk+token-providers@3.1116.0/node_modules/@aws-sdk/token-providers/dist-es/constants.js
var EXPIRE_WINDOW_MS, REFRESH_MESSAGE = `To refresh this SSO session run 'aws sso login' with the corresponding profile.`;
var init_constants = __esm(() => {
EXPIRE_WINDOW_MS = 5 * 60 * 1000;
});
// ../../node_modules/.bun/@smithy+core@3.33.3/node_modules/@smithy/core/dist-cjs/submodules/cbor/index.js
var require_cbor = __commonJS(function(exports) {
var { nv, NumericValue, calculateBodyLength, generateIdempotencyToken, fromBase64, _parseEpochTimestamp } = require_serde();
var { hasOwn, getSmithyContext } = require_transport();
var { HttpRequest, collectBody, SerdeContext, RpcProtocol } = require_protocols();
var { NormalizedSchema, deref, TypeRegistry } = require_schema();
var majorUint64 = 0;
var majorNegativeInt64 = 1;
var majorUnstructuredByteString = 2;
var majorUtf8String = 3;
var majorList = 4;
var majorMap = 5;
var majorTag = 6;
var majorSpecial = 7;
var specialFalse = 20;
var specialTrue = 21;
var specialNull = 22;
var specialUndefined = 23;
var extendedOneByte = 24;
var extendedFloat16 = 25;
var extendedFloat32 = 26;
var extendedFloat64 = 27;
var minorIndefinite = 31;
function alloc(size) {
return typeof Buffer !== "undefined" ? Buffer.alloc(size) : new Uint8Array(size);
}
var tagSymbol = Symbol("@smithy/core/cbor::tagSymbol");
function tag(data) {
data[tagSymbol] = true;
return data;
}
var USE_BUFFER$3 = typeof Buffer !== "undefined";
var textDecoder$1 = new TextDecoder;
var payload$1 = alloc(0);
var isBuffer$1 = false;
var dataView$2 = new DataView(payload$1.buffer, payload$1.byteOffset, payload$1.byteLength);
var _offset = 0;
function setPayload(bytes) {
payload$1 = bytes;
isBuffer$1 = USE_BUFFER$3 && payload$1 instanceof Buffer;
dataView$2 = new DataView(payload$1.buffer, payload$1.byteOffset, payload$1.byteLength);
}
function decode(at, to) {
if (at >= to) {
throw new Error("unexpected end of (decode) payload.");
}
const major = (payload$1[at] & 224) >> 5;
const minor = payload$1[at] & 31;
if (minor === minorIndefinite && 2 <= major && major <= 5) {
return decodeIndefinite(at, to);
}
switch (major) {
case majorUint64:
case majorNegativeInt64:
case majorTag: {
let unsignedInt;
let offset;
if (minor < 24) {
unsignedInt = minor;
offset = 1;
} else {
switch (minor) {
case extendedOneByte:
if (to - at < 2) {
overflow$1(1);
}
unsignedInt = payload$1[at + 1];
offset = 2;
break;
case extendedFloat16:
if (to - at < 3) {
overflow$1(2);
}
unsignedInt = dataView$2.getUint16(at + 1);
offset = 3;
break;
case extendedFloat32:
if (to - at < 5) {
overflow$1(4);
}
unsignedInt = dataView$2.getUint32(at + 1);
offset = 5;
break;
case extendedFloat64:
if (to - at < 9) {
overflow$1(8);
}
{
const hi = dataView$2.getUint32(at + 1);
if (hi < 2097152) {
unsignedInt = hi * 4294967296 + dataView$2.getUint32(at + 5);
} else {
unsignedInt = dataView$2.getBigUint64(at + 1);
}
}
offset = 9;
break;
default:
unexpectedMinor(minor);
}
}
if (major === majorUint64) {
_offset = offset;
return castBigInt$1(unsignedInt);
} else if (major === majorNegativeInt64) {
let negativeInt;
if (typeof unsignedInt === "bigint") {
negativeInt = BigInt(-1) - unsignedInt;
} else {
negativeInt = -1 - unsignedInt;
}
_offset = offset;
return castBigInt$1(negativeInt);
} else {
return decodeTagValue(at, to, minor, unsignedInt, offset);
}
}
case majorUtf8String:
return decodeUtf8String(at, to);
case majorMap:
return decodeMap(at, to);
case majorList:
return decodeList(at, to);
case majorUnstructuredByteString:
return decodeUnstructuredByteString(at, to);
default:
return decodeSpecial(at, to);
}
}
function decodeIndefinite(at, to) {
const major = (payload$1[at] & 224) >> 5;
const minor = payload$1[at] & 31;
if (minor === minorIndefinite) {
switch (major) {
case majorUtf8String:
return decodeUtf8StringIndefinite(at, to);
case majorMap:
return decodeMapIndefinite(at, to);
case majorList:
return decodeListIndefinite(at, to);
case majorUnstructuredByteString:
return decodeUnstructuredByteStringIndefinite(at, to);
}
}
}
function bytesToFloat16$1(a, b) {
const sign = a >> 7;
const exponent = (a & 124) >> 2;
const fraction = (a & 3) << 8 | b;
const scalar = sign === 0 ? 1 : -1;
if (exponent === 0) {
if (fraction === 0) {
return 0;
}
return scalar * (Math.pow(2, 1 - 15) * (fraction / 1024));
} else if (exponent === 31) {
if (fraction === 0) {
return scalar * Infinity;
}
return NaN;
}
return scalar * (Math.pow(2, exponent - 15) * (1 + fraction / 1024));
}
function decodeMap(at, to) {
const mapDataLength = decodeCount$1(at, to);
if (mapDataLength < 25) {
return decodeMapSmall(at, to, mapDataLength);
}
return decodeMapLarge(at, to, mapDataLength);
}
function decodeMapLarge(at, to, mapDataLength) {
const offset = _offset;
at += offset;
const base = at;
const map = Object.create(null);
for (let i = 0;i < mapDataLength; ++i) {
const key = decodeUtf8String(at, to);
at += _offset;
const valMajor = (payload$1[at] & 224) >> 5;
if (valMajor === majorUtf8String) {
map[key] = decodeUtf8String(at, to);
} else {
map[key] = decode(at, to);
}
at += _offset;
}
_offset = offset + (at - base);
Object.setPrototypeOf(map, Object.prototype);
return map;
}
function decodeMapSmall(at, to, mapDataLength) {
const offset = _offset;
at += offset;
const base = at;
const map = {};
for (let i = 0;i < mapDataLength; ++i) {
const key = decodeUtf8String(at, to);
at += _offset;
map[key] = decode(at, to);
at += _offset;
}
_offset = offset + (at - base);
return map;
}
function decodeList(at, to) {
const listDataLength = decodeCount$1(at, to);
const offset = _offset;
at += offset;
const base = at;
const list = Array(listDataLength);
for (let i = 0;i < listDataLength; ++i) {
list[i] = decode(at, to);
at += _offset;
}
_offset = offset + (at - base);
return list;
}
function decodeUtf8String(at, to) {
const length = decodeCount$1(at, to);
const offset = _offset;
at += offset;
if (to - at < length) {
overflow$1(length);
}
_offset = offset + length;
if (length < 24) {
return decodeUtf8StringCached(at, length);
}
if (isBuffer$1) {
return payload$1.toString("utf-8", at, at + length);
}
return textDecoder$1.decode(payload$1.subarray(at, at + length));
}
var stringCache$1 = new Array(2048);
var stringCacheEpochs$1 = new Uint16Array(2048);
var cacheEpoch$1 = 0;
function advanceDecodingEpoch() {
cacheEpoch$1 = cacheEpoch$1 + 1 & 65535;
}
function decodeUtf8StringCached(at, length) {
let h = length;
for (let i = 0;i < length; ++i) {
h = h * 31 + payload$1[at + i] | 0;
}
const slot = h >>> 0 & 2047;
const cached = stringCache$1[slot];
if (cached !== undefined) {
if (cached.length === length) {
let match = true;
for (let i = 0;i < length; ++i) {
if (cached.charCodeAt(i) !== payload$1[at + i]) {
match = false;
break;
}
}
if (match) {
stringCacheEpochs$1[slot] = cacheEpoch$1;
return cached;
}
}
}
const result = isBuffer$1 ? payload$1.toString("utf-8", at, at + length) : textDecoder$1.decode(payload$1.subarray(at, at + length));
if (stringCacheEpochs$1[slot] !== cacheEpoch$1) {
stringCache$1[slot] = result;
stringCacheEpochs$1[slot] = cacheEpoch$1;
}
return result;
}
function decodeUnstructuredByteString(at, to) {
const length = decodeCount$1(at, to);
const offset = _offset;
at += offset;
if (to - at < length) {
overflow$1(length);
}
const value = payload$1.subarray(at, at + length);
_offset = offset + length;
return value;
}
function decodeTagValue(at, to, minor, unsignedInt, offset) {
if (minor === 2 || minor === 3) {
const length = decodeCount$1(at + offset, to);
let b = BigInt(0);
const start = at + offset + _offset;
for (let i = start;i < start + length; ++i) {
b = b << BigInt(8) | BigInt(payload$1[i]);
}
_offset = offset + _offset + length;
return minor === 3 ? -b - BigInt(1) : b;
} else if (minor === 4) {
const decimalFraction = decode(at + offset, to);
const [rawExponent, mantissa] = decimalFraction;
const normalizer = mantissa < 0 ? -1 : 1;
const absMantissa = BigInt(normalizer) * BigInt(mantissa);
const mantissaDigits = String(absMantissa);
const sign = mantissa < 0 ? "-" : "";
let numericString;
const isSmallExponent = typeof rawExponent === "number" && Math.abs(rawExponent) <= 2 ** 28;
if (isSmallExponent) {
const exponent = rawExponent;
const mantissaStr = "0".repeat(Math.abs(exponent) + 1) + mantissaDigits;
numericString = exponent === 0 ? mantissaStr : mantissaStr.slice(0, mantissaStr.length + exponent) + "." + mantissaStr.slice(exponent);
numericString = numericString.replace(/^0+/g, "");
if (numericString === "") {
numericString = "0";
}
if (numericString[0] === ".") {
numericString = "0" + numericString;
}
numericString = sign + numericString;
} else {
const bigExponent = BigInt(rawExponent);
if (mantissaDigits.length === 1) {
numericString = sign + mantissaDigits + "e" + String(bigExponent);
} else {
const adjustedExp = bigExponent + BigInt(mantissaDigits.length - 1);
numericString = sign + mantissaDigits[0] + "." + mantissaDigits.slice(1) + "e" + String(adjustedExp);
}
}
_offset = offset + _offset;
return nv(numericString);
} else {
const value = decode(at + offset, to);
const valueOffset = _offset;
_offset = offset + valueOffset;
return tag({ tag: castBigInt$1(unsignedInt), value });
}
}
function decodeSpecial(at, to) {
const minor = payload$1[at] & 31;
switch (minor) {
case specialTrue:
case specialFalse:
_offset = 1;
return minor === specialTrue;
case specialNull:
_offset = 1;
return null;
case specialUndefined:
_offset = 1;
return null;
case extendedFloat16:
if (to - at < 3) {
throw new Error("incomplete float16 at end of buf.");
}
_offset = 3;
return bytesToFloat16$1(payload$1[at + 1], payload$1[at + 2]);
case extendedFloat32:
if (to - at < 5) {
throw new Error("incomplete float32 at end of buf.");
}
_offset = 5;
return dataView$2.getFloat32(at + 1);
case extendedFloat64:
if (to - at < 9) {
throw new Error("incomplete float64 at end of buf.");
}
_offset = 9;
return dataView$2.getFloat64(at + 1);
default:
unexpectedMinor(minor);
}
}
function decodeCount$1(at, to) {
const minor = payload$1[at] & 31;
if (minor < 24) {
_offset = 1;
return minor;
}
switch (minor) {
case extendedOneByte:
if (to - at < 2) {
overflow$1(1);
}
_offset = 2;
return payload$1[at + 1];
case extendedFloat16:
if (to - at < 3) {
overflow$1(2);
}
_offset = 3;
return dataView$2.getUint16(at + 1);
case extendedFloat32:
if (to - at < 5) {
overflow$1(4);
}
_offset = 5;
return dataView$2.getUint32(at + 1);
case extendedFloat64:
if (to - at < 9) {
overflow$1(8);
}
_offset = 9;
return demote(dataView$2.getBigUint64(at + 1));
default:
unexpectedMinor(minor);
}
}
function decodeMapIndefinite(at, to) {
at += 1;
const base = at;
const map = {};
for (;at < to; ) {
if (payload$1[at] === 255) {
_offset = at - base + 2;
return map;
}
const key = decodeUtf8String(at, to);
at += _offset;
map[key] = decode(at, to);
at += _offset;
}
throw new Error("expected break marker.");
}
function decodeListIndefinite(at, to) {
at += 1;
const list = [];
for (const base = at;at < to; ) {
if (payload$1[at] === 255) {
_offset = at - base + 2;
return list;
}
list.push(decode(at, to));
at += _offset;
}
throw new Error("expected break marker.");
}
function decodeUtf8StringIndefinite(at, to) {
at += 1;
const vector = [];
for (const base = at;at < to; ) {
if (payload$1[at] === 255) {
const data = alloc(vector.length);
data.set(vector, 0);
_offset = at - base + 2;
if (USE_BUFFER$3) {
return data.toString("utf-8", 0, data.length);
}
return textDecoder$1.decode(data);
}
const major = (payload$1[at] & 224) >> 5;
const minor = payload$1[at] & 31;
if (major !== majorUtf8String) {
unexpectedMajorInIndefiniteString(major);
}
if (minor === minorIndefinite) {
throw new Error("nested indefinite string.");
}
const bytes = decodeUnstructuredByteString(at, to);
const length = _offset;
at += length;
for (let i = 0;i < bytes.length; ++i) {
vector.push(bytes[i]);
}
}
throw new Error("expected break marker.");
}
function decodeUnstructuredByteStringIndefinite(at, to) {
at += 1;
const vector = [];
for (const base = at;at < to; ) {
if (payload$1[at] === 255) {
const data = alloc(vector.length);
data.set(vector, 0);
_offset = at - base + 2;
return data;
}
const major = (payload$1[at] & 224) >> 5;
const minor = payload$1[at] & 31;
if (major !== majorUnstructuredByteString) {
unexpectedMajorInIndefiniteString(major);
}
if (minor === minorIndefinite) {
throw new Error("nested indefinite string.");
}
const bytes = decodeUnstructuredByteString(at, to);
const length = _offset;
at += length;
for (let i = 0;i < bytes.length; ++i) {
vector.push(bytes[i]);
}
}
throw new Error("expected break marker.");
}
function castBigInt$1(bigInt) {
if (typeof bigInt === "number") {
return bigInt;
}
const num = Number(bigInt);
if (Number.MIN_SAFE_INTEGER <= num && num <= Number.MAX_SAFE_INTEGER) {
return num;
}
return bigInt;
}
function demote(bigInteger) {
const num = Number(bigInteger);
if (num < Number.MIN_SAFE_INTEGER || Number.MAX_SAFE_INTEGER < num) {
console.warn(new Error(`@smithy/core/cbor - truncating BigInt(${bigInteger}) to ${num} with loss of precision.`));
}
return num;
}
function overflow$1(n) {
throw new Error(`length ${n} greater than remaining buf len.`);
}
function unexpectedMinor(minor) {
throw new Error(`unexpected minor value ${minor}.`);
}
function unexpectedMajorInIndefiniteString(major) {
throw new Error(`unexpected major type ${major} in indefinite string.`);
}
var USE_BUFFER$2 = typeof Buffer !== "undefined";
var encodeStringCache = new Map;
var encodeCacheEpoch$1 = 0;
var encodeCacheSaturated$1 = false;
var initialSize = 2048;
var data = alloc(initialSize);
var dataView$1 = new DataView(data.buffer, data.byteOffset, data.byteLength);
var cursor$1 = 0;
function encode(_input) {
const encodeStack = [_input];
while (encodeStack.length) {
const input = encodeStack.pop();
if (typeof input === "string") {
const len = input.length;
if (USE_BUFFER$2) {
ensureSpace(len * 3 + 9);
if (len > 23) {
encodeHeader$1(majorUtf8String, Buffer.byteLength(input));
cursor$1 += data.write(input, cursor$1);
} else {
encodeStringCached(input);
}
} else {
const maxBytes = len * 3;
ensureSpace(maxBytes + 9);
const headerPos = cursor$1;
const result = new TextEncoder().encodeInto(input, data.subarray(cursor$1 + 9));
const byteLen = result.written;
let headerSize;
if (byteLen < 24) {
headerSize = 1;
} else if (byteLen < 256) {
headerSize = 2;
} else if (byteLen < 65536) {
headerSize = 3;
} else if (byteLen < 4294967296) {
headerSize = 5;
} else {
headerSize = 9;
}
if (headerSize < 9) {
data.copyWithin(headerPos + headerSize, headerPos + 9, headerPos + 9 + byteLen);
}
cursor$1 = headerPos;
encodeInteger(majorUtf8String, byteLen);
cursor$1 += byteLen;
}
continue;
}
if (data.byteLength - cursor$1 < 9) {
ensureSpace(64);
}
if (typeof input === "number") {
if (Number.isInteger(input) && input >= -9007199254740992 && input <= 9007199254740991) {
const nonNegative = input >= 0;
const major = nonNegative ? majorUint64 : majorNegativeInt64;
const value = nonNegative ? input : -input - 1;
if (value < 24) {
data[cursor$1++] = major << 5 | value;
} else if (value < 256) {
data[cursor$1++] = major << 5 | 24;
data[cursor$1++] = value;
} else if (value < 65536) {
data[cursor$1++] = major << 5 | extendedFloat16;
data[cursor$1++] = value >> 8;
data[cursor$1++] = value & 255;
} else if (value < 4294967296) {
data[cursor$1++] = major << 5 | extendedFloat32;
dataView$1.setUint32(cursor$1, value);
cursor$1 += 4;
} else {
data[cursor$1++] = major << 5 | extendedFloat64;
const hi = value / 4294967296 | 0;
const lo = value - hi * 4294967296 | 0;
dataView$1.setUint32(cursor$1, hi);
dataView$1.setUint32(cursor$1 + 4, lo);
cursor$1 += 8;
}
continue;
}
data[cursor$1++] = majorSpecial << 5 | extendedFloat64;
dataView$1.setFloat64(cursor$1, input);
cursor$1 += 8;
continue;
} else if (typeof input === "bigint") {
const nonNegative = input >= 0;
const major = nonNegative ? majorUint64 : majorNegativeInt64;
const value = nonNegative ? input : -input - BigInt(1);
if (value < BigInt("18446744073709551616")) {
const n = Number(value);
if (n < 4294967296) {
encodeInteger(major, n);
} else {
data[cursor$1++] = major << 5 | extendedFloat64;
dataView$1.setBigUint64(cursor$1, value);
cursor$1 += 8;
}
} else {
const binaryBigInt = value.toString(2);
const bigIntBytes = new Uint8Array(Math.ceil(binaryBigInt.length / 8));
let b = value;
let i = 0;
while (bigIntBytes.byteLength - ++i >= 0) {
bigIntBytes[bigIntBytes.byteLength - i] = Number(b & BigInt(255));
b >>= BigInt(8);
}
ensureSpace(bigIntBytes.byteLength * 2 + 16);
data[cursor$1++] = nonNegative ? 194 : 195;
encodeHeader$1(majorUnstructuredByteString, bigIntBytes.byteLength);
data.set(bigIntBytes, cursor$1);
cursor$1 += bigIntBytes.byteLength;
}
continue;
} else if (input === null) {
data[cursor$1++] = majorSpecial << 5 | specialNull;
continue;
} else if (typeof input === "boolean") {
data[cursor$1++] = majorSpecial << 5 | (input ? specialTrue : specialFalse);
continue;
} else if (typeof input === "undefined") {
throw new Error("@smithy/core/cbor: client may not serialize undefined value.");
} else if (Array.isArray(input)) {
encodeInteger(majorList, input.length);
ensureSpace(input.length * 9 + 64);
for (let i = input.length - 1;i >= 0; --i) {
encodeStack.push(input[i]);
}
continue;
} else if (typeof input.byteLength === "number") {
ensureSpace(input.length * 2 + 9);
encodeInteger(majorUnstructuredByteString, input.length);
data.set(input, cursor$1);
cursor$1 += input.byteLength;
continue;
} else if (typeof input === "object") {
if (input instanceof NumericValue) {
let str = input.string;
let expOffset = BigInt(0);
const eIndex = str.search(/[eE]/);
if (eIndex !== -1) {
expOffset = BigInt(str.slice(eIndex + 1));
str = str.slice(0, eIndex);
}
const decimalIndex = str.indexOf(".");
const fractionDigits = decimalIndex === -1 ? 0 : str.length - decimalIndex - 1;
const exponent = expOffset - BigInt(fractionDigits);
const mantissa = BigInt(str.replace(".", ""));
data[cursor$1++] = 196;
encodeInteger(majorList, 2);
encodeStack.push(mantissa);
encodeStack.push(exponent >= -0x20000000000000n && exponent <= 0x1fffffffffffffn ? Number(exponent) : exponent);
continue;
}
if (input[tagSymbol]) {
if ("tag" in input && "value" in input) {
encodeStack.push(input.value);
encodeHeader$1(majorTag, input.tag);
continue;
} else {
throw new Error("tag encountered with missing fields, need 'tag' and 'value', found: " + JSON.stringify(input));
}
}
const keys = Object.keys(input);
const len = keys.length;
encodeInteger(majorMap, len);
for (let i = len - 1;i >= 0; --i) {
encodeStack.push(input[keys[i]]);
encodeStack.push(keys[i]);
}
continue;
}
throw new Error(`data type ${input?.constructor?.name ?? typeof input} not compatible for encoding.`);
}
}
function advanceEncodingEpoch() {
encodeCacheEpoch$1 = encodeCacheEpoch$1 + 1 & 65535;
encodeCacheSaturated$1 = false;
}
function toUint8Array() {
const out = alloc(cursor$1);
out.set(data.subarray(0, cursor$1), 0);
cursor$1 = 0;
return out;
}
function resize(size) {
const old = data;
data = alloc(size);
if (old) {
if (old.copy) {
old.copy(data, 0, 0, old.byteLength);
} else {
data.set(old, 0);
}
}
dataView$1 = new DataView(data.buffer, data.byteOffset, data.byteLength);
}
function encodeStringCached(input) {
const cached = encodeStringCache.get(input);
if (cached !== undefined) {
data.set(cached.bytes, cursor$1);
cursor$1 += cached.bytes.length;
cached.epoch = encodeCacheEpoch$1;
return;
}
const start = cursor$1;
const byteLen = Buffer.byteLength(input);
encodeInteger(majorUtf8String, byteLen);
cursor$1 += data.write(input, cursor$1);
const bytes = Uint8Array.prototype.slice.call(data, start, cursor$1);
if (encodeStringCache.size >= 2048) {
if (encodeCacheSaturated$1) {
return;
}
let evicted = 0;
for (const [key, entry] of encodeStringCache) {
if (evicted >= 1024) {
break;
}
if (entry.epoch !== encodeCacheEpoch$1) {
encodeStringCache.delete(key);
evicted++;
}
}
if (evicted === 0) {
encodeCacheSaturated$1 = true;
return;
}
}
if (encodeStringCache.size < 2048) {
encodeStringCache.set(input, { epoch: encodeCacheEpoch$1, bytes });
}
}
function ensureSpace(bytes) {
const remaining = data.byteLength - cursor$1;
if (remaining < bytes) {
if (cursor$1 < 16000000) {
resize(Math.max(data.byteLength * 4, data.byteLength + bytes));
} else {
resize(data.byteLength + bytes + 16000000);
}
}
}
function encodeHeader$1(major, value) {
if (value < 24) {
data[cursor$1++] = major << 5 | value;
} else if (value < 256) {
data[cursor$1++] = major << 5 | 24;
data[cursor$1++] = value;
} else if (value < 65536) {
data[cursor$1++] = major << 5 | extendedFloat16;
dataView$1.setUint16(cursor$1, value);
cursor$1 += 2;
} else if (value < 4294967296) {
data[cursor$1++] = major << 5 | extendedFloat32;
dataView$1.setUint32(cursor$1, value);
cursor$1 += 4;
} else {
data[cursor$1++] = major << 5 | extendedFloat64;
dataView$1.setBigUint64(cursor$1, typeof value === "bigint" ? value : BigInt(value));
cursor$1 += 8;
}
}
function encodeInteger(major, value) {
if (value < 24) {
data[cursor$1++] = major << 5 | value;
} else if (value < 256) {
data[cursor$1++] = major << 5 | 24;
data[cursor$1++] = value;
} else if (value < 65536) {
data[cursor$1++] = major << 5 | extendedFloat16;
data[cursor$1++] = value >> 8;
data[cursor$1++] = value & 255;
} else if (value < 4294967296) {
data[cursor$1++] = major << 5 | extendedFloat32;
dataView$1.setUint32(cursor$1, value);
cursor$1 += 4;
} else {
data[cursor$1++] = major << 5 | extendedFloat64;
const hi = value / 4294967296 | 0;
const lo = value - hi * 4294967296 | 0;
dataView$1.setUint32(cursor$1, hi);
dataView$1.setUint32(cursor$1 + 4, lo);
cursor$1 += 8;
}
}
var cbor = {
deserialize(payload) {
advanceDecodingEpoch();
setPayload(payload);
return decode(0, payload.length);
},
serialize(input) {
advanceEncodingEpoch();
try {
encode(input);
return toUint8Array();
} catch (e) {
toUint8Array();
throw e;
}
},
resizeEncodingBuffer(size) {
resize(size);
}
};
var parseCborBody = (streamBody, context) => {
return collectBody(streamBody, context).then(async (bytes) => {
if (bytes.length) {
try {
return cbor.deserialize(bytes);
} catch (e) {
Object.defineProperty(e, "$responseBodyText", {
value: context.utf8Encoder(bytes)
});
throw e;
}
}
return {};
});
};
var dateToTag = (date) => {
return tag({
tag: 1,
value: date.getTime() / 1000
});
};
var parseCborErrorBody = async (errorBody, context) => {
const value = await parseCborBody(errorBody, context);
value.message = value.message ?? value.Message;
return value;
};
var loadSmithyRpcV2CborErrorCode = (output, data) => {
const sanitizeErrorCode = (rawValue) => {
let cleanValue = rawValue;
if (typeof cleanValue === "number") {
cleanValue = cleanValue.toString();
}
if (cleanValue.indexOf(",") >= 0) {
cleanValue = cleanValue.split(",")[0];
}
if (cleanValue.indexOf(":") >= 0) {
cleanValue = cleanValue.split(":")[0];
}
if (cleanValue.indexOf("#") >= 0) {
cleanValue = cleanValue.split("#")[1];
}
return cleanValue;
};
if (data["__type"] !== undefined) {
return sanitizeErrorCode(data["__type"]);
}
let codeKey;
for (const key in data) {
if (!hasOwn(data, key))
continue;
if (key.toLowerCase() === "code") {
codeKey = key;
break;
}
}
if (codeKey && data[codeKey] !== undefined) {
return sanitizeErrorCode(data[codeKey]);
}
};
var checkCborResponse = (response) => {
if (String(response.headers["smithy-protocol"]).toLowerCase() !== "rpc-v2-cbor") {
throw new Error("Malformed RPCv2 CBOR response, status: " + response.statusCode);
}
};
var buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
const endpoint = await context.endpoint();
const { hostname, protocol = "https", port, path: basePath } = endpoint;
const contents = {
protocol,
hostname,
port,
method: "POST",
path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
headers: {
...headers
}
};
if (resolvedHostname !== undefined) {
contents.hostname = resolvedHostname;
}
if (endpoint.headers) {
for (const name in endpoint.headers) {
if (!hasOwn(endpoint.headers, name))
continue;
contents.headers[name] = endpoint.headers[name];
}
}
if (body !== undefined) {
contents.body = body;
try {
contents.headers["content-length"] = String(calculateBodyLength(body));
} catch (ignored) {}
}
return new HttpRequest(contents);
};
class CborShapeSerializer2 extends SerdeContext {
write(schema, value) {
cursor = 0;
const ns = NormalizedSchema.of(schema);
writeValue(ns, value, undefined, this.serdeContext);
}
flush() {
const result = buf.subarray(0, cursor);
cursor = 0;
buf = allocUnsafe(INITIAL_BUFFER_SIZE);
view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
return result;
}
}
var CBOR_STRUCT_CACHE = Symbol.for("@smithy/cbor-struct-cache");
function loadCborStructIterator(ns) {
const schema = ns.getSchema();
const existing = schema[CBOR_STRUCT_CACHE];
if (existing) {
return existing;
}
const memberNames = [];
const memberSchemas = [];
for (const [name, memberSchema] of ns.structIterator()) {
memberNames.push(name);
memberSchemas.push(memberSchema);
}
const encodedKeys = new Array(memberNames.length);
for (let i = 0;i < memberNames.length; ++i) {
encodedKeys[i] = encodeCborStringKey(memberNames[i]);
}
const cache = { memberNames, memberSchemas, encodedKeys };
schema[CBOR_STRUCT_CACHE] = cache;
return cache;
}
function encodeCborStringKey(s) {
let utf8Bytes;
if (USE_BUFFER$1) {
utf8Bytes = Buffer.from(s, "utf-8");
} else {
utf8Bytes = new TextEncoder().encode(s);
}
const byteLen = utf8Bytes.length;
let headerSize;
if (byteLen < 24) {
headerSize = 1;
} else if (byteLen < 256) {
headerSize = 2;
} else {
headerSize = 3;
}
const result = new Uint8Array(headerSize + byteLen);
if (headerSize === 1) {
result[0] = majorUtf8String << 5 | byteLen;
} else if (headerSize === 2) {
result[0] = majorUtf8String << 5 | 24;
result[1] = byteLen;
} else {
result[0] = majorUtf8String << 5 | extendedFloat16;
result[1] = byteLen >> 8;
result[2] = byteLen & 255;
}
result.set(utf8Bytes, headerSize);
return result;
}
var USE_BUFFER$1 = typeof Buffer !== "undefined";
var textEncoder = new TextEncoder;
var INITIAL_BUFFER_SIZE = 2048;
var buf = USE_BUFFER$1 ? Buffer.allocUnsafe(INITIAL_BUFFER_SIZE) : new Uint8Array(INITIAL_BUFFER_SIZE);
var view = new DataView(buf.buffer, buf.byteOffset, buf.byteLength);
var cursor = 0;
var STRING_CACHE_MAX = 2048;
var stringEncodeCache = new Map;
var encodeCacheEpoch = 0;
var encodeCacheSaturated = false;
function allocUnsafe(size) {
return USE_BUFFER$1 ? Buffer.allocUnsafe(size) : new Uint8Array(size);
}
function writeValue(ns, value, container, serdeContext) {
if (value == null) {
if (value === undefined && ns.isIdempotencyToken()) {
writeString(generateIdempotencyToken());
return;
}
ensure(1);
buf[cursor++] = majorSpecial << 5 | specialNull;
return;
}
if (ns.isUnitSchema()) {
ensure(1);
encodeHeader(majorMap, 0);
return;
}
const isObject = typeof value === "object";
if (isObject) {
if (ns.isBlobSchema()) {
if (value instanceof Uint8Array) {
writeBytes(value);
return;
}
}
if (ns.isTimestampSchema()) {
if (value instanceof Date) {
writeTimestamp(value);
return;
}
}
if (ns.isStructSchema()) {
writeStruct(ns, value, serdeContext);
return;
}
if (Array.isArray(value) && (ns.isListSchema() || ns.isDocumentSchema())) {
writeList(ns, value, ns.isDocumentSchema(), serdeContext);
return;
}
if (ns.isMapSchema()) {
writeMap(ns, value, false, serdeContext);
return;
}
if (value instanceof Date) {
writeTimestamp(value);
return;
}
if (value instanceof Uint8Array) {
writeBytes(value);
return;
}
if (value instanceof NumericValue) {
writeNumericValue(value);
return;
}
if (value[tagSymbol]) {
const tagged = value;
writeTag(tagged.tag, tagged.value);
return;
}
if (ns.isDocumentSchema()) {
if (Array.isArray(value)) {
writeList(ns, value, true, serdeContext);
} else {
writeMap(ns, value, true, serdeContext);
}
return;
}
if (ns.isBigDecimalSchema()) {
writeUntypedValue(value);
return;
}
writeMap(ns, value, true, serdeContext);
return;
}
if (typeof value === "string") {
if (ns.isBlobSchema()) {
const bytes = (serdeContext?.base64Decoder ?? fromBase64)(value);
writeBytes(bytes);
return;
}
writeString(value);
return;
}
if (typeof value === "number") {
ensure(9);
if (Number.isInteger(value) && value >= -9007199254740992 && value <= 9007199254740991) {
writeInteger(value);
} else {
writeFloat64(value);
}
return;
}
if (typeof value === "boolean") {
ensure(1);
buf[cursor++] = majorSpecial << 5 | (value ? specialTrue : specialFalse);
return;
}
if (typeof value === "bigint") {
writeBigInt(value);
return;
}
writeString(String(value));
}
function writeStruct(ns, value, serdeContext) {
if (ns.isUnionSchema()) {
let wrote = false;
for (const [memberName, memberSchema] of ns.structIterator()) {
const item = value[memberName];
if (item != null) {
ensure(9);
encodeHeader(majorMap, 1);
writeString(memberName);
writeValue(memberSchema, item, ns, serdeContext);
wrote = true;
break;
}
}
if (!wrote) {
const { $unknown } = value;
if (Array.isArray($unknown)) {
ensure(9);
encodeHeader(majorMap, 1);
writeString($unknown[0]);
writeUntypedValue($unknown[1]);
} else {
ensure(9);
encodeHeader(majorMap, 0);
}
}
return;
}
const cache = loadCborStructIterator(ns);
const { memberNames, memberSchemas, encodedKeys } = cache;
const z = memberNames.length;
let headerSize;
if (z < 24) {
headerSize = 1;
} else if (z < 256) {
headerSize = 2;
} else {
headerSize = 3;
}
ensure(headerSize);
const headerPos = cursor;
cursor += headerSize;
let count = 0;
for (let i = 0;i < z; ++i) {
const item = value[memberNames[i]];
if (item == null && !memberSchemas[i].isIdempotencyToken()) {
continue;
}
const key = encodedKeys[i];
ensure(key.length);
buf.set(key, cursor);
cursor += key.length;
writeValue(memberSchemas[i], item, ns, serdeContext);
++count;
}
if (typeof value.__type === "string") {
for (const k in value) {
if (!hasOwn(value, k))
continue;
if (!memberNames.includes(k)) {
writeString(k);
writeUntypedValue(value[k]);
++count;
}
}
}
if (headerSize === 1) {
buf[headerPos] = majorMap << 5 | count;
} else if (headerSize === 2) {
buf[headerPos] = majorMap << 5 | 24;
buf[headerPos + 1] = count;
} else {
buf[headerPos] = majorMap << 5 | extendedFloat16;
buf[headerPos + 1] = count >> 8;
buf[headerPos + 2] = count & 255;
}
}
function writeList(ns, value, isDocument, serdeContext) {
const sparse = !!ns.getMergedTraits().sparse;
const valueSchema = ns.getValueSchema();
if (isDocument || sparse) {
const items = [];
for (let i = 0;i < value.length; ++i) {
const item = value[i];
if (isDocument) {
if (item !== undefined) {
items.push(item);
}
} else {
if (item != null || sparse) {
items.push(item);
}
}
}
ensure(9);
encodeHeader(majorList, items.length);
for (let i = 0;i < items.length; ++i) {
writeValue(valueSchema, items[i], undefined, serdeContext);
}
} else {
let count = 0;
for (let i = 0;i < value.length; ++i) {
if (value[i] != null) {
++count;
}
}
ensure(9);
encodeHeader(majorList, count);
for (let i = 0;i < value.length; ++i) {
if (value[i] != null) {
writeValue(valueSchema, value[i], undefined, serdeContext);
}
}
}
}
function writeMap(ns, value, isDocument, serdeContext) {
const sparse = !!ns.getMergedTraits().sparse;
const valueSchema = ns.getValueSchema();
const keys = [];
for (const k in value) {
if (!hasOwn(value, k))
continue;
const v = value[k];
if (isDocument ? v !== undefined : v != null || sparse) {
keys.push(k);
}
}
ensure(9);
encodeHeader(majorMap, keys.length);
for (let i = 0;i < keys.length; ++i) {
const k = keys[i];
writeString(k);
writeValue(valueSchema, value[k], undefined, serdeContext);
}
}
function writeUntypedValue(value) {
if (value == null) {
ensure(1);
buf[cursor++] = majorSpecial << 5 | specialNull;
return;
}
if (typeof value === "string") {
writeString(value);
return;
}
if (typeof value === "number") {
ensure(9);
if (Number.isInteger(value) && value >= -9007199254740992 && value <= 9007199254740991) {
writeInteger(value);
} else {
writeFloat64(value);
}
return;
}
if (typeof value === "boolean") {
ensure(1);
buf[cursor++] = majorSpecial << 5 | (value ? specialTrue : specialFalse);
return;
}
if (typeof value === "bigint") {
writeBigInt(value);
return;
}
if (value instanceof Uint8Array) {
writeBytes(value);
return;
}
if (value instanceof Date) {
writeTimestamp(value);
return;
}
if (value instanceof NumericValue) {
writeNumericValue(value);
return;
}
if (value[tagSymbol]) {
const tagged = value;
writeTag(tagged.tag, tagged.value);
return;
}
if (Array.isArray(value)) {
ensure(9);
encodeHeader(majorList, value.length);
for (let i = 0;i < value.length; ++i) {
writeUntypedValue(value[i]);
}
return;
}
if (typeof value === "object") {
const keys = Object.keys(value);
ensure(9);
encodeHeader(majorMap, keys.length);
for (let i = 0;i < keys.length; ++i) {
writeString(keys[i]);
writeUntypedValue(value[keys[i]]);
}
return;
}
writeString(String(value));
}
function ensure(n) {
if (cursor + n > buf.length) {
let newSize = buf.length * 2;
while (newSize < cursor + n) {
newSize *= 2;
}
const next = allocUnsafe(newSize);
next.set(buf.subarray(0, cursor));
buf = next;
view = new DataView(next.buffer, next.byteOffset, next.byteLength);
}
}
function encodeHeader(major, value) {
if (value < 24) {
buf[cursor++] = major << 5 | value;
} else if (value < 256) {
buf[cursor++] = major << 5 | 24;
buf[cursor++] = value;
} else if (value < 65536) {
buf[cursor++] = major << 5 | extendedFloat16;
buf[cursor++] = value >> 8;
buf[cursor++] = value & 255;
} else if (value < 4294967296) {
buf[cursor++] = major << 5 | extendedFloat32;
view.setUint32(cursor, value);
cursor += 4;
} else {
buf[cursor++] = major << 5 | extendedFloat64;
const hi = value / 4294967296 | 0;
const lo = value - hi * 4294967296 | 0;
view.setUint32(cursor, hi);
view.setUint32(cursor + 4, lo);
cursor += 8;
}
}
function encodeBigHeader(major, value) {
const n = Number(value);
if (n < 4294967296) {
encodeHeader(major, n);
return;
}
buf[cursor++] = major << 5 | extendedFloat64;
view.setBigUint64(cursor, value);
cursor += 8;
}
function writeString(s) {
const len = s.length;
if (len <= 23) {
const cached = stringEncodeCache.get(s);
if (cached) {
ensure(cached.bytes.length);
buf.set(cached.bytes, cursor);
cursor += cached.bytes.length;
cached.epoch = encodeCacheEpoch;
return;
}
const start = cursor;
writeStringUncached(s, len);
const end = cursor;
const bytes = Uint8Array.prototype.slice.call(buf, start, end);
if (stringEncodeCache.size >= STRING_CACHE_MAX) {
if (encodeCacheSaturated) {
return;
}
let evicted = 0;
for (const [key, entry] of stringEncodeCache) {
if (evicted >= 1024) {
break;
}
if (entry.epoch !== encodeCacheEpoch) {
stringEncodeCache.delete(key);
++evicted;
}
}
if (evicted === 0) {
encodeCacheSaturated = true;
return;
}
}
if (stringEncodeCache.size < STRING_CACHE_MAX) {
stringEncodeCache.set(s, { epoch: encodeCacheEpoch, bytes });
}
return;
}
writeStringUncached(s, len);
}
function writeStringUncached(s, len) {
if (USE_BUFFER$1) {
const maxBytes = len * 3;
ensure(maxBytes + 9);
const byteLen = Buffer.byteLength(s);
encodeHeader(majorUtf8String, byteLen);
cursor += buf.write(s, cursor);
} else {
const maxBytes = len * 3;
ensure(maxBytes + 9);
const headerPos = cursor;
const result = textEncoder.encodeInto(s, buf.subarray(headerPos + 9));
const byteLen = result.written;
let headerSize;
if (byteLen < 24) {
headerSize = 1;
} else if (byteLen < 256) {
headerSize = 2;
} else if (byteLen < 65536) {
headerSize = 3;
} else if (byteLen < 4294967296) {
headerSize = 5;
} else {
headerSize = 9;
}
if (headerSize < 9) {
buf.copyWithin(headerPos + headerSize, headerPos + 9, headerPos + 9 + byteLen);
}
cursor = headerPos;
encodeHeader(majorUtf8String, byteLen);
cursor += byteLen;
}
}
function writeFloat64(value) {
ensure(9);
buf[cursor++] = majorSpecial << 5 | extendedFloat64;
view.setFloat64(cursor, value);
cursor += 8;
}
function writeInteger(value) {
ensure(9);
const nonNegative = value >= 0;
const major = nonNegative ? majorUint64 : majorNegativeInt64;
const abs = nonNegative ? value : -value - 1;
encodeHeader(major, abs);
}
function writeBigInt(value) {
const nonNegative = value >= 0;
const major = nonNegative ? majorUint64 : majorNegativeInt64;
const abs = nonNegative ? value : -value - BigInt(1);
if (abs < BigInt("18446744073709551616")) {
ensure(9);
encodeBigHeader(major, abs);
} else {
const binaryStr = abs.toString(2);
const byteLen = Math.ceil(binaryStr.length / 8);
const bigIntBytes = new Uint8Array(byteLen);
let b = abs;
for (let i = byteLen - 1;i >= 0; --i) {
bigIntBytes[i] = Number(b & BigInt(255));
b >>= BigInt(8);
}
ensure(byteLen + 16);
buf[cursor++] = nonNegative ? 194 : 195;
encodeHeader(majorUnstructuredByteString, byteLen);
buf.set(bigIntBytes, cursor);
cursor += byteLen;
}
}
function writeBytes(data) {
ensure(data.length + 9);
encodeHeader(majorUnstructuredByteString, data.length);
buf.set(data, cursor);
cursor += data.length;
}
function writeTag(tagValue, innerValue) {
ensure(9);
if (typeof tagValue === "bigint") {
encodeBigHeader(majorTag, tagValue);
} else {
encodeHeader(majorTag, tagValue);
}
writeUntypedValue(innerValue);
}
function writeNumericValue(nv) {
let str = nv.string;
let expOffset = BigInt(0);
const eIndex = str.search(/[eE]/);
if (eIndex !== -1) {
expOffset = BigInt(str.slice(eIndex + 1));
str = str.slice(0, eIndex);
}
const decimalIndex = str.indexOf(".");
const fractionDigits = decimalIndex === -1 ? 0 : str.length - decimalIndex - 1;
const exponent = expOffset - BigInt(fractionDigits);
const mantissa = BigInt(str.replace(".", ""));
ensure(9);
buf[cursor++] = 196;
encodeHeader(majorList, 2);
ensure(9);
if (exponent >= -0x20000000000000n && exponent <= 0x1fffffffffffffn) {
writeInteger(Number(exponent));
} else {
writeBigInt(exponent);
}
writeBigInt(mantissa);
}
function writeTimestamp(date) {
ensure(18);
encodeHeader(majorTag, 1);
const epochSecs = date.getTime() / 1000;
if (Number.isInteger(epochSecs)) {
writeInteger(epochSecs);
} else {
writeFloat64(epochSecs);
}
}
class CborShapeDeserializer2 extends SerdeContext {
read(schema, bytes) {
payload = bytes;
isBuffer = USE_BUFFER && bytes instanceof Buffer;
dataView = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
pos = 0;
end = bytes.length;
cacheEpoch = cacheEpoch + 1 & 65535;
return readValue(NormalizedSchema.of(schema));
}
readValue(_schema, value) {
return transformObject(NormalizedSchema.of(_schema), value);
}
}
var USE_BUFFER = typeof Buffer !== "undefined";
var textDecoder = new TextDecoder;
var payload = new Uint8Array(0);
var isBuffer = false;
var dataView = new DataView(new ArrayBuffer(0));
var pos = 0;
var end = 0;
var STRING_CACHE_SIZE = 2048;
var stringCache = new Array(STRING_CACHE_SIZE);
var stringCacheEpochs = new Uint16Array(STRING_CACHE_SIZE);
var cacheEpoch = 0;
function readValue(ns) {
if (pos >= end) {
throw new Error("unexpected end of CBOR payload.");
}
const major = (payload[pos] & 224) >> 5;
const minor = payload[pos] & 31;
if (minor === minorIndefinite && major >= 2 && major <= 5) {
return readIndefinite(ns, major);
}
switch (major) {
case majorUint64:
return readUnsignedInt();
case majorNegativeInt64:
return readNegativeInt();
case majorUnstructuredByteString:
return readByteString();
case majorUtf8String:
return readUtf8String();
case majorList:
return readList(ns);
case majorMap:
return readMap(ns);
case majorTag:
return readTag();
case majorSpecial:
return readSpecial();
default:
throw new Error(`unexpected CBOR major type ${major}.`);
}
}
function readList(ns) {
const count = decodeCount();
const memberSchema = ns.isListSchema() ? ns.getValueSchema() : ns;
const list = Array(count);
for (let i = 0;i < count; ++i) {
list[i] = readValue(memberSchema);
}
return list;
}
function readMap(ns) {
const count = decodeCount();
if (ns.isStructSchema()) {
const startPos = pos;
return readStruct(ns, count, startPos);
}
const valueSchema = ns.isMapSchema() ? ns.getValueSchema() : ns;
const map = {};
for (let i = 0;i < count; ++i) {
const key = readUtf8String();
map[key] = readValue(valueSchema);
}
return map;
}
function readStruct(ns, count, startPos) {
const isUnion = ns.isUnionSchema();
const cache = loadCborStructIterator(ns);
const { memberSchemas, encodedKeys, memberNames } = cache;
const z = encodedKeys.length;
const result = {};
let unknownKey;
let unknownValue;
let unknownCount = 0;
let hasType = false;
let hint = 0;
for (let i = 0;i < count; ++i) {
const matchIdx = matchStructKey(encodedKeys, z, hint);
if (matchIdx >= 0) {
hint = matchIdx + 1;
if (hint >= z) {
hint = 0;
}
const val = readValue(memberSchemas[matchIdx]);
if (val != null) {
result[memberNames[matchIdx]] = val;
}
} else {
const key = readUtf8String();
const val = readValue(NormalizedSchema.of(15));
if (key === "__type" && typeof val === "string") {
hasType = true;
} else {
unknownKey = key;
unknownValue = val;
++unknownCount;
}
}
}
if (isUnion) {
let resultEmpty = true;
for (const _ in result) {
if (!hasOwn(result, _))
continue;
resultEmpty = false;
break;
}
if (resultEmpty && unknownCount === 1) {
result.$unknown = [unknownKey, unknownValue];
}
} else if (hasType) {
pos = startPos;
const docSchema = NormalizedSchema.of(15);
for (let i = 0;i < count; ++i) {
const key = readUtf8String();
const val = readValue(docSchema);
if (!(key in result)) {
result[key] = val;
}
}
}
return result;
}
function readTag(ns) {
const tagNum = decodeArgument();
const tagNumber = typeof tagNum === "bigint" ? Number(tagNum) : tagNum;
if (tagNumber === 1) {
const docSchema = NormalizedSchema.of(15);
const epochValue = readValue(docSchema);
return _parseEpochTimestamp(epochValue);
}
if (tagNumber === 2 || tagNumber === 3) {
const byteStr = readByteString();
let b = BigInt(0);
for (let i = 0;i < byteStr.length; ++i) {
b = b << BigInt(8) | BigInt(byteStr[i]);
}
return tagNumber === 3 ? -b - BigInt(1) : b;
}
if (tagNumber === 4) {
const docSchema = NormalizedSchema.of(15);
const pair = readValue(docSchema);
const [rawExponent, mantissa] = pair;
const normalizer = mantissa < 0 ? -1 : 1;
const absMantissa = BigInt(normalizer) * BigInt(mantissa);
const mantissaDigits = String(absMantissa);
const sign = mantissa < 0 ? "-" : "";
let numericString;
const isSmallExponent = typeof rawExponent === "number" && Math.abs(rawExponent) <= 2 ** 28;
if (isSmallExponent) {
const exponent = rawExponent;
const mantissaStr = "0".repeat(Math.abs(exponent) + 1) + mantissaDigits;
numericString = exponent === 0 ? mantissaStr : mantissaStr.slice(0, mantissaStr.length + exponent) + "." + mantissaStr.slice(exponent);
numericString = numericString.replace(/^0+/g, "");
if (numericString === "") {
numericString = "0";
}
if (numericString[0] === ".") {
numericString = "0" + numericString;
}
numericString = sign + numericString;
} else {
const bigExponent = BigInt(rawExponent);
if (mantissaDigits.length === 1) {
numericString = sign + mantissaDigits + "e" + String(bigExponent);
} else {
const adjustedExp = bigExponent + BigInt(mantissaDigits.length - 1);
numericString = sign + mantissaDigits[0] + "." + mantissaDigits.slice(1) + "e" + String(adjustedExp);
}
}
return nv(numericString);
}
const docSchema = NormalizedSchema.of(15);
const innerValue = readValue(docSchema);
return { tag: castBigInt(tagNum), value: innerValue };
}
function readIndefinite(ns, major) {
switch (major) {
case majorUtf8String:
return readUtf8StringIndefinite();
case majorUnstructuredByteString:
return readByteStringIndefinite();
case majorList:
return readListIndefinite(ns);
case majorMap:
return readMapIndefinite(ns);
default:
throw new Error(`unexpected indefinite length for major ${major}.`);
}
}
function readUtf8StringIndefinite() {
pos += 1;
const chunks = [];
let totalLen = 0;
while (pos < end) {
if (payload[pos] === 255) {
pos += 1;
const combined = new Uint8Array(totalLen);
let offset = 0;
for (let i = 0;i < chunks.length; ++i) {
combined.set(chunks[i], offset);
offset += chunks[i].length;
}
if (USE_BUFFER) {
return Buffer.from(combined.buffer, combined.byteOffset, combined.byteLength).toString("utf-8");
}
return textDecoder.decode(combined);
}
const bytes = readByteString();
chunks.push(bytes);
totalLen += bytes.length;
}
throw new Error("expected break marker.");
}
function readByteStringIndefinite() {
pos += 1;
const chunks = [];
let totalLen = 0;
while (pos < end) {
if (payload[pos] === 255) {
pos += 1;
const combined = new Uint8Array(totalLen);
let offset = 0;
for (let i = 0;i < chunks.length; ++i) {
combined.set(chunks[i], offset);
offset += chunks[i].length;
}
return combined;
}
const bytes = readByteString();
chunks.push(bytes);
totalLen += bytes.length;
}
throw new Error("expected break marker.");
}
function readListIndefinite(ns) {
pos += 1;
const memberSchema = ns.isListSchema() ? ns.getValueSchema() : ns;
const list = [];
while (pos < end) {
if (payload[pos] === 255) {
pos += 1;
return list;
}
list.push(readValue(memberSchema));
}
throw new Error("expected break marker.");
}
function readMapIndefinite(ns) {
pos += 1;
if (ns.isStructSchema()) {
const cache = loadCborStructIterator(ns);
const { memberSchemas, encodedKeys, memberNames } = cache;
const z = encodedKeys.length;
const isUnion = ns.isUnionSchema();
const result = {};
let unknownKey;
let unknownValue;
let unknownCount = 0;
let hint = 0;
while (pos < end) {
if (payload[pos] === 255) {
pos += 1;
if (isUnion) {
let resultEmpty = true;
for (const _ in result) {
if (!hasOwn(result, _))
continue;
resultEmpty = false;
break;
}
if (resultEmpty && unknownCount === 1) {
result.$unknown = [unknownKey, unknownValue];
}
}
return result;
}
const matchIdx = matchStructKey(encodedKeys, z, hint);
if (matchIdx >= 0) {
hint = matchIdx + 1;
if (hint >= z) {
hint = 0;
}
const val = readValue(memberSchemas[matchIdx]);
if (val != null) {
result[memberNames[matchIdx]] = val;
}
} else {
const key = readUtf8String();
const val = readValue(NormalizedSchema.of(15));
if (key !== "__type") {
unknownKey = key;
unknownValue = val;
++unknownCount;
}
}
}
throw new Error("expected break marker.");
}
const valueSchema = ns.isMapSchema() ? ns.getValueSchema() : ns;
const map = {};
while (pos < end) {
if (payload[pos] === 255) {
pos += 1;
return map;
}
const key = readUtf8String();
map[key] = readValue(valueSchema);
}
throw new Error("expected break marker.");
}
function matchStructKey(encodedKeys, z, hint) {
const hintKey = encodedKeys[hint];
if (pos + hintKey.length <= end && bytesMatch(pos, hintKey)) {
pos += hintKey.length;
return hint;
}
for (let i = 0;i < z; ++i) {
if (i === hint) {
continue;
}
const ek = encodedKeys[i];
if (pos + ek.length <= end && bytesMatch(pos, ek)) {
pos += ek.length;
return i;
}
}
return -1;
}
function bytesMatch(at, expected) {
const len = expected.length;
if (payload[at] !== expected[0]) {
return false;
}
for (let i = 1;i < len; ++i) {
if (payload[at + i] !== expected[i]) {
return false;
}
}
return true;
}
function decodeArgument() {
const minor = payload[pos] & 31;
if (minor < 24) {
pos += 1;
return minor;
}
switch (minor) {
case extendedOneByte:
if (end - pos < 2) {
overflow(1);
}
pos += 2;
return payload[pos - 1];
case extendedFloat16:
if (end - pos < 3) {
overflow(2);
}
pos += 3;
return dataView.getUint16(pos - 2);
case extendedFloat32:
if (end - pos < 5) {
overflow(4);
}
pos += 5;
return dataView.getUint32(pos - 4);
case extendedFloat64: {
if (end - pos < 9) {
overflow(8);
}
pos += 9;
const hi = dataView.getUint32(pos - 8);
if (hi < 2097152) {
return hi * 4294967296 + dataView.getUint32(pos - 4);
}
return dataView.getBigUint64(pos - 8);
}
default:
throw new Error(`unexpected minor value ${minor}.`);
}
}
function decodeCount() {
const val = decodeArgument();
return typeof val === "bigint" ? Number(val) : val;
}
function readUnsignedInt() {
const val = decodeArgument();
return castBigInt(val);
}
function readNegativeInt() {
const val = decodeArgument();
if (typeof val === "bigint") {
return BigInt(-1) - val;
}
return -1 - val;
}
function readByteString() {
const length = decodeCount();
if (end - pos < length) {
overflow(length);
}
const start = pos;
pos += length;
return payload.subarray(start, start + length);
}
function readUtf8String() {
const length = decodeCount();
if (end - pos < length) {
overflow(length);
}
const start = pos;
pos += length;
if (length < 24) {
return decodeUtf8Cached(start, length);
}
if (isBuffer) {
return payload.toString("utf-8", start, start + length);
}
return textDecoder.decode(payload.subarray(start, start + length));
}
function decodeUtf8Cached(at, length) {
let h = length;
for (let i = 0;i < length; ++i) {
h = h * 31 + payload[at + i] | 0;
}
const slot = h >>> 0 & STRING_CACHE_SIZE - 1;
const cached = stringCache[slot];
if (cached !== undefined && cached.length === length) {
let match = true;
for (let i = 0;i < length; ++i) {
if (cached.charCodeAt(i) !== payload[at + i]) {
match = false;
break;
}
}
if (match) {
stringCacheEpochs[slot] = cacheEpoch;
return cached;
}
}
const result = isBuffer ? payload.toString("utf-8", at, at + length) : textDecoder.decode(payload.subarray(at, at + length));
if (stringCacheEpochs[slot] !== cacheEpoch) {
stringCache[slot] = result;
stringCacheEpochs[slot] = cacheEpoch;
}
return result;
}
function readSpecial() {
const p = pos;
const minor = payload[p] & 31;
switch (minor) {
case specialTrue:
pos = p + 1;
return true;
case specialFalse:
pos = p + 1;
return false;
case specialNull:
pos = p + 1;
return null;
case specialUndefined:
pos = p + 1;
return null;
case extendedFloat16: {
if (end - p < 3) {
overflow(2);
}
pos = p + 3;
return bytesToFloat16(payload[p + 1], payload[p + 2]);
}
case extendedFloat32: {
if (end - p < 5) {
overflow(4);
}
pos = p + 5;
return dataView.getFloat32(p + 1);
}
case extendedFloat64: {
if (end - p < 9) {
overflow(8);
}
pos = p + 9;
return dataView.getFloat64(p + 1);
}
default:
throw new Error(`unexpected minor value ${minor} for major 7.`);
}
}
function bytesToFloat16(a, b) {
const sign = a >> 7;
const exponent = (a & 124) >> 2;
const fraction = (a & 3) << 8 | b;
const scalar = sign === 0 ? 1 : -1;
if (exponent === 0) {
if (fraction === 0) {
return 0;
}
return scalar * (Math.pow(2, 1 - 15) * (fraction / 1024));
} else if (exponent === 31) {
if (fraction === 0) {
return scalar * Infinity;
}
return NaN;
}
return scalar * (Math.pow(2, exponent - 15) * (1 + fraction / 1024));
}
function castBigInt(value) {
if (typeof value === "number") {
return value;
}
const num = Number(value);
if (Number.MIN_SAFE_INTEGER <= num && num <= Number.MAX_SAFE_INTEGER) {
return num;
}
return value;
}
function overflow(n) {
throw new Error(`CBOR: length ${n} greater than remaining buffer length.`);
}
function transformObject(ns, value) {
if (ns.isTimestampSchema()) {
if (typeof value === "number") {
return _parseEpochTimestamp(value);
}
if (typeof value === "object" && value !== null) {
if (value.tag === 1 && "value" in value) {
return _parseEpochTimestamp(value.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;
}
if (typeof value !== "object" || value === null) {
return value;
}
if ("byteLength" in value) {
return value;
}
if (value instanceof Date) {
return value;
}
if (value instanceof NumericValue) {
return value;
}
if (ns.isDocumentSchema()) {
return value;
}
if (ns.isListSchema()) {
const memberSchema = ns.getValueSchema();
const out = [];
for (const item of value) {
out.push(transformObject(memberSchema, item));
}
return out;
}
const newObject = {};
if (ns.isMapSchema()) {
const targetSchema = ns.getValueSchema();
for (const key in value) {
if (!hasOwn(value, key))
continue;
newObject[key] = transformObject(targetSchema, value[key]);
}
} else if (ns.isStructSchema()) {
const isUnion = ns.isUnionSchema();
let keys;
if (isUnion) {
keys = new Set;
for (const k in value) {
if (!hasOwn(value, k))
continue;
if (k !== "__type") {
keys.add(k);
}
}
}
for (const [key, memberSchema] of ns.structIterator()) {
if (isUnion) {
keys.delete(key);
}
if (value[key] != null) {
newObject[key] = transformObject(memberSchema, value[key]);
}
}
if (isUnion && keys?.size === 1) {
let newObjectEmpty = true;
for (const _ in newObject) {
if (!hasOwn(newObject, _))
continue;
newObjectEmpty = false;
break;
}
if (newObjectEmpty) {
const k = keys.values().next().value;
newObject.$unknown = [k, value[k]];
}
} else if (typeof value.__type === "string") {
for (const k in value) {
if (!hasOwn(value, k))
continue;
if (!(k in newObject)) {
newObject[k] = value[k];
}
}
}
}
return newObject;
}
class CborCodec extends SerdeContext {
createSerializer() {
const serializer = new CborShapeSerializer2;
serializer.setSerdeContext(this.serdeContext);
return serializer;
}
createDeserializer() {
const deserializer = new CborShapeDeserializer2;
deserializer.setSerdeContext(this.serdeContext);
return deserializer;
}
}
class SmithyRpcV2CborProtocol extends RpcProtocol {
codec = new CborCodec;
serializer = this.codec.createSerializer();
deserializer = this.codec.createDeserializer();
constructor({ defaultNamespace, errorTypeRegistries }) {
super({ defaultNamespace, errorTypeRegistries });
}
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": this.getDefaultContentType(),
"smithy-protocol": "rpc-v2-cbor",
accept: this.getDefaultContentType()
});
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();
}
if (request.body instanceof Uint8Array) {
request.headers["content-length"] = String(request.body.byteLength);
}
}
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 errorName = loadSmithyRpcV2CborErrorCode(response, dataObject) ?? "Unknown";
const errorMetadata = {
$metadata: metadata,
$fault: response.statusCode <= 500 ? "client" : "server"
};
let namespace = this.options.defaultNamespace;
if (errorName.includes("#")) {
[namespace] = errorName.split("#");
}
const registry = this.compositeErrorRegistry;
const nsRegistry = TypeRegistry.for(namespace);
registry.copyFrom(nsRegistry);
let errorSchema;
try {
errorSchema = registry.getSchema(errorName);
} catch (ignored) {
if (dataObject.Message) {
dataObject.message = dataObject.Message;
}
const syntheticRegistry = TypeRegistry.for("smithy.ts.sdk.synthetic." + namespace);
registry.copyFrom(syntheticRegistry);
const baseExceptionSchema = registry.getBaseException();
if (baseExceptionSchema) {
const ErrorCtor = registry.getErrorCtor(baseExceptionSchema);
throw Object.assign(new ErrorCtor({ name: errorName }), errorMetadata, dataObject);
}
throw Object.assign(new Error(errorName), errorMetadata, dataObject);
}
const ns = NormalizedSchema.of(errorSchema);
const ErrorCtor = registry.getErrorCtor(errorSchema);
const message = dataObject.message ?? dataObject.Message ?? "Unknown";
const exception = new ErrorCtor({});
const output = {};
for (const [name, member] of ns.structIterator()) {
output[name] = this.deserializer.readValue(member, dataObject[name]);
}
throw Object.assign(exception, errorMetadata, {
$fault: ns.getMergedTraits().error,
message
}, output);
}
getDefaultContentType() {
return "application/cbor";
}
}
class CborShapeSerializer extends SerdeContext {
value;
write(schema, value) {
this.value = this.serialize(schema, value);
}
serialize(schema, source) {
const ns = NormalizedSchema.of(schema);
if (source == null) {
if (ns.isIdempotencyToken()) {
return generateIdempotencyToken();
}
return source;
}
if (ns.isBlobSchema()) {
if (typeof source === "string") {
return (this.serdeContext?.base64Decoder ?? fromBase64)(source);
}
return source;
}
if (ns.isTimestampSchema()) {
if (typeof source === "number" || typeof source === "bigint") {
return dateToTag(new Date(Number(source) / 1000 | 0));
}
return dateToTag(source);
}
if (typeof source === "function" || typeof source === "object") {
const sourceObject = source;
if (ns.isListSchema() && Array.isArray(sourceObject)) {
const sparse = !!ns.getMergedTraits().sparse;
const newArray = [];
let i = 0;
for (const item of sourceObject) {
const value = this.serialize(ns.getValueSchema(), item);
if (value != null || sparse) {
newArray[i++] = value;
}
}
return newArray;
}
if (sourceObject instanceof Date) {
return dateToTag(sourceObject);
}
const newObject = {};
if (ns.isMapSchema()) {
const sparse = !!ns.getMergedTraits().sparse;
for (const key in sourceObject) {
if (!hasOwn(sourceObject, key))
continue;
const value = this.serialize(ns.getValueSchema(), sourceObject[key]);
if (value != null || sparse) {
newObject[key] = value;
}
}
} else if (ns.isStructSchema()) {
for (const [key, memberSchema] of ns.structIterator()) {
const value = this.serialize(memberSchema, sourceObject[key]);
if (value != null) {
newObject[key] = value;
}
}
const isUnion = ns.isUnionSchema();
if (isUnion && Array.isArray(sourceObject.$unknown)) {
const [k, v] = sourceObject.$unknown;
newObject[k] = v;
} else if (typeof sourceObject.__type === "string") {
for (const k in sourceObject) {
if (!hasOwn(sourceObject, k))
continue;
if (!(k in newObject)) {
newObject[k] = this.serialize(15, sourceObject[k]);
}
}
}
} else if (ns.isDocumentSchema()) {
if (Array.isArray(sourceObject)) {
const newArray = [];
let i = 0;
for (const item of sourceObject) {
newArray[i++] = this.serialize(ns.getValueSchema(), item);
}
return newArray;
}
for (const key in sourceObject) {
if (!hasOwn(sourceObject, key))
continue;
newObject[key] = this.serialize(ns.getValueSchema(), sourceObject[key]);
}
} else if (ns.isBigDecimalSchema()) {
return sourceObject;
}
return newObject;
}
return source;
}
flush() {
const buffer = cbor.serialize(this.value);
this.value = undefined;
return buffer;
}
}
class CborShapeDeserializer extends SerdeContext {
read(schema, bytes) {
const data = cbor.deserialize(bytes);
return this.readValue(schema, data);
}
readValue(_schema, value) {
const ns = NormalizedSchema.of(_schema);
if (ns.isTimestampSchema()) {
if (typeof value === "number") {
return _parseEpochTimestamp(value);
}
if (typeof value === "object") {
if (value.tag === 1 && "value" in value) {
return _parseEpochTimestamp(value.value);
}
}
}
if (ns.isBlobSchema()) {
if (typeof value === "string") {
return (this.serdeContext?.base64Decoder ?? fromBase64)(value);
}
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 === "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();
for (const item of value) {
const itemValue = this.readValue(memberSchema, item);
newArray.push(itemValue);
}
return newArray;
}
const newObject = {};
if (ns.isMapSchema()) {
const targetSchema = ns.getValueSchema();
for (const key in value) {
if (!hasOwn(value, key))
continue;
const itemValue = this.readValue(targetSchema, value[key]);
newObject[key] = itemValue;
}
} else if (ns.isStructSchema()) {
const isUnion = ns.isUnionSchema();
let keys;
if (isUnion) {
keys = new Set;
for (const k in value) {
if (!hasOwn(value, k))
continue;
if (k !== "__type") {
keys.add(k);
}
}
}
for (const [key, memberSchema] of ns.structIterator()) {
if (isUnion) {
keys.delete(key);
}
if (value[key] != null) {
newObject[key] = this.readValue(memberSchema, value[key]);
}
}
if (isUnion && keys?.size === 1) {
let newObjectEmpty = true;
for (const _ in newObject) {
if (!hasOwn(newObject, _))
continue;
newObjectEmpty = false;
break;
}
if (newObjectEmpty) {
const k = keys.values().next().value;
newObject.$unknown = [k, value[k]];
}
} else if (typeof value.__type === "string") {
for (const k in value) {
if (!hasOwn(value, k))
continue;
if (!(k in newObject)) {
newObject[k] = value[k];
}
}
}
} else if (value instanceof NumericValue) {
return value;
}
return newObject;
} else {
return value;
}
}
}
exports.CborCodec = CborCodec;
exports.CborShapeDeserializer = CborShapeDeserializer;
exports.CborShapeDeserializer2 = CborShapeDeserializer2;
exports.CborShapeSerializer = CborShapeSerializer;
exports.CborShapeSerializer2 = CborShapeSerializer2;
exports.SmithyRpcV2CborProtocol = SmithyRpcV2CborProtocol;
exports.buildHttpRpcRequest = buildHttpRpcRequest;
exports.cbor = cbor;
exports.checkCborResponse = checkCborResponse;
exports.dateToTag = dateToTag;
exports.loadSmithyRpcV2CborErrorCode = loadSmithyRpcV2CborErrorCode;
exports.parseCborBody = parseCborBody;
exports.parseCborErrorBody = parseCborErrorBody;
exports.tag = tag;
exports.tagSymbol = tagSymbol;
});
// ../../node_modules/.bun/@aws-sdk+xml-builder@3.972.40/node_modules/@aws-sdk/xml-builder/dist-cjs/index.js
var require_dist_cjs5 = __commonJS(function(exports) {
var ATTR_ESCAPE_RE = /[&<>"]/g;
var ATTR_ESCAPE_MAP = {
"&": "&",
"<": "<",
">": ">",
'"': """
};
function escapeAttribute(value) {
return value.replace(ATTR_ESCAPE_RE, (ch) => ATTR_ESCAPE_MAP[ch]);
}
var ELEMENT_ESCAPE_RE = /[&"'<>\r\n\u0085\u2028]/g;
var ELEMENT_ESCAPE_MAP = {
"&": "&",
'"': """,
"'": "'",
"<": "<",
">": ">",
"\r": "
",
"\n": "
",
"\x85": "…",
"\u2028": "
"
};
function escapeElement(value) {
return value.replace(ELEMENT_ESCAPE_RE, (ch) => ELEMENT_ESCAPE_MAP[ch]);
}
class XmlText {
value;
constructor(value) {
this.value = value;
}
toString() {
return escapeElement("" + this.value);
}
}
class XmlNode {
name;
children;
attributes = {};
static of(name, childText, withName) {
const node = new XmlNode(name);
if (childText !== undefined) {
node.addChildNode(new XmlText(childText));
}
if (withName !== undefined) {
node.withName(withName);
}
return node;
}
constructor(name, children = []) {
this.name = name;
this.children = children;
}
withName(name) {
this.name = name;
return this;
}
addAttribute(name, value) {
this.attributes[name] = value;
return this;
}
addChildNode(child) {
this.children.push(child);
return this;
}
removeAttribute(name) {
delete this.attributes[name];
return this;
}
n(name) {
this.name = name;
return this;
}
c(child) {
this.children.push(child);
return this;
}
a(name, value) {
if (value != null) {
this.attributes[name] = value;
}
return this;
}
cc(input, field, withName = field) {
if (input[field] != null) {
const node = XmlNode.of(field, input[field]).withName(withName);
this.c(node);
}
}
l(input, listName, memberName, valueProvider) {
if (input[listName] != null) {
const nodes = valueProvider();
nodes.map((node) => {
node.withName(memberName);
this.c(node);
});
}
}
lc(input, listName, memberName, valueProvider) {
if (input[listName] != null) {
const nodes = valueProvider();
const containerNode = new XmlNode(memberName);
nodes.map((node) => {
containerNode.c(node);
});
this.c(containerNode);
}
}
toString() {
const hasChildren = Boolean(this.children.length);
let xmlText = `<${this.name}`;
const attributes = this.attributes;
for (const attributeName of Object.keys(attributes)) {
const attribute = attributes[attributeName];
if (attribute != null) {
xmlText += ` ${attributeName}="${escapeAttribute("" + attribute)}"`;
}
}
return xmlText += !hasChildren ? "/>" : `>${this.children.map((c) => c.toString()).join("")}</${this.name}>`;
}
}
function writeKey(obj) {
Object.defineProperty(obj, "__proto__", { value: undefined, writable: true, enumerable: true, configurable: true });
}
function parseXML(xml) {
const state = new AwsXmlParser(xml);
return state.parse();
}
class AwsXmlParser {
x;
i = 0;
z;
constructor(x) {
this.x = x;
this.x = x.replace(/\r\n?/g, `
`);
this.z = this.x.length;
}
parse() {
const p = this;
const { z } = p;
while (p.i < z) {
p.trim();
if (p.i >= z) {
break;
}
if (p.isNext("<?")) {
p.readTo("?>");
p.trim();
} else if (p.isNext("<!--")) {
p.readTo("-->");
p.trim();
} else if (p.isNext("<!DOCTYPE", false)) {
p.skipDoctype();
p.trim();
} else if (p.x[p.i] === "<") {
const root = p.parseTag();
return { [root.tag]: root.value };
} else {
throw new Error("@aws-sdk XML parse error: unexpected content.");
}
}
throw new Error("@aws-sdk XML parse error: no root element.");
}
isNext(s, caseSensitive = true) {
const p = this;
if (caseSensitive) {
return p.x.startsWith(s, p.i);
}
return p.x.toLowerCase().startsWith(s.toLowerCase(), p.i);
}
readTo(stop) {
const p = this;
const _i = p.x.indexOf(stop, p.i);
if (_i === -1) {
throw new Error(`@aws-sdk XML parse error: expected "${stop}" not found.`);
}
const result = p.x.slice(p.i, _i);
p.i = _i + stop.length;
return result;
}
trim() {
const p = this;
while (p.i < p.z && ` \r
`.includes(p.x[p.i])) {
++p.i;
}
}
readAttrValue() {
const p = this;
const quote = p.x[p.i];
++p.i;
let value = "";
while (p.i < p.z && p.x[p.i] !== quote) {
value += p.x[p.i++];
}
++p.i;
return p.decodeEntities(value);
}
parseTag() {
const p = this;
++p.i;
let tag = "";
while (p.i < p.z && !` \r
>/`.includes(p.x[p.i])) {
tag += p.x[p.i++];
}
let hasAttrs = false;
const attrs = {};
while (p.i < p.z) {
p.trim();
if (">/".includes(p.x[p.i])) {
break;
}
let name = "";
while (p.i < p.z && !`= \r
>/?`.includes(p.x[p.i])) {
name += p.x[p.i++];
}
p.trim();
if (p.x[p.i] !== "=") {
break;
}
++p.i;
p.trim();
if (name === "__proto__") {
writeKey(attrs);
}
attrs[name] = p.readAttrValue();
hasAttrs = true;
}
if (p.i >= p.z) {
throw new Error("@aws-sdk XML parse error: unexpected end of input.");
}
if (p.x[p.i] === "/") {
++p.i;
if (p.i >= p.z || p.x[p.i] !== ">") {
throw new Error("@aws-sdk XML parse error: expected > at the end of self-closing tag.");
}
++p.i;
return { tag, value: hasAttrs ? attrs : "" };
}
if (p.x[p.i] !== ">") {
throw new Error("@aws-sdk XML parse error: expected > at the end of opening tag.");
}
++p.i;
const textParts = [];
const childTags = [];
let hasElementChild = false;
while (p.i < p.z) {
if (p.isNext("</")) {
break;
}
if (p.x[p.i] === "<") {
if (p.isNext("<!--")) {
p.readTo("-->");
} else if (p.isNext("<![CDATA[")) {
p.i += 9;
textParts.push(p.readTo("]]>"));
} else if (p.isNext("<?")) {
p.readTo("?>");
} else {
hasElementChild = true;
childTags.push(p.parseTag());
}
} else {
let text = "";
while (p.i < p.z && p.x[p.i] !== "<") {
text += p.x[p.i++];
}
textParts.push(p.decodeEntities(text));
}
}
if (!p.isNext("</")) {
throw new Error(`@aws-sdk XML parse error: missing closing tag </${tag}>.`);
}
p.i += 2;
const closeTag = p.readTo(">").trim();
if (closeTag !== tag) {
throw new Error(`@aws-sdk XML parse error: mismatched tags <${tag}> and </${closeTag}>.`);
}
if (!hasAttrs && textParts.length === 0 && !hasElementChild) {
return { tag, value: "" };
}
if (!hasAttrs && !hasElementChild) {
const text = textParts.length === 1 ? textParts[0] : textParts.join("");
if (text.trim() === "" && text.includes(`
`)) {
return { tag, value: "" };
}
return { tag, value: text };
}
const obj = {};
for (const text of textParts) {
if (text.trim() === "" && text.includes(`
`)) {
continue;
}
obj["#text"] = "#text" in obj ? obj["#text"] + text : text;
}
for (const child of childTags) {
if (child.tag === "__proto__") {
writeKey(obj);
}
if (child.tag in obj) {
if (Array.isArray(obj[child.tag])) {
obj[child.tag].push(child.value);
} else {
obj[child.tag] = [obj[child.tag], child.value];
}
} else {
obj[child.tag] = child.value;
}
}
for (const [k, v] of Object.entries(attrs)) {
if (k === "__proto__") {
writeKey(obj);
}
obj[k] = v;
}
return { tag, value: obj };
}
static ENTITIES = {
amp: "&",
lt: "<",
gt: ">",
quot: '"',
apos: "'"
};
skipDoctype() {
const p = this;
p.i += 9;
let depth = 0;
while (p.i < p.z) {
const c = p.x[p.i];
if (c === "[") {
++depth;
} else if (c === "]") {
--depth;
} else if (c === ">" && depth === 0) {
++p.i;
return;
}
++p.i;
}
throw new Error("@aws-sdk XML parse error: unclosed DOCTYPE.");
}
decodeEntities(s) {
return s.replace(/&(?:#x([0-9a-fA-F]{1,6})|#(\d{1,7})|([a-zA-Z][a-zA-Z0-9]{0,30}));/g, (_, hex, dec, named) => {
if (hex) {
return String.fromCharCode(parseInt(hex, 16));
}
if (dec) {
return String.fromCharCode(parseInt(dec, 10));
}
return AwsXmlParser.ENTITIES[named] ?? "";
});
}
}
exports.XmlNode = XmlNode;
exports.XmlText = XmlText;
exports.parseXML = parseXML;
});
// ../../node_modules/.bun/@aws-sdk+core@3.977.9/node_modules/@aws-sdk/core/dist-cjs/submodules/protocols/index.js
var require_protocols2 = __commonJS(function(exports) {
var { SmithyRpcV2CborProtocol, loadSmithyRpcV2CborErrorCode } = require_cbor();
var { TypeRegistry, NormalizedSchema, deref } = require_schema();
var { decorateServiceException, getValueFromTextNode } = require_client();
var { collectBody, determineTimestampFormat, RpcProtocol, HttpBindingProtocol, HttpInterceptingShapeSerializer, HttpInterceptingShapeDeserializer, FromStringShapeDeserializer, extendedEncodeURIComponent } = require_protocols();
var { NumericValue, toUtf8, fromBase64, LazyJsonString, parseEpochTimestamp, parseRfc7231DateTime, parseRfc3339DateTimeWithOffset, generateIdempotencyToken, toBase64, dateToUtcString, expectUnion } = require_serde();
var { parseXML, XmlNode, XmlText } = require_dist_cjs5();
class ProtocolLib {
queryCompat;
errorRegistry;
constructor(queryCompat = false) {
this.queryCompat = queryCompat;
}
resolveRestContentType(defaultContentType, inputSchema) {
const members = inputSchema.getMemberSchemas();
const httpPayloadMember = Object.values(members).find((m) => {
return !!m.getMergedTraits().httpPayload;
});
if (httpPayloadMember) {
const mediaType = httpPayloadMember.getMergedTraits().mediaType;
if (mediaType) {
return mediaType;
} else if (httpPayloadMember.isStringSchema()) {
return "text/plain";
} else if (httpPayloadMember.isBlobSchema()) {
return "application/octet-stream";
} else {
return defaultContentType;
}
} else if (!inputSchema.isUnitSchema()) {
const hasBody = Object.values(members).find((m) => {
const { httpQuery, httpQueryParams, httpHeader, httpLabel, httpPrefixHeaders } = m.getMergedTraits();
const noPrefixHeaders = httpPrefixHeaders === undefined;
return !httpQuery && !httpQueryParams && !httpHeader && !httpLabel && noPrefixHeaders;
});
if (hasBody) {
return defaultContentType;
}
}
}
async getErrorSchemaOrThrowBaseException(errorIdentifier, defaultNamespace, response, dataObject, metadata, getErrorSchema) {
let errorName = errorIdentifier;
if (errorIdentifier.includes("#")) {
[, errorName] = errorIdentifier.split("#");
}
const errorMetadata = {
$metadata: metadata,
$fault: response.statusCode < 500 ? "client" : "server"
};
if (!this.errorRegistry) {
throw new Error("@aws-sdk/core/protocols - error handler not initialized.");
}
try {
const errorSchema = getErrorSchema?.(this.errorRegistry, errorName) ?? this.errorRegistry.getSchema(errorIdentifier);
return { errorSchema, errorMetadata };
} catch (e) {
dataObject.message = dataObject.message ?? dataObject.Message ?? "UnknownError";
const synthetic = this.errorRegistry;
const baseExceptionSchema = synthetic.getBaseException();
if (baseExceptionSchema) {
const ErrorCtor = synthetic.getErrorCtor(baseExceptionSchema) ?? Error;
throw this.decorateServiceException(Object.assign(new ErrorCtor({ name: errorName }), errorMetadata), dataObject);
}
const d = dataObject;
const message = d?.message ?? d?.Message ?? d?.Error?.Message ?? d?.Error?.message;
throw this.decorateServiceException(Object.assign(new Error(message), {
name: errorName
}, errorMetadata), dataObject);
}
}
compose(composite, errorIdentifier, defaultNamespace) {
let namespace = defaultNamespace;
if (errorIdentifier.includes("#")) {
[namespace] = errorIdentifier.split("#");
}
const staticRegistry = TypeRegistry.for(namespace);
const defaultSyntheticRegistry = TypeRegistry.for("smithy.ts.sdk.synthetic." + defaultNamespace);
composite.copyFrom(staticRegistry);
composite.copyFrom(defaultSyntheticRegistry);
this.errorRegistry = composite;
}
decorateServiceException(exception, additions = {}) {
if (this.queryCompat) {
const msg = exception.Message ?? additions.Message;
const error = decorateServiceException(exception, additions);
if (msg) {
error.message = msg;
}
const errorObj = error.Error ?? {};
errorObj.Type = error.Error?.Type;
errorObj.Code = error.Error?.Code;
errorObj.Message = error.Error?.message ?? error.Error?.Message ?? msg;
error.Error = errorObj;
const reqId = error.$metadata.requestId;
if (reqId) {
error.RequestId = reqId;
}
return error;
}
return decorateServiceException(exception, additions);
}
setQueryCompatError(output, response) {
const queryErrorHeader = response.headers?.["x-amzn-query-error"];
if (output !== undefined && queryErrorHeader != null) {
const [Code, Type] = queryErrorHeader.split(";");
const keys = Object.keys(output);
const Error2 = {
Code,
Type
};
output.Code = Code;
output.Type = Type;
for (let i = 0;i < keys.length; i++) {
const k = keys[i];
Error2[k === "message" ? "Message" : k] = output[k];
}
delete Error2.__type;
output.Error = Error2;
}
}
queryCompatOutput(queryCompatErrorData, errorData) {
if (queryCompatErrorData.Error) {
errorData.Error = queryCompatErrorData.Error;
}
if (queryCompatErrorData.Type) {
errorData.Type = queryCompatErrorData.Type;
}
if (queryCompatErrorData.Code) {
errorData.Code = queryCompatErrorData.Code;
}
}
findQueryCompatibleError(registry, errorName) {
try {
return registry.getSchema(errorName);
} catch (e) {
return registry.find((schema) => NormalizedSchema.of(schema).getMergedTraits().awsQueryError?.[0] === errorName);
}
}
}
class AwsSmithyRpcV2CborProtocol extends SmithyRpcV2CborProtocol {
awsQueryCompatible;
mixin;
constructor({ defaultNamespace, errorTypeRegistries, awsQueryCompatible }) {
super({ defaultNamespace, errorTypeRegistries });
this.awsQueryCompatible = !!awsQueryCompatible;
this.mixin = new ProtocolLib(this.awsQueryCompatible);
}
async serializeRequest(operationSchema, input, context) {
const request = await super.serializeRequest(operationSchema, input, context);
if (this.awsQueryCompatible) {
request.headers["x-amzn-query-mode"] = "true";
}
return request;
}
async handleError(operationSchema, context, response, dataObject, metadata) {
if (this.awsQueryCompatible) {
this.mixin.setQueryCompatError(dataObject, response);
}
const errorName = (() => {
const compatHeader = response.headers["x-amzn-query-error"];
if (compatHeader && this.awsQueryCompatible) {
return compatHeader.split(";")[0];
}
return loadSmithyRpcV2CborErrorCode(response, dataObject) ?? "Unknown";
})();
this.mixin.compose(this.compositeErrorRegistry, errorName, this.options.defaultNamespace);
const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorName, this.options.defaultNamespace, response, dataObject, metadata, this.awsQueryCompatible ? this.mixin.findQueryCompatibleError : undefined);
const ns = NormalizedSchema.of(errorSchema);
const message = dataObject.message ?? dataObject.Message ?? "UnknownError";
const ErrorCtor = this.compositeErrorRegistry.getErrorCtor(errorSchema) ?? Error;
const exception = new ErrorCtor({});
const output = {};
for (const [name, member] of ns.structIterator()) {
if (dataObject[name] != null) {
output[name] = this.deserializer.readValue(member, dataObject[name]);
}
}
if (this.awsQueryCompatible) {
this.mixin.queryCompatOutput(dataObject, output);
}
throw this.mixin.decorateServiceException(Object.assign(exception, errorMetadata, {
$fault: ns.getMergedTraits().error,
message
}, output), dataObject);
}
}
class SerdeContextConfig {
serdeContext;
setSerdeContext(serdeContext) {
this.serdeContext = serdeContext;
}
}
class UnionSerde {
from;
to;
keys;
constructor(from, to) {
this.from = from;
this.to = to;
const keys = Object.keys(this.from);
const set = new Set(keys);
set.delete("__type");
this.keys = set;
}
mark(key) {
this.keys.delete(key);
}
hasUnknown() {
return this.keys.size === 1 && Object.keys(this.to).length === 0;
}
writeUnknown() {
if (this.hasUnknown()) {
const k = this.keys.values().next().value;
const v = this.from[k];
this.to.$unknown = [k, v];
}
}
}
var canParseBuffer;
function detectBufferParsing() {
if (canParseBuffer === undefined) {
try {
if (typeof Buffer !== "function") {
canParseBuffer = false;
} else {
const result = JSON.parse(Buffer.from([123, 125]));
canParseBuffer = result !== null && typeof result === "object";
}
} catch {
canParseBuffer = false;
}
}
return canParseBuffer;
}
function jsonReviver(key, value, context) {
if (context?.source) {
const numericString = context.source;
if (typeof value === "number") {
const inSafeRange = value <= Number.MAX_SAFE_INTEGER && value >= Number.MIN_SAFE_INTEGER;
if (inSafeRange) {
if (isRepresentable(numericString, value)) {
return value;
}
return new NumericValue(numericString, "bigDecimal");
} else {
if (isFractionalBigNumeric(numericString)) {
return new NumericValue(numericString, "bigDecimal");
}
if (/[eE]/.test(numericString)) {
return expandExponentToBigInt(numericString);
}
return BigInt(numericString);
}
}
}
return value;
}
function isFractionalBigNumeric(s) {
const dotIndex = s.indexOf(".");
if (dotIndex === -1) {
return false;
}
const eIndex = s.search(/[eE]/);
if (eIndex === -1) {
return true;
}
const fracDigits = eIndex - dotIndex - 1;
const exp = parseInt(s.slice(eIndex + 1), 10);
return exp < fracDigits;
}
function isRepresentable(numericString, value) {
if (numericString === String(value)) {
return true;
}
if (Object.is(value, -0)) {
return true;
}
if (/[eE]/.test(numericString)) {
return expandToDecimal(numericString) === expandToDecimal(String(value));
}
const normalized = numericString.replace(/(\.\d*?)0+$/, "$1").replace(/\.$/, "");
const canonical = String(value);
if (normalized === canonical) {
return true;
}
if (/[eE]/.test(canonical)) {
return normalized === expandToDecimal(canonical);
}
return false;
}
function expandToDecimal(s) {
const negative = s.startsWith("-");
const abs = negative ? s.slice(1) : s;
const eIndex = abs.search(/[eE]/);
let result;
if (eIndex === -1) {
result = abs;
} else {
const exp = parseInt(abs.slice(eIndex + 1), 10);
const mantissa = abs.slice(0, eIndex);
const dotIndex = mantissa.indexOf(".");
let digits;
let intLen;
if (dotIndex === -1) {
digits = mantissa;
intLen = mantissa.length;
} else {
digits = mantissa.slice(0, dotIndex) + mantissa.slice(dotIndex + 1);
intLen = dotIndex;
}
digits = digits.replace(/0+$/, "") || "0";
const newDotPos = intLen + exp;
if (digits === "0") {
result = "0";
} else if (newDotPos <= 0) {
result = "0." + "0".repeat(-newDotPos) + digits;
} else if (newDotPos >= digits.length) {
result = digits + "0".repeat(newDotPos - digits.length);
} else {
result = digits.slice(0, newDotPos) + "." + digits.slice(newDotPos);
}
}
if (result.includes(".")) {
result = result.replace(/(\.\d*?)0+$/, "$1").replace(/\.$/, "");
}
return (negative ? "-" : "") + result;
}
function expandExponentToBigInt(s) {
const eIndex = s.search(/[eE]/);
const exp = parseInt(s.slice(eIndex + 1), 10);
const negative = s.startsWith("-");
const mantissa = s.slice(negative ? 1 : 0, eIndex);
const dotIndex = mantissa.indexOf(".");
let digits;
let shift;
if (dotIndex === -1) {
digits = mantissa;
shift = exp;
} else {
digits = mantissa.slice(0, dotIndex) + mantissa.slice(dotIndex + 1);
const fracDigits = mantissa.length - dotIndex - 1;
shift = exp - fracDigits;
}
digits = digits.replace(/0+$/, "") || "0";
const result = BigInt(digits) * 10n ** BigInt(shift + (mantissa.replace(".", "").length - digits.length));
return negative ? -result : result;
}
var REVIVER_SYMBOL = Symbol.for("@aws-sdk/reviver");
function needsReviver(schema) {
const ns = NormalizedSchema.of(schema);
const raw = ns.getSchema();
if (Array.isArray(raw) && ns.isStructSchema()) {
if (REVIVER_SYMBOL in raw) {
return raw[REVIVER_SYMBOL];
}
const result = _check(ns, new Set);
raw[REVIVER_SYMBOL] = result;
return result;
}
return _check(ns, new Set);
}
function _check(ns, seen) {
const raw = ns.getSchema();
if (seen.has(raw)) {
return false;
}
seen.add(raw);
if (ns.isBigIntegerSchema() || ns.isBigDecimalSchema()) {
return true;
}
if (ns.isStructSchema()) {
for (const [, memberSchema] of ns.structIterator()) {
if (_check(memberSchema, seen)) {
return true;
}
}
} else if (ns.isListSchema() || ns.isMapSchema()) {
if (_check(ns.getValueSchema(), seen)) {
return true;
}
} else if (ns.isDocumentSchema()) {
return true;
}
return false;
}
var collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => (context?.utf8Encoder ?? toUtf8)(body));
async function parseJsonBody(streamBody, context, schema) {
let parsingInput;
if (detectBufferParsing() && typeof streamBody?.[Symbol.asyncIterator] === "function") {
const buffer = await collectBody(streamBody, context);
if (typeof Buffer === "function") {
if (Buffer.isBuffer(buffer)) {
parsingInput = buffer;
} else {
parsingInput = Buffer.from(buffer.buffer, buffer.byteOffset, buffer.byteLength);
}
}
}
if (!parsingInput) {
parsingInput = await collectBodyString(streamBody, context);
}
if (parsingInput.length === 0) {
return {};
}
const reviver = schema && needsReviver(schema) ? jsonReviver : undefined;
try {
return JSON.parse(parsingInput, reviver);
} catch (e) {
if (e?.name === "SyntaxError") {
Object.defineProperty(e, "$responseBodyText", {
value: typeof parsingInput === "string" ? parsingInput : parsingInput.toString("utf8")
});
}
throw e;
}
}
var parseJsonErrorBody = async (errorBody, context) => {
const value = await parseJsonBody(errorBody, context);
value.message = value.message ?? value.Message;
return value;
};
var findKey = (object, key) => Object.keys(object).find((k) => k.toLowerCase() === key.toLowerCase());
var sanitizeErrorCode = (rawValue) => {
let cleanValue = rawValue;
if (typeof cleanValue === "number") {
cleanValue = cleanValue.toString();
}
if (cleanValue.indexOf(",") >= 0) {
cleanValue = cleanValue.split(",")[0];
}
if (cleanValue.indexOf(":") >= 0) {
cleanValue = cleanValue.split(":")[0];
}
if (cleanValue.indexOf("#") >= 0) {
cleanValue = cleanValue.split("#")[1];
}
return cleanValue;
};
var loadRestJsonErrorCode = (output, data) => {
return loadErrorCode(output, data, ["header", "code", "type"]);
};
var loadJsonRpcErrorCode = (output, data, queryCompat = false) => {
return loadErrorCode(output, data, queryCompat ? ["code", "header", "type"] : ["type", "code", "header"]);
};
var loadErrorCode = ({ headers }, data, order) => {
while (order.length > 0) {
const location = order.shift();
switch (location) {
case "header":
const headerKey = findKey(headers ?? {}, "x-amzn-errortype");
if (headerKey !== undefined) {
return sanitizeErrorCode(headers[headerKey]);
}
break;
case "code":
const codeKey = findKey(data ?? {}, "code");
if (codeKey && data[codeKey] !== undefined) {
return sanitizeErrorCode(data[codeKey]);
}
break;
case "type":
if (data?.__type !== undefined) {
return sanitizeErrorCode(data.__type);
}
break;
}
}
};
function writeKey(obj) {
Object.defineProperty(obj, "__proto__", { value: undefined, writable: true, enumerable: true, configurable: true });
}
class JsonShapeDeserializer2 extends SerdeContextConfig {
settings;
constructor(settings) {
super();
this.settings = settings;
}
async read(schema, data) {
const reviver = needsReviver(schema) ? jsonReviver : undefined;
let parsed;
if (typeof data === "string") {
if (data.length === 0) {
return {};
}
parsed = JSON.parse(data, reviver);
} else if (data instanceof Uint8Array && detectBufferParsing()) {
if (data.byteLength === 0) {
return {};
}
const buf = Buffer.isBuffer(data) ? data : Buffer.from(data.buffer, data.byteOffset, data.byteLength);
parsed = JSON.parse(buf, reviver);
} else {
parsed = await parseJsonBody(data, this.serdeContext, schema);
}
return this._read(schema, parsed);
}
readObject(schema, data) {
return this._read(schema, data);
}
_read(schema, value) {
const isObject = value !== null && typeof value === "object";
const ns = NormalizedSchema.of(schema);
if (isObject) {
if (ns.isStructSchema()) {
return this._readStruct(ns, value);
}
if (Array.isArray(value) && ns.isListSchema()) {
const listMember = ns.getValueSchema();
if (this.needsTransform(listMember)) {
for (let i = 0;i < value.length; ++i) {
value[i] = this._read(listMember, value[i]);
}
}
return value;
}
if (ns.isMapSchema()) {
const mapMember = ns.getValueSchema();
const map = value;
if (this.needsTransform(mapMember)) {
for (const k in map) {
if (k === "__proto__") {
writeKey(map);
}
map[k] = this._read(mapMember, map[k]);
}
}
return map;
}
}
if (ns.isBlobSchema() && typeof value === "string") {
return fromBase64(value);
}
const mediaType = ns.getMergedTraits().mediaType;
if (ns.isStringSchema() && typeof value === "string" && mediaType) {
const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
if (isJson) {
return LazyJsonString.from(value);
}
return value;
}
if (ns.isTimestampSchema() && value != null) {
const format = determineTimestampFormat(ns, this.settings);
switch (format) {
case 5:
return parseRfc3339DateTimeWithOffset(value);
case 6:
return parseRfc7231DateTime(value);
case 7:
return parseEpochTimestamp(value);
default:
console.warn("Missing timestamp format, parsing value with Date constructor:", value);
return new Date(value);
}
}
if (ns.isBigIntegerSchema() && (typeof value === "number" || typeof value === "string")) {
return BigInt(value);
}
if (ns.isBigDecimalSchema() && value != null) {
if (value instanceof NumericValue) {
return value;
}
const untyped = value;
if (untyped.type === "bigDecimal" && "string" in untyped) {
return new NumericValue(untyped.string, untyped.type);
}
return new NumericValue(String(value), "bigDecimal");
}
if (ns.isNumericSchema() && typeof value === "string") {
switch (value) {
case "Infinity":
return Infinity;
case "-Infinity":
return -Infinity;
case "NaN":
return NaN;
}
return value;
}
if (ns.isDocumentSchema()) {
if (isObject) {
if (Array.isArray(value)) {
for (let i = 0;i < value.length; ++i) {
const v = value[i];
if (!(v instanceof NumericValue)) {
value[i] = this._read(ns, v);
}
}
} else {
const doc = value;
for (const k in doc) {
if (k === "__proto__") {
writeKey(doc);
}
const v = doc[k];
if (!(v instanceof NumericValue)) {
doc[k] = this._read(ns, v);
}
}
}
}
}
return value;
}
_readStruct(ns, record) {
const union = ns.isUnionSchema();
const out = {};
let nameMap;
const hasType = typeof record.__type === "string";
const { jsonName } = this.settings;
if (jsonName && hasType) {
nameMap = {};
}
let unionSerde;
if (union) {
unionSerde = new UnionSerde(record, out);
}
for (const [memberName, memberSchema] of ns.structIterator()) {
let fromKey = memberName;
if (jsonName) {
fromKey = memberSchema.getMergedTraits().jsonName ?? fromKey;
if (hasType) {
nameMap[fromKey] = memberName;
}
}
if (union) {
unionSerde.mark(fromKey);
}
if (record[fromKey] != null) {
out[memberName] = this._read(memberSchema, record[fromKey]);
}
}
if (union) {
unionSerde.writeUnknown();
} else if (hasType) {
for (const k in record) {
const v = record[k];
const t = jsonName ? nameMap[k] ?? k : k;
if (!(t in out)) {
out[t] = v;
}
}
}
return out;
}
needsTransform(ns) {
if (ns.isBlobSchema() || ns.isTimestampSchema() || ns.isBigIntegerSchema() || ns.isBigDecimalSchema()) {
return true;
}
if (ns.isDocumentSchema() || ns.isStructSchema() || ns.isListSchema() || ns.isMapSchema()) {
return true;
}
if (ns.isStringSchema() && ns.getMergedTraits().mediaType) {
return true;
}
return false;
}
}
class JsonBytesStringAdapter extends Uint8Array {
string = null;
static allocUnsafe(bytes) {
if (typeof Buffer === "function") {
const buffer = Buffer.allocUnsafe(bytes);
return new JsonBytesStringAdapter(buffer.buffer, buffer.byteOffset, buffer.byteLength);
}
return new JsonBytesStringAdapter(bytes);
}
toString() {
return this.s();
}
valueOf() {
return this.s();
}
includes(searchString, position) {
if (typeof searchString === "string") {
return this.s().includes(searchString, position);
}
return Uint8Array.prototype.includes.call(this, searchString, position);
}
indexOf(searchString, position) {
if (typeof searchString === "string") {
return this.s().indexOf(searchString, position);
}
return Uint8Array.prototype.indexOf.call(this, searchString, position);
}
lastIndexOf(searchString, position) {
if (typeof searchString === "string") {
return this.s().lastIndexOf(searchString, position);
}
const fn = Uint8Array.prototype.lastIndexOf;
if (position !== undefined) {
return fn.call(this, searchString, position);
}
return fn.call(this, searchString);
}
startsWith(searchString, position) {
return this.s().startsWith(searchString, position);
}
endsWith(searchString, endPosition) {
return this.s().endsWith(searchString, endPosition);
}
match(regexp) {
return this.s().match(regexp);
}
replace(searchValue, replaceValue) {
return this.s().replace(searchValue, replaceValue);
}
search(regexp) {
return this.s().search(regexp);
}
split(separator, limit) {
return this.s().split(separator, limit);
}
substring(start, end) {
return this.s().substring(start, end);
}
trim() {
return this.s().trim();
}
trimStart() {
return this.s().trimStart();
}
trimEnd() {
return this.s().trimEnd();
}
charAt(pos) {
return this.s().charAt(pos);
}
charCodeAt(index) {
return this.s().charCodeAt(index);
}
padStart(maxLength, fillString) {
return this.s().padStart(maxLength, fillString);
}
padEnd(maxLength, fillString) {
return this.s().padEnd(maxLength, fillString);
}
repeat(count) {
return this.s().repeat(count);
}
toUpperCase() {
return this.s().toUpperCase();
}
toLowerCase() {
return this.s().toLowerCase();
}
s() {
if (this.string == null) {
const n = Date.now();
if (n > warned + 60000) {
console.warn("@aws-sdk/core/protocols - WARN - JsonCodec2: you have called a string method on a Uint8Array request body. " + "It has been automatically converted to string. In a future version this will throw an error.");
warned = n;
}
this.string = toUtf8(this);
}
return this.string;
}
}
var warned = 0;
var encoder = new TextEncoder;
var OPEN_BRACE = 123;
var CLOSE_BRACE = 125;
var OPEN_BRACKET = 91;
var CLOSE_BRACKET = 93;
var QUOTE = 34;
var COLON = 58;
var COMMA = 44;
var BACKSLASH = 92;
var TRUE = new Uint8Array([116, 114, 117, 101]);
var FALSE = new Uint8Array([102, 97, 108, 115, 101]);
var NULL = new Uint8Array([110, 117, 108, 108]);
var ESCAPE_TABLE = new Array(128).fill(null);
ESCAPE_TABLE[8] = "b";
ESCAPE_TABLE[9] = "t";
ESCAPE_TABLE[10] = "n";
ESCAPE_TABLE[12] = "f";
ESCAPE_TABLE[13] = "r";
ESCAPE_TABLE[34] = '"';
ESCAPE_TABLE[92] = "\\";
for (let i = 0;i < 32; i++) {
if (ESCAPE_TABLE[i] === null) {
ESCAPE_TABLE[i] = "u00" + i.toString(16).padStart(2, "0");
}
}
var INITIAL_BUFFER_SIZE = 2048;
function alloc(size) {
return JsonBytesStringAdapter.allocUnsafe(size);
}
class JsonShapeSerializer2 extends SerdeContextConfig {
settings;
json;
i = 0;
rootSchema;
rawValue;
passthrough = false;
constructor(settings) {
super();
this.settings = settings;
this.json = alloc(INITIAL_BUFFER_SIZE);
}
write(schema, value) {
this.i = 0;
this.rawValue = value;
this.rootSchema = NormalizedSchema.of(schema);
this.passthrough = this.rootSchema.isBlobSchema() || this.rootSchema.isStringSchema();
if (!this.passthrough) {
this.writeValue(this.rootSchema, value, undefined);
}
}
writeDiscriminatedDocument(schema, value) {
this.i = 0;
this.rootSchema = NormalizedSchema.of(schema);
const ns = this.rootSchema;
if (ns.isStructSchema() && value != null && typeof value === "object") {
this.writeValue(ns, value, undefined);
const prefix = `"__type":"${ns.getName(true) ?? "Unknown"}",`;
const z = prefix.length;
this.ensure(z);
this.json.copyWithin(1 + z, 1, this.i);
encoder.encodeInto(prefix, this.json.subarray(1));
this.i += z;
} else {
this.writeValue(ns, value, undefined);
}
}
flush() {
this.rootSchema = undefined;
const finalPosition = this.i;
this.i = 0;
const raw = this.rawValue;
this.rawValue = undefined;
if (finalPosition === 0) {
return raw;
}
const result = this.json.subarray(0, finalPosition);
this.json = alloc(INITIAL_BUFFER_SIZE);
return result;
}
ensure(byteCount) {
const { i, json } = this;
if (i + byteCount > json.length) {
let newSize = json.length * 2;
while (newSize < i + byteCount) {
newSize *= 2;
}
const next = alloc(newSize);
next.set(this.json);
this.json = next;
}
}
writeAscii(s) {
const z = s.length;
this.ensure(z);
let { i, json } = this;
for (let j = 0;j < z; ++j) {
json[i] = s.charCodeAt(j);
i += 1;
}
this.i = i;
}
writeAsciiQuoted(s) {
const z = s.length;
this.ensure(z + 4);
let { json, i } = this;
json[i++] = QUOTE;
for (let j = 0;j < z; ++j) {
json[i++] = s.charCodeAt(j);
}
json[i++] = QUOTE;
this.i = i;
}
writeJsonString(s) {
this.ensure(s.length * 3 + 2);
this.json[this.i++] = QUOTE;
const z = s.length;
for (let j = 0;j < z; ++j) {
const c = s.charCodeAt(j);
if (c > 34 && c < 92) {
this.json[this.i++] = c;
} else if (c < 128) {
const esc = ESCAPE_TABLE[c];
if (esc !== null) {
this.ensure(esc.length + 1);
this.json[this.i++] = BACKSLASH;
for (let k = 0;k < esc.length; k++) {
this.json[this.i++] = esc.charCodeAt(k);
}
} else {
this.json[this.i++] = c;
}
} else if (c >= 55296 && c <= 56319) {
const next = j + 1 < z ? s.charCodeAt(j + 1) : 0;
if (next >= 56320 && next <= 57343) {
this.ensure(4);
const { written } = encoder.encodeInto(s.substring(j, j + 2), this.json.subarray(this.i));
this.i += written;
++j;
} else {
this.ensure(6);
this.writeUnicodeEscape(c);
}
} else if (c >= 56320 && c <= 57343) {
this.ensure(6);
this.writeUnicodeEscape(c);
} else {
let { i, json } = this;
if (c < 2048) {
json[i++] = 192 | c >> 6;
json[i++] = 128 | c & 63;
} else {
json[i++] = 224 | c >> 12;
json[i++] = 128 | c >> 6 & 63;
json[i++] = 128 | c & 63;
}
this.i = i;
}
}
this.json[this.i++] = QUOTE;
}
writeUnicodeEscape(code) {
let { json, i } = this;
json[i++] = BACKSLASH;
json[i++] = 117;
const hex = code.toString(16).padStart(4, "0");
for (let j = 0;j < 4; ++j) {
json[i++] = hex.charCodeAt(j);
}
this.i = i;
}
static B64 = (() => {
const chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
const table = new Uint8Array(64);
for (let i = 0;i < 64; ++i) {
table[i] = chars.charCodeAt(i);
}
return table;
})();
writeBase64(data) {
const b64Len = Math.ceil(data.length / 3) * 4;
this.ensure(b64Len + 2);
const json = this.json;
const B64 = JsonShapeSerializer2.B64;
let i = this.i;
json[i++] = QUOTE;
const len = data.length;
const remainder = len % 3;
const mainLen = len - remainder;
for (let j = 0;j < mainLen; j += 3) {
const a = data[j];
const b = data[j + 1];
const c = data[j + 2];
json[i++] = B64[a >> 2];
json[i++] = B64[(a & 3) << 4 | b >> 4];
json[i++] = B64[(b & 15) << 2 | c >> 6];
json[i++] = B64[c & 63];
}
if (remainder === 2) {
const a = data[mainLen];
const b = data[mainLen + 1];
json[i++] = B64[a >> 2];
json[i++] = B64[(a & 3) << 4 | b >> 4];
json[i++] = B64[(b & 15) << 2];
json[i++] = 61;
} else if (remainder === 1) {
const a = data[mainLen];
json[i++] = B64[a >> 2];
json[i++] = B64[(a & 3) << 4];
json[i++] = 61;
json[i++] = 61;
}
json[i++] = QUOTE;
this.i = i;
}
writeValue(schema, value, container) {
if (value == null) {
if (container?.isStructSchema()) {
if (value === undefined) {
const ns = NormalizedSchema.of(schema);
if (ns.isIdempotencyToken()) {
this.writeAsciiQuoted(generateIdempotencyToken());
return;
}
}
return;
}
this.ensure(4);
this.json.set(NULL, this.i);
this.i += 4;
return;
}
const ns = NormalizedSchema.of(schema);
const isObject = typeof value === "object";
if (ns.isStringSchema()) {
const mediaType = ns.getMergedTraits().mediaType;
if (mediaType) {
const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
if (isJson) {
this.writeJsonString(LazyJsonString.from(value).toString());
return;
}
}
}
if (isObject) {
if (ns.isStructSchema()) {
this.writeStruct(ns, value);
return;
}
if (Array.isArray(value) && (ns.isListSchema() || ns.isDocumentSchema())) {
this.writeList(ns, value, ns.isDocumentSchema());
return;
}
if (ns.isMapSchema()) {
this.writeMap(ns, value, false);
return;
}
if (value instanceof Uint8Array && (ns.isBlobSchema() || ns.isDocumentSchema())) {
this.writeBase64(value);
return;
}
if (value instanceof Date && (ns.isTimestampSchema() || ns.isDocumentSchema())) {
this.writeTimestamp(ns, value);
return;
}
if (value instanceof NumericValue) {
this.writeAscii(value.string);
return;
}
if (ns.isDocumentSchema()) {
if (Array.isArray(value)) {
this.writeList(ns, value, true);
} else {
this.writeMap(ns, value, true);
}
return;
}
const json = JSON.stringify(value);
this.writeAscii(json);
return;
}
if (typeof value === "string") {
if (ns.isBlobSchema()) {
const b64 = (this.serdeContext?.base64Encoder ?? toBase64)(value);
this.writeAsciiQuoted(b64);
return;
}
this.writeJsonString(value);
return;
}
if (typeof value === "number") {
if (Math.abs(value) === Infinity || Number.isNaN(value)) {
this.writeAsciiQuoted(String(value));
return;
}
const numStr = String(value);
this.writeAscii(numStr);
return;
}
if (typeof value === "boolean") {
this.ensure(5);
let { i, json } = this;
if (value) {
json.set(TRUE, i);
i += 4;
} else {
json.set(FALSE, i);
i += 5;
}
this.i = i;
return;
}
if (typeof value === "bigint") {
this.writeAscii(value.toString());
return;
}
this.writeAscii(String(value));
}
writeStruct(ns, value) {
this.ensure(2);
this.json[this.i++] = OPEN_BRACE;
let wroteAny = false;
const hasType = typeof value.__type === "string";
let writtenKeys;
if (hasType) {
writtenKeys = new Set;
}
for (const [memberName, memberSchema] of ns.structIterator()) {
const item = value[memberName];
if (item == null && !memberSchema.isIdempotencyToken()) {
continue;
}
if (wroteAny) {
this.ensure(1);
this.json[this.i++] = COMMA;
}
wroteAny = true;
const targetKey = this.settings.jsonName ? memberSchema.getMergedTraits().jsonName ?? memberName : memberName;
if (writtenKeys) {
writtenKeys.add(memberName);
writtenKeys.add(targetKey);
}
this.writeAsciiQuoted(targetKey);
this.json[this.i++] = COLON;
this.writeValue(memberSchema, item, ns);
}
if (!wroteAny && ns.isUnionSchema()) {
const { $unknown } = value;
if (Array.isArray($unknown)) {
const [k, v] = $unknown;
this.writeAsciiQuoted(k);
this.ensure(1);
this.json[this.i++] = COLON;
this.writeValue(15, v, ns);
}
} else if (hasType) {
for (const k in value) {
if (writtenKeys.has(k)) {
continue;
}
writtenKeys.add(k);
const v = value[k];
if (wroteAny) {
this.ensure(1);
this.json[this.i++] = COMMA;
}
wroteAny = true;
this.writeAsciiQuoted(k);
this.ensure(1);
this.json[this.i++] = COLON;
this.writeValue(15, v, undefined);
}
}
this.ensure(1);
this.json[this.i++] = CLOSE_BRACE;
}
writeList(ns, value, isDocument) {
const sparse = !!ns.getMergedTraits().sparse;
const valueSchema = ns.getValueSchema();
if (!isDocument) {
if (valueSchema.isStringSchema() || valueSchema.isNumericSchema() || valueSchema.isBooleanSchema()) {
let hasSpecials = false;
for (let i = 0;i < value.length; ++i) {
const v = value[i];
if (Number.isNaN(v) || v === Infinity || v === -Infinity || v == null && !sparse) {
hasSpecials = true;
break;
}
}
let json;
if (!hasSpecials) {
json = JSON.stringify(value);
} else {
const out = [];
for (let i = 0;i < value.length; ++i) {
const v = value[i];
if (v == null && !sparse)
continue;
if (Number.isNaN(v) || v === Infinity || v === -Infinity) {
out.push(String(v));
} else {
out.push(v);
}
}
json = JSON.stringify(out);
}
this.ensure(json.length * 3);
this.i += encoder.encodeInto(json, this.json.subarray(this.i)).written;
return;
}
}
this.ensure(2);
this.json[this.i++] = OPEN_BRACKET;
let wroteFirstItem = false;
for (let i = 0;i < value.length; ++i) {
const item = value[i];
if (isDocument ? item === undefined : item == null && !sparse) {
continue;
}
if (wroteFirstItem) {
this.ensure(1);
this.json[this.i++] = COMMA;
}
this.writeValue(valueSchema, item, undefined);
wroteFirstItem = true;
}
this.ensure(1);
this.json[this.i++] = CLOSE_BRACKET;
}
writeMap(ns, value, isDocument) {
const sparse = !!ns.getMergedTraits().sparse;
const valueSchema = ns.getValueSchema();
if (!isDocument) {
if (valueSchema.isStringSchema() || valueSchema.isNumericSchema() || valueSchema.isBooleanSchema()) {
let modifications;
for (const k in value) {
const v = value[k];
if (Number.isNaN(v) || v === Infinity || v === -Infinity) {
(modifications ??= {})[k] = v;
value[k] = String(v);
} else if (v === null && !sparse) {
(modifications ??= {})[k] = null;
value[k] = undefined;
}
}
const json = JSON.stringify(value);
if (modifications) {
Object.assign(value, modifications);
}
this.ensure(json.length * 3);
this.i += encoder.encodeInto(json, this.json.subarray(this.i)).written;
return;
}
}
this.ensure(2);
this.json[this.i++] = OPEN_BRACE;
let first = true;
for (const k in value) {
const v = value[k];
if (isDocument ? v === undefined : v == null && !sparse) {
continue;
}
if (!first) {
this.ensure(1);
this.json[this.i++] = COMMA;
}
first = false;
this.writeJsonString(k);
this.ensure(1);
this.json[this.i++] = COLON;
this.writeValue(valueSchema, v, undefined);
}
this.ensure(1);
this.json[this.i++] = CLOSE_BRACE;
}
writeTimestamp(ns, value) {
const format = determineTimestampFormat(ns, this.settings);
switch (format) {
case 5: {
const iso = value.toISOString().replace(".000Z", "Z");
this.writeAsciiQuoted(iso);
return;
}
case 6: {
this.writeAsciiQuoted(dateToUtcString(value));
return;
}
case 7: {
const epochSecs = String(value.getTime() / 1000);
this.writeAscii(epochSecs);
return;
}
default: {
const epochSecs = String(value.getTime() / 1000);
this.writeAscii(epochSecs);
return;
}
}
}
}
class JsonCodec2 extends SerdeContextConfig {
settings;
constructor(settings) {
super();
this.settings = settings;
}
createSerializer() {
const serializer = new JsonShapeSerializer2(this.settings);
serializer.setSerdeContext(this.serdeContext);
return serializer;
}
createDeserializer() {
const deserializer = new JsonShapeDeserializer2(this.settings);
deserializer.setSerdeContext(this.serdeContext);
return deserializer;
}
}
class AwsJsonRpcProtocol extends RpcProtocol {
serializer;
deserializer;
serviceTarget;
codec;
mixin;
awsQueryCompatible;
constructor({ defaultNamespace, errorTypeRegistries, serviceTarget, awsQueryCompatible, jsonCodec }) {
super({
defaultNamespace,
errorTypeRegistries
});
this.serviceTarget = serviceTarget;
this.codec = jsonCodec ?? new JsonCodec2({
timestampFormat: {
useTrait: true,
default: 7
},
jsonName: false
});
this.serializer = this.codec.createSerializer();
this.deserializer = this.codec.createDeserializer();
this.awsQueryCompatible = !!awsQueryCompatible;
this.mixin = new ProtocolLib(this.awsQueryCompatible);
}
async serializeRequest(operationSchema, input, context) {
const request = await super.serializeRequest(operationSchema, input, context);
if (!request.path.endsWith("/")) {
request.path += "/";
}
request.headers["content-type"] = `application/x-amz-json-${this.getJsonRpcVersion()}`;
request.headers["x-amz-target"] = `${this.serviceTarget}.${operationSchema.name}`;
if (this.awsQueryCompatible) {
request.headers["x-amzn-query-mode"] = "true";
}
if (deref(operationSchema.input) === "unit" || !request.body) {
request.body = "{}";
}
return request;
}
getPayloadCodec() {
return this.codec;
}
async handleError(operationSchema, context, response, dataObject, metadata) {
const { awsQueryCompatible } = this;
if (awsQueryCompatible) {
this.mixin.setQueryCompatError(dataObject, response);
}
const errorIdentifier = loadJsonRpcErrorCode(response, dataObject, awsQueryCompatible) ?? "Unknown";
this.mixin.compose(this.compositeErrorRegistry, errorIdentifier, this.options.defaultNamespace);
const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, dataObject, metadata, awsQueryCompatible ? this.mixin.findQueryCompatibleError : undefined);
const ns = NormalizedSchema.of(errorSchema);
const message = dataObject.message ?? dataObject.Message ?? "UnknownError";
const ErrorCtor = this.compositeErrorRegistry.getErrorCtor(errorSchema) ?? Error;
const exception = new ErrorCtor({});
const output = {};
const errorDeserializer = this.codec.createDeserializer();
for (const [name, member] of ns.structIterator()) {
if (dataObject[name] != null) {
output[name] = errorDeserializer.readObject(member, dataObject[name]);
}
}
if (awsQueryCompatible) {
this.mixin.queryCompatOutput(dataObject, output);
}
throw this.mixin.decorateServiceException(Object.assign(exception, errorMetadata, {
$fault: ns.getMergedTraits().error,
message
}, output), dataObject);
}
}
class AwsJson1_0Protocol extends AwsJsonRpcProtocol {
constructor({ defaultNamespace, errorTypeRegistries, serviceTarget, awsQueryCompatible, jsonCodec }) {
super({
defaultNamespace,
errorTypeRegistries,
serviceTarget,
awsQueryCompatible,
jsonCodec
});
}
getShapeId() {
return "aws.protocols#awsJson1_0";
}
getJsonRpcVersion() {
return "1.0";
}
getDefaultContentType() {
return "application/x-amz-json-1.0";
}
}
class AwsJson1_1Protocol extends AwsJsonRpcProtocol {
constructor({ defaultNamespace, errorTypeRegistries, serviceTarget, awsQueryCompatible, jsonCodec }) {
super({
defaultNamespace,
errorTypeRegistries,
serviceTarget,
awsQueryCompatible,
jsonCodec
});
}
getShapeId() {
return "aws.protocols#awsJson1_1";
}
getJsonRpcVersion() {
return "1.1";
}
getDefaultContentType() {
return "application/x-amz-json-1.1";
}
}
class AwsRestJsonProtocol extends HttpBindingProtocol {
serializer;
deserializer;
codec;
mixin = new ProtocolLib;
constructor({ defaultNamespace, errorTypeRegistries, jsonCodec }) {
super({
defaultNamespace,
errorTypeRegistries
});
const settings = {
timestampFormat: {
useTrait: true,
default: 7
},
httpBindings: true,
jsonName: true
};
this.codec = jsonCodec ?? new JsonCodec2(settings);
this.serializer = new HttpInterceptingShapeSerializer(this.codec.createSerializer(), settings);
this.deserializer = new HttpInterceptingShapeDeserializer(this.codec.createDeserializer(), settings);
}
getShapeId() {
return "aws.protocols#restJson1";
}
getPayloadCodec() {
return this.codec;
}
setSerdeContext(serdeContext) {
this.codec.setSerdeContext(serdeContext);
super.setSerdeContext(serdeContext);
}
async serializeRequest(operationSchema, input, context) {
const request = await super.serializeRequest(operationSchema, input, context);
const inputSchema = NormalizedSchema.of(operationSchema.input);
if (!request.headers["content-type"]) {
const contentType = this.mixin.resolveRestContentType(this.getDefaultContentType(), inputSchema);
if (contentType) {
request.headers["content-type"] = contentType;
}
}
if (request.body == null && request.headers["content-type"] === this.getDefaultContentType()) {
request.body = "{}";
}
return request;
}
async deserializeResponse(operationSchema, context, response) {
const output = await super.deserializeResponse(operationSchema, context, response);
const outputSchema = NormalizedSchema.of(operationSchema.output);
for (const [name, member] of outputSchema.structIterator()) {
if (member.getMemberTraits().httpPayload && !(name in output)) {
output[name] = null;
}
}
return output;
}
async handleError(operationSchema, context, response, dataObject, metadata) {
const errorIdentifier = loadRestJsonErrorCode(response, dataObject) ?? "Unknown";
this.mixin.compose(this.compositeErrorRegistry, errorIdentifier, this.options.defaultNamespace);
const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, dataObject, metadata);
const ns = NormalizedSchema.of(errorSchema);
const message = dataObject.message ?? dataObject.Message ?? "UnknownError";
const ErrorCtor = this.compositeErrorRegistry.getErrorCtor(errorSchema) ?? Error;
const exception = new ErrorCtor({});
await this.deserializeHttpMessage(errorSchema, context, response, dataObject);
const output = {};
const errorDeserializer = this.codec.createDeserializer();
for (const [name, member] of ns.structIterator()) {
const target = member.getMergedTraits().jsonName ?? name;
output[name] = errorDeserializer.readObject(member, dataObject[target]);
}
throw this.mixin.decorateServiceException(Object.assign(exception, errorMetadata, {
$fault: ns.getMergedTraits().error,
message
}, output), dataObject);
}
getDefaultContentType() {
return "application/json";
}
}
class JsonShapeDeserializer extends SerdeContextConfig {
settings;
constructor(settings) {
super();
this.settings = settings;
}
async read(schema, data) {
const reviver = needsReviver(schema) ? jsonReviver : undefined;
return this._read(schema, typeof data === "string" ? JSON.parse(data, reviver) : await parseJsonBody(data, this.serdeContext, schema));
}
readObject(schema, data) {
return this._read(schema, data);
}
_read(schema, value) {
const isObject = value !== null && typeof value === "object";
const ns = NormalizedSchema.of(schema);
if (isObject) {
if (ns.isStructSchema()) {
const record = value;
const union = ns.isUnionSchema();
const out = {};
let nameMap = undefined;
const { jsonName } = this.settings;
if (jsonName) {
nameMap = {};
}
let unionSerde;
if (union) {
unionSerde = new UnionSerde(record, out);
}
for (const [memberName, memberSchema] of ns.structIterator()) {
let fromKey = memberName;
if (jsonName) {
fromKey = memberSchema.getMergedTraits().jsonName ?? fromKey;
nameMap[fromKey] = memberName;
}
if (union) {
unionSerde.mark(fromKey);
}
if (record[fromKey] != null) {
out[memberName] = this._read(memberSchema, record[fromKey]);
}
}
if (union) {
unionSerde.writeUnknown();
} else if (typeof record.__type === "string") {
for (const k in record) {
const v = record[k];
const t = jsonName ? nameMap[k] ?? k : k;
if (!(t in out)) {
out[t] = v;
}
}
}
return out;
}
if (Array.isArray(value) && ns.isListSchema()) {
const listMember = ns.getValueSchema();
const out = [];
for (const item of value) {
out.push(this._read(listMember, item));
}
return out;
}
if (ns.isMapSchema()) {
const mapMember = ns.getValueSchema();
const out = {};
for (const _k in value) {
if (_k === "__proto__") {
writeKey(out);
}
out[_k] = this._read(mapMember, value[_k]);
}
return out;
}
}
if (ns.isBlobSchema() && typeof value === "string") {
return fromBase64(value);
}
const mediaType = ns.getMergedTraits().mediaType;
if (ns.isStringSchema() && typeof value === "string" && mediaType) {
const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
if (isJson) {
return LazyJsonString.from(value);
}
return value;
}
if (ns.isTimestampSchema() && value != null) {
const format = determineTimestampFormat(ns, this.settings);
switch (format) {
case 5:
return parseRfc3339DateTimeWithOffset(value);
case 6:
return parseRfc7231DateTime(value);
case 7:
return parseEpochTimestamp(value);
default:
console.warn("Missing timestamp format, parsing value with Date constructor:", value);
return new Date(value);
}
}
if (ns.isBigIntegerSchema() && (typeof value === "number" || typeof value === "string")) {
return BigInt(value);
}
if (ns.isBigDecimalSchema() && value != null) {
if (value instanceof NumericValue) {
return value;
}
const untyped = value;
if (untyped.type === "bigDecimal" && "string" in untyped) {
return new NumericValue(untyped.string, untyped.type);
}
return new NumericValue(String(value), "bigDecimal");
}
if (ns.isNumericSchema() && typeof value === "string") {
switch (value) {
case "Infinity":
return Infinity;
case "-Infinity":
return -Infinity;
case "NaN":
return NaN;
}
return value;
}
if (ns.isDocumentSchema()) {
if (isObject) {
const out = Array.isArray(value) ? [] : {};
for (const k in value) {
if (k === "__proto__") {
writeKey(out);
}
const v = value[k];
if (v instanceof NumericValue) {
out[k] = v;
} else {
out[k] = this._read(ns, v);
}
}
return out;
} else {
return structuredClone(value);
}
}
return value;
}
}
var NUMERIC_CONTROL_CHAR = String.fromCharCode(925);
class JsonReplacer {
values = new Map;
counter = 0;
stage = 0;
createReplacer() {
if (this.stage === 1) {
throw new Error("@aws-sdk/core/protocols - JsonReplacer already created.");
}
if (this.stage === 2) {
throw new Error("@aws-sdk/core/protocols - JsonReplacer exhausted.");
}
this.stage = 1;
return (key, value) => {
if (value instanceof NumericValue) {
const v = `${NUMERIC_CONTROL_CHAR + "nv" + this.counter++}_` + value.string;
this.values.set(`"${v}"`, value.string);
return v;
}
if (typeof value === "bigint") {
const s = value.toString();
const v = `${NUMERIC_CONTROL_CHAR + "b" + this.counter++}_` + s;
this.values.set(`"${v}"`, s);
return v;
}
return value;
};
}
replaceInJson(json) {
if (this.stage === 0) {
throw new Error("@aws-sdk/core/protocols - JsonReplacer not created yet.");
}
if (this.stage === 2) {
throw new Error("@aws-sdk/core/protocols - JsonReplacer exhausted.");
}
this.stage = 2;
if (this.counter === 0) {
return json;
}
for (const [key, value] of this.values) {
json = json.replace(key, value);
}
return json;
}
}
class JsonShapeSerializer extends SerdeContextConfig {
settings;
buffer;
useReplacer = false;
rootSchema;
constructor(settings) {
super();
this.settings = settings;
}
write(schema, value) {
this.rootSchema = NormalizedSchema.of(schema);
this.buffer = this._write(this.rootSchema, value);
}
flush() {
const { rootSchema, useReplacer } = this;
this.rootSchema = undefined;
this.useReplacer = false;
if (rootSchema?.isStructSchema() || rootSchema?.isDocumentSchema()) {
if (!useReplacer) {
return JSON.stringify(this.buffer);
}
const replacer = new JsonReplacer;
return replacer.replaceInJson(JSON.stringify(this.buffer, replacer.createReplacer(), 0));
}
return this.buffer;
}
writeDiscriminatedDocument(schema, value) {
this.write(schema, value);
if (typeof this.buffer === "object") {
this.buffer.__type = NormalizedSchema.of(schema).getName(true);
}
}
_write(schema, value, container) {
const isObject = value !== null && typeof value === "object";
const ns = NormalizedSchema.of(schema);
if (isObject) {
if (ns.isStructSchema()) {
const record = value;
const out = {};
const { jsonName } = this.settings;
let nameMap = undefined;
if (jsonName) {
nameMap = {};
}
let outCount = 0;
for (const [memberName, memberSchema] of ns.structIterator()) {
const serializableValue = this._write(memberSchema, record[memberName], ns);
if (serializableValue !== undefined) {
let targetKey = memberName;
if (jsonName) {
targetKey = memberSchema.getMergedTraits().jsonName ?? memberName;
nameMap[memberName] = targetKey;
}
out[targetKey] = serializableValue;
outCount++;
}
}
if (ns.isUnionSchema() && outCount === 0) {
const { $unknown } = record;
if (Array.isArray($unknown)) {
const [k, v] = $unknown;
if (k === "__proto__") {
writeKey(out);
}
out[k] = this._write(15, v);
}
} else if (typeof record.__type === "string") {
for (const k in record) {
const v = record[k];
const targetKey = jsonName ? nameMap[k] ?? k : k;
if (!(targetKey in out)) {
out[targetKey] = this._write(15, v);
}
}
}
return out;
}
if (Array.isArray(value) && ns.isListSchema()) {
const listMember = ns.getValueSchema();
const out = [];
const sparse = !!ns.getMergedTraits().sparse;
for (const item of value) {
if (sparse || item != null) {
out.push(this._write(listMember, item));
}
}
return out;
}
if (ns.isMapSchema()) {
const mapMember = ns.getValueSchema();
const out = {};
const sparse = !!ns.getMergedTraits().sparse;
for (const _k in value) {
const _v = value[_k];
if (sparse || _v != null) {
if (_k === "__proto__") {
writeKey(out);
}
out[_k] = this._write(mapMember, _v);
}
}
return out;
}
if (value instanceof Uint8Array && ns.isBlobSchema()) {
if (ns === this.rootSchema) {
return value;
}
return (this.serdeContext?.base64Encoder ?? toBase64)(value);
}
if (value instanceof Date && (ns.isTimestampSchema() || ns.isDocumentSchema())) {
const format = determineTimestampFormat(ns, this.settings);
switch (format) {
case 5:
return value.toISOString().replace(".000Z", "Z");
case 6:
return dateToUtcString(value);
case 7:
return value.getTime() / 1000;
default:
console.warn("Missing timestamp format, using epoch seconds", value);
return value.getTime() / 1000;
}
}
if (value instanceof NumericValue) {
this.useReplacer = true;
}
}
if (value === null && container?.isStructSchema()) {
return;
}
if (ns.isStringSchema()) {
if (typeof value === "undefined" && ns.isIdempotencyToken()) {
return generateIdempotencyToken();
}
const mediaType = ns.getMergedTraits().mediaType;
if (value != null && mediaType) {
const isJson = mediaType === "application/json" || mediaType.endsWith("+json");
if (isJson) {
return LazyJsonString.from(value);
}
}
return value;
}
if (typeof value === "number") {
if (Math.abs(value) === Infinity || isNaN(value)) {
return String(value);
}
return value;
}
if (typeof value === "string" && ns.isBlobSchema()) {
if (ns === this.rootSchema) {
return value;
}
return (this.serdeContext?.base64Encoder ?? toBase64)(value);
}
if (typeof value === "bigint") {
this.useReplacer = true;
}
if (ns.isDocumentSchema()) {
if (isObject) {
if (value instanceof Uint8Array) {
return (this.serdeContext?.base64Encoder ?? toBase64)(value);
}
const out = Array.isArray(value) ? [] : {};
for (const k in value) {
const v = value[k];
if (k === "__proto__") {
writeKey(out);
}
if (v instanceof NumericValue) {
this.useReplacer = true;
out[k] = v;
} else {
out[k] = this._write(ns, v);
}
}
return out;
} else {
return structuredClone(value);
}
}
return value;
}
}
class JsonCodec extends SerdeContextConfig {
settings;
constructor(settings) {
super();
this.settings = settings;
}
createSerializer() {
const serializer = new JsonShapeSerializer(this.settings);
serializer.setSerdeContext(this.serdeContext);
return serializer;
}
createDeserializer() {
const deserializer = new JsonShapeDeserializer(this.settings);
deserializer.setSerdeContext(this.serdeContext);
return deserializer;
}
}
class XmlShapeDeserializer extends SerdeContextConfig {
settings;
stringDeserializer;
constructor(settings) {
super();
this.settings = settings;
this.stringDeserializer = new FromStringShapeDeserializer(settings);
}
setSerdeContext(serdeContext) {
this.serdeContext = serdeContext;
this.stringDeserializer.setSerdeContext(serdeContext);
}
read(schema, bytes, key) {
const ns = NormalizedSchema.of(schema);
const memberSchemas = ns.getMemberSchemas();
const isEventPayload = ns.isStructSchema() && ns.isMemberSchema() && !!Object.values(memberSchemas).find((memberNs) => {
return !!memberNs.getMemberTraits().eventPayload;
});
if (isEventPayload) {
const output = {};
const memberName = Object.keys(memberSchemas)[0];
const eventMemberSchema = memberSchemas[memberName];
if (eventMemberSchema.isBlobSchema()) {
output[memberName] = bytes;
} else {
output[memberName] = this.read(memberSchemas[memberName], bytes);
}
return output;
}
const xmlString = (this.serdeContext?.utf8Encoder ?? toUtf8)(bytes);
const parsedObject = this.parseXml(xmlString);
return this.readSchema(schema, key ? parsedObject[key] : parsedObject);
}
readSchema(_schema, value) {
const ns = NormalizedSchema.of(_schema);
if (ns.isUnitSchema()) {
return;
}
const traits = ns.getMergedTraits();
if (ns.isListSchema() && !Array.isArray(value)) {
return this.readSchema(ns, [value]);
}
if (value == null) {
return value;
}
if (typeof value === "object") {
const flat = !!traits.xmlFlattened;
if (ns.isListSchema()) {
const listValue = ns.getValueSchema();
const buffer = [];
const sourceKey = listValue.getMergedTraits().xmlName ?? "member";
const source = flat ? value : (value[0] ?? value)[sourceKey];
if (source == null) {
return buffer;
}
const sourceArray = Array.isArray(source) ? source : [source];
for (const v of sourceArray) {
buffer.push(this.readSchema(listValue, v));
}
return buffer;
}
const buffer = {};
if (ns.isMapSchema()) {
const keyNs = ns.getKeySchema();
const memberNs = ns.getValueSchema();
let entries;
if (flat) {
entries = Array.isArray(value) ? value : [value];
} else {
entries = Array.isArray(value.entry) ? value.entry : [value.entry];
}
const keyProperty = keyNs.getMergedTraits().xmlName ?? "key";
const valueProperty = memberNs.getMergedTraits().xmlName ?? "value";
for (const entry of entries) {
const key = entry[keyProperty];
const value = entry[valueProperty];
if (key === "__proto__") {
writeKey(buffer);
}
buffer[key] = this.readSchema(memberNs, value);
}
return buffer;
}
if (ns.isStructSchema()) {
const union = ns.isUnionSchema();
let unionSerde;
if (union) {
unionSerde = new UnionSerde(value, buffer);
}
for (const [memberName, memberSchema] of ns.structIterator()) {
const memberTraits = memberSchema.getMergedTraits();
const xmlObjectKey = !memberTraits.httpPayload ? memberSchema.getMemberTraits().xmlName ?? memberName : memberTraits.xmlName ?? memberSchema.getName();
if (union) {
unionSerde.mark(xmlObjectKey);
}
if (value[xmlObjectKey] != null) {
buffer[memberName] = this.readSchema(memberSchema, value[xmlObjectKey]);
}
}
if (union) {
unionSerde.writeUnknown();
}
return buffer;
}
if (ns.isDocumentSchema()) {
return value;
}
throw new Error(`@aws-sdk/core/protocols - xml deserializer unhandled schema type for ${ns.getName(true)}`);
}
if (ns.isListSchema()) {
return [];
}
if (ns.isMapSchema() || ns.isStructSchema()) {
return {};
}
return this.stringDeserializer.read(ns, value);
}
parseXml(xml) {
if (xml.length) {
let parsedObj;
try {
parsedObj = parseXML(xml);
} catch (e) {
if (e && typeof e === "object") {
Object.defineProperty(e, "$responseBodyText", {
value: xml
});
}
throw e;
}
const textNodeName = "#text";
const key = Object.keys(parsedObj)[0];
const parsedObjToReturn = parsedObj[key];
if (parsedObjToReturn[textNodeName]) {
parsedObjToReturn[key] = parsedObjToReturn[textNodeName];
delete parsedObjToReturn[textNodeName];
}
return getValueFromTextNode(parsedObjToReturn);
}
return {};
}
}
class QueryShapeSerializer extends SerdeContextConfig {
settings;
buffer;
constructor(settings) {
super();
this.settings = settings;
}
write(schema, value, prefix = "") {
if (this.buffer === undefined) {
this.buffer = "";
}
const ns = NormalizedSchema.of(schema);
if (prefix && !prefix.endsWith(".")) {
prefix += ".";
}
if (ns.isBlobSchema()) {
if (typeof value === "string" || value instanceof Uint8Array) {
this.writeKey(prefix);
this.writeValue((this.serdeContext?.base64Encoder ?? toBase64)(value));
}
} else if (ns.isBooleanSchema() || ns.isNumericSchema() || ns.isStringSchema()) {
if (value != null) {
this.writeKey(prefix);
this.writeValue(String(value));
} else if (ns.isIdempotencyToken()) {
this.writeKey(prefix);
this.writeValue(generateIdempotencyToken());
}
} else if (ns.isBigIntegerSchema()) {
if (value != null) {
this.writeKey(prefix);
this.writeValue(String(value));
}
} else if (ns.isBigDecimalSchema()) {
if (value != null) {
this.writeKey(prefix);
this.writeValue(value instanceof NumericValue ? value.string : String(value));
}
} else if (ns.isTimestampSchema()) {
if (value instanceof Date) {
this.writeKey(prefix);
const format = determineTimestampFormat(ns, this.settings);
switch (format) {
case 5:
this.writeValue(value.toISOString().replace(".000Z", "Z"));
break;
case 6:
this.writeValue(dateToUtcString(value));
break;
case 7:
this.writeValue(String(value.getTime() / 1000));
break;
}
}
} else if (ns.isDocumentSchema()) {
if (Array.isArray(value)) {
this.write(64 | 15, value, prefix);
} else if (value instanceof Date) {
this.write(4, value, prefix);
} else if (value instanceof Uint8Array) {
this.write(21, value, prefix);
} else if (value && typeof value === "object") {
this.write(128 | 15, value, prefix);
} else {
this.writeKey(prefix);
this.writeValue(String(value));
}
} else if (ns.isListSchema()) {
if (Array.isArray(value)) {
if (value.length === 0) {
if (this.settings.serializeEmptyLists) {
this.writeKey(prefix);
this.writeValue("");
}
} else {
const member = ns.getValueSchema();
const flat = this.settings.flattenLists || ns.getMergedTraits().xmlFlattened;
let i = 1;
for (const item of value) {
if (item == null) {
continue;
}
const traits = member.getMergedTraits();
const suffix = this.getKey("member", traits.xmlName, traits.ec2QueryName);
const key = flat ? `${prefix}${i}` : `${prefix}${suffix}.${i}`;
this.write(member, item, key);
++i;
}
}
}
} else if (ns.isMapSchema()) {
if (value && typeof value === "object") {
const keySchema = ns.getKeySchema();
const memberSchema = ns.getValueSchema();
const flat = ns.getMergedTraits().xmlFlattened;
let i = 1;
for (const k in value) {
const v = value[k];
if (v == null) {
continue;
}
const keyTraits = keySchema.getMergedTraits();
const keySuffix = this.getKey("key", keyTraits.xmlName, keyTraits.ec2QueryName);
const key = flat ? `${prefix}${i}.${keySuffix}` : `${prefix}entry.${i}.${keySuffix}`;
const valTraits = memberSchema.getMergedTraits();
const valueSuffix = this.getKey("value", valTraits.xmlName, valTraits.ec2QueryName);
const valueKey = flat ? `${prefix}${i}.${valueSuffix}` : `${prefix}entry.${i}.${valueSuffix}`;
this.write(keySchema, k, key);
this.write(memberSchema, v, valueKey);
++i;
}
}
} else if (ns.isStructSchema()) {
if (value && typeof value === "object") {
let didWriteMember = false;
for (const [memberName, member] of ns.structIterator()) {
if (value[memberName] == null && !member.isIdempotencyToken()) {
continue;
}
const traits = member.getMergedTraits();
const suffix = this.getKey(memberName, traits.xmlName, traits.ec2QueryName, "struct");
const key = `${prefix}${suffix}`;
this.write(member, value[memberName], key);
didWriteMember = true;
}
if (!didWriteMember && ns.isUnionSchema()) {
const { $unknown } = value;
if (Array.isArray($unknown)) {
const [k, v] = $unknown;
const key = `${prefix}${k}`;
this.write(15, v, key);
}
}
}
} else if (ns.isUnitSchema())
;
else {
throw new Error(`@aws-sdk/core/protocols - QuerySerializer unrecognized schema type ${ns.getName(true)}`);
}
}
flush() {
if (this.buffer === undefined) {
throw new Error("@aws-sdk/core/protocols - QuerySerializer cannot flush with nothing written to buffer.");
}
const str = this.buffer;
delete this.buffer;
return str;
}
getKey(memberName, xmlName, ec2QueryName, keySource) {
const { ec2, capitalizeKeys } = this.settings;
if (ec2 && ec2QueryName) {
return ec2QueryName;
}
const key = xmlName ?? memberName;
if (capitalizeKeys && keySource === "struct") {
return key[0].toUpperCase() + key.slice(1);
}
return key;
}
writeKey(key) {
if (key.endsWith(".")) {
key = key.slice(0, key.length - 1);
}
this.buffer += `&${extendedEncodeURIComponent(key)}=`;
}
writeValue(value) {
this.buffer += extendedEncodeURIComponent(value);
}
}
class AwsQueryProtocol extends RpcProtocol {
options;
serializer;
deserializer;
mixin = new ProtocolLib;
constructor(options) {
super({
defaultNamespace: options.defaultNamespace,
errorTypeRegistries: options.errorTypeRegistries
});
this.options = options;
const settings = {
timestampFormat: {
useTrait: true,
default: 5
},
httpBindings: false,
xmlNamespace: options.xmlNamespace,
serviceNamespace: options.defaultNamespace,
serializeEmptyLists: true
};
this.serializer = new QueryShapeSerializer(settings);
this.deserializer = new XmlShapeDeserializer(settings);
}
getShapeId() {
return "aws.protocols#awsQuery";
}
setSerdeContext(serdeContext) {
this.serializer.setSerdeContext(serdeContext);
this.deserializer.setSerdeContext(serdeContext);
}
getPayloadCodec() {
throw new Error("AWSQuery protocol has no payload codec.");
}
async serializeRequest(operationSchema, input, context) {
const request = await super.serializeRequest(operationSchema, input, context);
if (!request.path.endsWith("/")) {
request.path += "/";
}
request.headers["content-type"] = "application/x-www-form-urlencoded";
if (deref(operationSchema.input) === "unit" || !request.body) {
request.body = "";
}
const action = operationSchema.name.split("#")[1] ?? operationSchema.name;
request.body = `Action=${action}&Version=${this.options.version}` + request.body;
if (request.body.endsWith("&")) {
request.body = request.body.slice(-1);
}
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(15, bytes));
}
await this.handleError(operationSchema, context, response, dataObject, this.deserializeMetadata(response));
}
for (const header in response.headers) {
const value = response.headers[header];
delete response.headers[header];
response.headers[header.toLowerCase()] = value;
}
const shortName = operationSchema.name.split("#")[1] ?? operationSchema.name;
const awsQueryResultKey = ns.isStructSchema() && this.useNestedResult() ? shortName + "Result" : undefined;
const bytes = await collectBody(response.body, context);
if (bytes.byteLength > 0) {
Object.assign(dataObject, await deserializer.read(ns, bytes, awsQueryResultKey));
}
dataObject.$metadata = this.deserializeMetadata(response);
return dataObject;
}
useNestedResult() {
return true;
}
async handleError(operationSchema, context, response, dataObject, metadata) {
const errorIdentifier = this.loadQueryErrorCode(response, dataObject) ?? "Unknown";
this.mixin.compose(this.compositeErrorRegistry, errorIdentifier, this.options.defaultNamespace);
const errorData = this.loadQueryError(dataObject) ?? {};
const message = this.loadQueryErrorMessage(dataObject);
errorData.message = message;
errorData.Error = {
Type: errorData.Type,
Code: errorData.Code,
Message: message
};
const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, errorData, metadata, this.mixin.findQueryCompatibleError);
const ns = NormalizedSchema.of(errorSchema);
const ErrorCtor = this.compositeErrorRegistry.getErrorCtor(errorSchema) ?? Error;
const exception = new ErrorCtor({});
const output = {
Type: errorData.Error.Type,
Code: errorData.Error.Code,
Error: errorData.Error
};
for (const [name, member] of ns.structIterator()) {
const target = member.getMergedTraits().xmlName ?? name;
const value = errorData[target] ?? dataObject[target];
output[name] = this.deserializer.readSchema(member, value);
}
throw this.mixin.decorateServiceException(Object.assign(exception, errorMetadata, {
$fault: ns.getMergedTraits().error,
message
}, output), dataObject);
}
loadQueryErrorCode(output, data) {
const code = (data.Errors?.[0]?.Error ?? data.Errors?.Error ?? data.Error)?.Code;
if (code !== undefined) {
return code;
}
if (output.statusCode == 404) {
return "NotFound";
}
}
loadQueryError(data) {
return data.Errors?.[0]?.Error ?? data.Errors?.Error ?? data.Error;
}
loadQueryErrorMessage(data) {
const errorData = this.loadQueryError(data);
return errorData?.message ?? errorData?.Message ?? data.message ?? data.Message ?? "Unknown";
}
getDefaultContentType() {
return "application/x-www-form-urlencoded";
}
}
class AwsEc2QueryProtocol extends AwsQueryProtocol {
options;
constructor(options) {
super(options);
this.options = options;
const ec2Settings = {
capitalizeKeys: true,
flattenLists: true,
serializeEmptyLists: false,
ec2: true
};
Object.assign(this.serializer.settings, ec2Settings);
}
getShapeId() {
return "aws.protocols#ec2Query";
}
useNestedResult() {
return false;
}
}
var parseXmlBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => {
if (encoded.length) {
let parsedObj;
try {
parsedObj = parseXML(encoded);
} catch (e) {
if (e && typeof e === "object") {
Object.defineProperty(e, "$responseBodyText", {
value: encoded
});
}
throw e;
}
const textNodeName = "#text";
const key = Object.keys(parsedObj)[0];
const parsedObjToReturn = parsedObj[key];
if (parsedObjToReturn[textNodeName]) {
parsedObjToReturn[key] = parsedObjToReturn[textNodeName];
delete parsedObjToReturn[textNodeName];
}
return getValueFromTextNode(parsedObjToReturn);
}
return {};
});
var parseXmlErrorBody = async (errorBody, context) => {
const value = await parseXmlBody(errorBody, context);
if (value.Error) {
value.Error.message = value.Error.message ?? value.Error.Message;
}
return value;
};
var loadRestXmlErrorCode = (output, data) => {
if (data?.Error?.Code !== undefined) {
return data.Error.Code;
}
if (data?.Code !== undefined) {
return data.Code;
}
if (output.statusCode == 404) {
return "NotFound";
}
};
class XmlShapeSerializer extends SerdeContextConfig {
settings;
stringBuffer;
byteBuffer;
buffer;
constructor(settings) {
super();
this.settings = settings;
}
write(schema, value) {
const ns = NormalizedSchema.of(schema);
if (ns.isStringSchema() && typeof value === "string") {
this.stringBuffer = value;
} else if (ns.isBlobSchema()) {
this.byteBuffer = "byteLength" in value ? value : (this.serdeContext?.base64Decoder ?? fromBase64)(value);
} else {
this.buffer = this.writeStruct(ns, value, undefined);
const traits = ns.getMergedTraits();
if (traits.httpPayload && !traits.xmlName) {
this.buffer.withName(ns.getName());
}
}
}
flush() {
if (this.byteBuffer !== undefined) {
const bytes = this.byteBuffer;
delete this.byteBuffer;
return bytes;
}
if (this.stringBuffer !== undefined) {
const str = this.stringBuffer;
delete this.stringBuffer;
return str;
}
const buffer = this.buffer;
if (this.settings.xmlNamespace) {
if (!buffer?.attributes?.["xmlns"]) {
buffer.addAttribute("xmlns", this.settings.xmlNamespace);
}
}
delete this.buffer;
return buffer.toString();
}
writeStruct(ns, value, parentXmlns) {
const traits = ns.getMergedTraits();
const name = ns.isMemberSchema() && !traits.httpPayload ? ns.getMemberTraits().xmlName ?? ns.getMemberName() : traits.xmlName ?? ns.getName();
if (!name || !ns.isStructSchema()) {
throw new Error(`@aws-sdk/core/protocols - xml serializer, cannot write struct with empty name or non-struct, schema=${ns.getName(true)}.`);
}
const structXmlNode = XmlNode.of(name);
const [xmlnsAttr, xmlns] = this.getXmlnsAttribute(ns, parentXmlns);
for (const [memberName, memberSchema] of ns.structIterator()) {
const val = value[memberName];
if (val != null || memberSchema.isIdempotencyToken()) {
if (memberSchema.getMergedTraits().xmlAttribute) {
structXmlNode.addAttribute(memberSchema.getMergedTraits().xmlName ?? memberName, this.writeSimple(memberSchema, val));
continue;
}
if (memberSchema.isListSchema()) {
this.writeList(memberSchema, val, structXmlNode, xmlns);
} else if (memberSchema.isMapSchema()) {
this.writeMap(memberSchema, val, structXmlNode, xmlns);
} else if (memberSchema.isStructSchema()) {
structXmlNode.addChildNode(this.writeStruct(memberSchema, val, xmlns));
} else {
const memberNode = XmlNode.of(memberSchema.getMergedTraits().xmlName ?? memberSchema.getMemberName());
this.writeSimpleInto(memberSchema, val, memberNode, xmlns);
structXmlNode.addChildNode(memberNode);
}
}
}
const { $unknown } = value;
if ($unknown && ns.isUnionSchema() && Array.isArray($unknown) && Object.keys(value).length === 1) {
const [k, v] = $unknown;
const node = XmlNode.of(k);
if (typeof v !== "string") {
if (value instanceof XmlNode || value instanceof XmlText) {
structXmlNode.addChildNode(value);
} else {
throw new Error(`@aws-sdk - $unknown union member in XML requires ` + `value of type string, @aws-sdk/xml-builder::XmlNode or XmlText.`);
}
}
this.writeSimpleInto(0, v, node, xmlns);
structXmlNode.addChildNode(node);
}
if (xmlns) {
structXmlNode.addAttribute(xmlnsAttr, xmlns);
}
return structXmlNode;
}
writeList(listMember, array, container, parentXmlns) {
if (!listMember.isMemberSchema()) {
throw new Error(`@aws-sdk/core/protocols - xml serializer, cannot write non-member list: ${listMember.getName(true)}`);
}
const listTraits = listMember.getMergedTraits();
const listValueSchema = listMember.getValueSchema();
const listValueTraits = listValueSchema.getMergedTraits();
const sparse = !!listValueTraits.sparse;
const flat = !!listTraits.xmlFlattened;
const [xmlnsAttr, xmlns] = this.getXmlnsAttribute(listMember, parentXmlns);
const writeItem = (container, value) => {
if (listValueSchema.isListSchema()) {
this.writeList(listValueSchema, Array.isArray(value) ? value : [value], container, xmlns);
} else if (listValueSchema.isMapSchema()) {
this.writeMap(listValueSchema, value, container, xmlns);
} else if (listValueSchema.isStructSchema()) {
const struct = this.writeStruct(listValueSchema, value, xmlns);
container.addChildNode(struct.withName(flat ? listTraits.xmlName ?? listMember.getMemberName() : listValueTraits.xmlName ?? "member"));
} else {
const listItemNode = XmlNode.of(flat ? listTraits.xmlName ?? listMember.getMemberName() : listValueTraits.xmlName ?? "member");
this.writeSimpleInto(listValueSchema, value, listItemNode, xmlns);
container.addChildNode(listItemNode);
}
};
if (flat) {
for (const value of array) {
if (sparse || value != null) {
writeItem(container, value);
}
}
} else {
const listNode = XmlNode.of(listTraits.xmlName ?? listMember.getMemberName());
if (xmlns) {
listNode.addAttribute(xmlnsAttr, xmlns);
}
for (const value of array) {
if (sparse || value != null) {
writeItem(listNode, value);
}
}
container.addChildNode(listNode);
}
}
writeMap(mapMember, map, container, parentXmlns, containerIsMap = false) {
if (!mapMember.isMemberSchema()) {
throw new Error(`@aws-sdk/core/protocols - xml serializer, cannot write non-member map: ${mapMember.getName(true)}`);
}
const mapTraits = mapMember.getMergedTraits();
const mapKeySchema = mapMember.getKeySchema();
const mapKeyTraits = mapKeySchema.getMergedTraits();
const keyTag = mapKeyTraits.xmlName ?? "key";
const mapValueSchema = mapMember.getValueSchema();
const mapValueTraits = mapValueSchema.getMergedTraits();
const valueTag = mapValueTraits.xmlName ?? "value";
const sparse = !!mapValueTraits.sparse;
const flat = !!mapTraits.xmlFlattened;
const [xmlnsAttr, xmlns] = this.getXmlnsAttribute(mapMember, parentXmlns);
const addKeyValue = (entry, key, val) => {
const keyNode = XmlNode.of(keyTag, key);
const [keyXmlnsAttr, keyXmlns] = this.getXmlnsAttribute(mapKeySchema, xmlns);
if (keyXmlns) {
keyNode.addAttribute(keyXmlnsAttr, keyXmlns);
}
entry.addChildNode(keyNode);
let valueNode = XmlNode.of(valueTag);
if (mapValueSchema.isListSchema()) {
this.writeList(mapValueSchema, val, valueNode, xmlns);
} else if (mapValueSchema.isMapSchema()) {
this.writeMap(mapValueSchema, val, valueNode, xmlns, true);
} else if (mapValueSchema.isStructSchema()) {
valueNode = this.writeStruct(mapValueSchema, val, xmlns);
} else {
this.writeSimpleInto(mapValueSchema, val, valueNode, xmlns);
}
entry.addChildNode(valueNode);
};
if (flat) {
for (const key in map) {
const val = map[key];
if (sparse || val != null) {
const entry = XmlNode.of(mapTraits.xmlName ?? mapMember.getMemberName());
addKeyValue(entry, key, val);
container.addChildNode(entry);
}
}
} else {
let mapNode;
if (!containerIsMap) {
mapNode = XmlNode.of(mapTraits.xmlName ?? mapMember.getMemberName());
if (xmlns) {
mapNode.addAttribute(xmlnsAttr, xmlns);
}
container.addChildNode(mapNode);
}
for (const key in map) {
const val = map[key];
if (sparse || val != null) {
const entry = XmlNode.of("entry");
addKeyValue(entry, key, val);
(containerIsMap ? container : mapNode).addChildNode(entry);
}
}
}
}
writeSimple(_schema, value) {
if (value === null) {
throw new Error("@aws-sdk/core/protocols - (XML serializer) cannot write null value.");
}
const ns = NormalizedSchema.of(_schema);
let nodeContents = null;
if (value && typeof value === "object") {
if (ns.isBlobSchema()) {
nodeContents = (this.serdeContext?.base64Encoder ?? toBase64)(value);
} else if (ns.isTimestampSchema() && value instanceof Date) {
const format = determineTimestampFormat(ns, this.settings);
switch (format) {
case 5:
nodeContents = value.toISOString().replace(".000Z", "Z");
break;
case 6:
nodeContents = dateToUtcString(value);
break;
case 7:
nodeContents = String(value.getTime() / 1000);
break;
default:
console.warn("Missing timestamp format, using http date", value);
nodeContents = dateToUtcString(value);
break;
}
} else if (ns.isBigDecimalSchema() && value) {
if (value instanceof NumericValue) {
return value.string;
}
return String(value);
} else if (ns.isMapSchema() || ns.isListSchema()) {
throw new Error("@aws-sdk/core/protocols - xml serializer, cannot call _write() on List/Map schema, call writeList or writeMap() instead.");
} else {
throw new Error(`@aws-sdk/core/protocols - xml serializer, unhandled schema type for object value and schema: ${ns.getName(true)}`);
}
}
if (ns.isBooleanSchema() || ns.isNumericSchema() || ns.isBigIntegerSchema() || ns.isBigDecimalSchema()) {
nodeContents = String(value);
}
if (ns.isStringSchema()) {
if (value === undefined && ns.isIdempotencyToken()) {
nodeContents = generateIdempotencyToken();
} else {
nodeContents = String(value);
}
}
if (nodeContents === null) {
throw new Error(`Unhandled schema-value pair ${ns.getName(true)}=${value}`);
}
return nodeContents;
}
writeSimpleInto(_schema, value, into, parentXmlns) {
const nodeContents = this.writeSimple(_schema, value);
const ns = NormalizedSchema.of(_schema);
const content = new XmlText(nodeContents);
const [xmlnsAttr, xmlns] = this.getXmlnsAttribute(ns, parentXmlns);
if (xmlns) {
into.addAttribute(xmlnsAttr, xmlns);
}
into.addChildNode(content);
}
getXmlnsAttribute(ns, parentXmlns) {
const traits = ns.getMergedTraits();
const [prefix, xmlns] = traits.xmlNamespace ?? [];
if (xmlns && xmlns !== parentXmlns) {
return [prefix ? `xmlns:${prefix}` : "xmlns", xmlns];
}
return [undefined, undefined];
}
}
class XmlCodec extends SerdeContextConfig {
settings;
constructor(settings) {
super();
this.settings = settings;
}
createSerializer() {
const serializer = new XmlShapeSerializer(this.settings);
serializer.setSerdeContext(this.serdeContext);
return serializer;
}
createDeserializer() {
const deserializer = new XmlShapeDeserializer(this.settings);
deserializer.setSerdeContext(this.serdeContext);
return deserializer;
}
}
class AwsRestXmlProtocol extends HttpBindingProtocol {
codec;
serializer;
deserializer;
mixin = new ProtocolLib;
constructor(options) {
super(options);
const settings = {
timestampFormat: {
useTrait: true,
default: 5
},
httpBindings: true,
xmlNamespace: options.xmlNamespace,
serviceNamespace: options.defaultNamespace
};
this.codec = new XmlCodec(settings);
this.serializer = new HttpInterceptingShapeSerializer(this.codec.createSerializer(), settings);
this.deserializer = new HttpInterceptingShapeDeserializer(this.codec.createDeserializer(), settings);
}
getPayloadCodec() {
return this.codec;
}
getShapeId() {
return "aws.protocols#restXml";
}
async serializeRequest(operationSchema, input, context) {
const request = await super.serializeRequest(operationSchema, input, context);
const inputSchema = NormalizedSchema.of(operationSchema.input);
if (!request.headers["content-type"]) {
const contentType = this.mixin.resolveRestContentType(this.getDefaultContentType(), inputSchema);
if (contentType) {
request.headers["content-type"] = contentType;
}
}
if (typeof request.body === "string" && request.headers["content-type"] === this.getDefaultContentType() && !request.body.startsWith("<?xml ") && !this.hasUnstructuredPayloadBinding(inputSchema)) {
request.body = '<?xml version="1.0" encoding="UTF-8"?>' + request.body;
}
return request;
}
async deserializeResponse(operationSchema, context, response) {
return super.deserializeResponse(operationSchema, context, response);
}
async handleError(operationSchema, context, response, dataObject, metadata) {
const errorIdentifier = loadRestXmlErrorCode(response, dataObject) ?? "Unknown";
this.mixin.compose(this.compositeErrorRegistry, errorIdentifier, this.options.defaultNamespace);
if (dataObject.Error && typeof dataObject.Error === "object") {
for (const key of Object.keys(dataObject.Error)) {
dataObject[key] = dataObject.Error[key];
if (key.toLowerCase() === "message") {
dataObject.message = dataObject.Error[key];
}
}
}
if (dataObject.RequestId && !metadata.requestId) {
metadata.requestId = dataObject.RequestId;
}
const { errorSchema, errorMetadata } = await this.mixin.getErrorSchemaOrThrowBaseException(errorIdentifier, this.options.defaultNamespace, response, dataObject, metadata);
const ns = NormalizedSchema.of(errorSchema);
const message = dataObject.Error?.message ?? dataObject.Error?.Message ?? dataObject.message ?? dataObject.Message ?? "UnknownError";
const ErrorCtor = this.compositeErrorRegistry.getErrorCtor(errorSchema) ?? Error;
const exception = new ErrorCtor({});
await this.deserializeHttpMessage(errorSchema, context, response, dataObject);
const output = {};
const errorDeserializer = this.codec.createDeserializer();
for (const [name, member] of ns.structIterator()) {
const target = member.getMergedTraits().xmlName ?? name;
const value = dataObject.Error?.[target] ?? dataObject[target];
output[name] = errorDeserializer.readSchema(member, value);
}
throw this.mixin.decorateServiceException(Object.assign(exception, errorMetadata, {
$fault: ns.getMergedTraits().error,
message
}, output), dataObject);
}
getDefaultContentType() {
return "application/xml";
}
hasUnstructuredPayloadBinding(ns) {
for (const [, member] of ns.structIterator()) {
if (member.getMergedTraits().httpPayload) {
return !(member.isStructSchema() || member.isMapSchema() || member.isListSchema());
}
}
return false;
}
}
var awsExpectUnion = (value) => {
if (value == null) {
return;
}
if (typeof value === "object" && "__type" in value) {
delete value.__type;
}
return expectUnion(value);
};
var _toStr = (val) => {
if (val == null) {
return val;
}
if (typeof val === "number" || typeof val === "bigint") {
const warning = new Error(`Received number ${val} where a string was expected.`);
warning.name = "Warning";
console.warn(warning);
return String(val);
}
if (typeof val === "boolean") {
const warning = new Error(`Received boolean ${val} where a string was expected.`);
warning.name = "Warning";
console.warn(warning);
return String(val);
}
return val;
};
var _toBool = (val) => {
if (val == null) {
return val;
}
if (typeof val === "string") {
const lowercase = val.toLowerCase();
if (val !== "" && lowercase !== "false" && lowercase !== "true") {
const warning = new Error(`Received string "${val}" where a boolean was expected.`);
warning.name = "Warning";
console.warn(warning);
}
return val !== "" && lowercase !== "false";
}
return val;
};
var _toNum = (val) => {
if (val == null) {
return val;
}
if (typeof val === "string") {
const num = Number(val);
if (num.toString() !== val) {
const warning = new Error(`Received string "${val}" where a number was expected.`);
warning.name = "Warning";
console.warn(warning);
return val;
}
return num;
}
return val;
};
exports.AwsEc2QueryProtocol = AwsEc2QueryProtocol;
exports.AwsJson1_0Protocol = AwsJson1_0Protocol;
exports.AwsJson1_1Protocol = AwsJson1_1Protocol;
exports.AwsJsonRpcProtocol = AwsJsonRpcProtocol;
exports.AwsQueryProtocol = AwsQueryProtocol;
exports.AwsRestJsonProtocol = AwsRestJsonProtocol;
exports.AwsRestXmlProtocol = AwsRestXmlProtocol;
exports.AwsSmithyRpcV2CborProtocol = AwsSmithyRpcV2CborProtocol;
exports.JsonCodec = JsonCodec;
exports.JsonCodec2 = JsonCodec2;
exports.JsonShapeDeserializer = JsonShapeDeserializer;
exports.JsonShapeDeserializer2 = JsonShapeDeserializer2;
exports.JsonShapeSerializer = JsonShapeSerializer;
exports.JsonShapeSerializer2 = JsonShapeSerializer2;
exports.QueryShapeSerializer = QueryShapeSerializer;
exports.XmlCodec = XmlCodec;
exports.XmlShapeDeserializer = XmlShapeDeserializer;
exports.XmlShapeSerializer = XmlShapeSerializer;
exports._toBool = _toBool;
exports._toNum = _toNum;
exports._toStr = _toStr;
exports.awsExpectUnion = awsExpectUnion;
exports.loadJsonRpcErrorCode = loadJsonRpcErrorCode;
exports.loadRestJsonErrorCode = loadRestJsonErrorCode;
exports.loadRestXmlErrorCode = loadRestXmlErrorCode;
exports.parseJsonBody = parseJsonBody;
exports.parseJsonErrorBody = parseJsonErrorBody;
exports.parseXmlBody = parseXmlBody;
exports.parseXmlErrorBody = parseXmlErrorBody;
});
// ../../node_modules/.bun/@aws-sdk+nested-clients@3.997.44/node_modules/@aws-sdk/nested-clients/dist-cjs/submodules/sso-oidc/index.js
var require_sso_oidc = __commonJS(function(exports) {
var { awsEndpointFunctions, emitWarningIfUnsupportedVersion: emitWarningIfUnsupportedVersion$1, createDefaultUserAgentProvider, NODE_APP_ID_CONFIG_OPTIONS, getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require_client2();
var { NoAuthSigner, getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin } = require_dist_cjs2();
var { normalizeProvider, getSmithyContext, ServiceException, NoOpLogger, emitWarningIfUnsupportedVersion, loadConfigsForDefaultMode, getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, makeBuilder, createAggregatedClient } = require_client();
var { Command: $Command } = require_client();
exports.$Command = $Command;
exports.__Client = Client;
var { resolveDefaultsModeConfig, loadConfig, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS, resolveRegionConfig } = require_config();
var { BinaryDecisionDiagram, EndpointCache, decideEndpoint, customEndpointFunctions, resolveEndpointConfig, getEndpointPlugin } = require_endpoints();
var { parseUrl, getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require_protocols();
var { DEFAULT_RETRY_MODE, NODE_RETRY_MODE_CONFIG_OPTIONS, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, resolveRetryConfig, getRetryPlugin } = require_retry();
var { TypeRegistry, getSchemaSerdePlugin } = require_schema();
var { resolveAwsSdkSigV4Config, AwsSdkSigV4Signer, NODE_AUTH_SCHEME_PREFERENCE_OPTIONS } = require_httpAuthSchemes();
var { toUtf8, fromUtf8, toBase64, fromBase64, calculateBodyLength } = require_serde();
var { streamCollector, NodeHttpHandler } = require_dist_cjs4();
var { AwsRestJsonProtocol } = require_protocols2();
var { Sha256 } = require_checksum();
var defaultSSOOIDCHttpAuthSchemeParametersProvider = async (config, context, input) => {
return {
operation: getSmithyContext(context).operation,
region: await normalizeProvider(config.region)() || (() => {
throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
})()
};
};
function createAwsAuthSigv4HttpAuthOption(authParameters) {
return {
schemeId: "aws.auth#sigv4",
signingProperties: {
name: "sso-oauth",
region: authParameters.region
},
propertiesExtractor: (config, context) => ({
signingProperties: {
config,
context
}
})
};
}
function createSmithyApiNoAuthHttpAuthOption(authParameters) {
return {
schemeId: "smithy.api#noAuth"
};
}
var defaultSSOOIDCHttpAuthSchemeProvider = (authParameters) => {
const options = [];
switch (authParameters.operation) {
case "CreateToken": {
options.push(createSmithyApiNoAuthHttpAuthOption());
break;
}
default: {
options.push(createAwsAuthSigv4HttpAuthOption(authParameters));
}
}
return options;
};
var resolveHttpAuthSchemeConfig = (config) => {
const config_0 = resolveAwsSdkSigV4Config(config);
return Object.assign(config_0, {
authSchemePreference: normalizeProvider(config.authSchemePreference ?? [])
});
};
var resolveClientEndpointParameters = (options) => {
return Object.assign(options, {
useDualstackEndpoint: options.useDualstackEndpoint ?? false,
useFipsEndpoint: options.useFipsEndpoint ?? false,
defaultSigningName: "sso-oauth"
});
};
var commonParams = {
UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
Endpoint: { type: "builtInParams", name: "endpoint" },
Region: { type: "builtInParams", name: "region" },
UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
};
var version = "3.997.43";
var packageInfo = {
version
};
var k = "ref";
var a = -1;
var b = true;
var c = "isSet";
var d = "PartitionResult";
var e = "booleanEquals";
var f = "getAttr";
var g = { [k]: "Endpoint" };
var h = { [k]: d };
var i = {};
var j = [{ [k]: "Region" }];
var _data = {
conditions: [
[c, [g]],
[c, j],
["aws.partition", j, d],
[e, [{ [k]: "UseFIPS" }, b]],
[e, [{ [k]: "UseDualStack" }, b]],
[e, [{ fn: f, argv: [h, "supportsDualStack"] }, b]],
[e, [{ fn: f, argv: [h, "supportsFIPS"] }, b]],
["stringEquals", [{ fn: f, argv: [h, "name"] }, "aws-us-gov"]]
],
results: [
[a],
[a, "Invalid Configuration: FIPS and custom endpoint are not supported"],
[a, "Invalid Configuration: Dualstack and custom endpoint are not supported"],
[g, i],
["https://oidc-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", i],
[a, "FIPS and DualStack are enabled, but this partition does not support one or both"],
["https://oidc.{Region}.amazonaws.com", i],
["https://oidc-fips.{Region}.{PartitionResult#dnsSuffix}", i],
[a, "FIPS is enabled but this partition does not support FIPS"],
["https://oidc.{Region}.{PartitionResult#dualStackDnsSuffix}", i],
[a, "DualStack is enabled but this partition does not support DualStack"],
["https://oidc.{Region}.{PartitionResult#dnsSuffix}", i],
[a, "Invalid Configuration: Missing Region"]
]
};
var root = 2;
var r = 1e8;
var nodes = new Int32Array([
-1,
1,
-1,
0,
13,
3,
1,
4,
r + 12,
2,
5,
r + 12,
3,
8,
6,
4,
7,
r + 11,
5,
r + 9,
r + 10,
4,
11,
9,
6,
10,
r + 8,
7,
r + 6,
r + 7,
5,
12,
r + 5,
6,
r + 4,
r + 5,
3,
r + 1,
14,
4,
r + 2,
r + 3
]);
var bdd = BinaryDecisionDiagram.from(nodes, root, _data.conditions, _data.results);
var cache = new EndpointCache({
size: 50,
params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"]
});
var defaultEndpointResolver = (endpointParams, context = {}) => {
return cache.get(endpointParams, () => decideEndpoint(bdd, {
endpointParams,
logger: context.logger
}));
};
customEndpointFunctions.aws = awsEndpointFunctions;
class SSOOIDCServiceException extends ServiceException {
constructor(options) {
super(options);
Object.setPrototypeOf(this, SSOOIDCServiceException.prototype);
}
}
class AccessDeniedException extends SSOOIDCServiceException {
name = "AccessDeniedException";
$fault = "client";
error;
reason;
error_description;
constructor(opts) {
super({
name: "AccessDeniedException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, AccessDeniedException.prototype);
this.error = opts.error;
this.reason = opts.reason;
this.error_description = opts.error_description;
}
}
class AuthorizationPendingException extends SSOOIDCServiceException {
name = "AuthorizationPendingException";
$fault = "client";
error;
error_description;
constructor(opts) {
super({
name: "AuthorizationPendingException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, AuthorizationPendingException.prototype);
this.error = opts.error;
this.error_description = opts.error_description;
}
}
class ExpiredTokenException extends SSOOIDCServiceException {
name = "ExpiredTokenException";
$fault = "client";
error;
error_description;
constructor(opts) {
super({
name: "ExpiredTokenException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, ExpiredTokenException.prototype);
this.error = opts.error;
this.error_description = opts.error_description;
}
}
class InternalServerException extends SSOOIDCServiceException {
name = "InternalServerException";
$fault = "server";
error;
error_description;
constructor(opts) {
super({
name: "InternalServerException",
$fault: "server",
...opts
});
Object.setPrototypeOf(this, InternalServerException.prototype);
this.error = opts.error;
this.error_description = opts.error_description;
}
}
class InvalidClientException extends SSOOIDCServiceException {
name = "InvalidClientException";
$fault = "client";
error;
error_description;
constructor(opts) {
super({
name: "InvalidClientException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidClientException.prototype);
this.error = opts.error;
this.error_description = opts.error_description;
}
}
class InvalidGrantException extends SSOOIDCServiceException {
name = "InvalidGrantException";
$fault = "client";
error;
error_description;
constructor(opts) {
super({
name: "InvalidGrantException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidGrantException.prototype);
this.error = opts.error;
this.error_description = opts.error_description;
}
}
class InvalidRequestException extends SSOOIDCServiceException {
name = "InvalidRequestException";
$fault = "client";
error;
reason;
error_description;
constructor(opts) {
super({
name: "InvalidRequestException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidRequestException.prototype);
this.error = opts.error;
this.reason = opts.reason;
this.error_description = opts.error_description;
}
}
class InvalidScopeException extends SSOOIDCServiceException {
name = "InvalidScopeException";
$fault = "client";
error;
error_description;
constructor(opts) {
super({
name: "InvalidScopeException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidScopeException.prototype);
this.error = opts.error;
this.error_description = opts.error_description;
}
}
class SlowDownException extends SSOOIDCServiceException {
name = "SlowDownException";
$fault = "client";
error;
error_description;
constructor(opts) {
super({
name: "SlowDownException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, SlowDownException.prototype);
this.error = opts.error;
this.error_description = opts.error_description;
}
}
class UnauthorizedClientException extends SSOOIDCServiceException {
name = "UnauthorizedClientException";
$fault = "client";
error;
error_description;
constructor(opts) {
super({
name: "UnauthorizedClientException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, UnauthorizedClientException.prototype);
this.error = opts.error;
this.error_description = opts.error_description;
}
}
class UnsupportedGrantTypeException extends SSOOIDCServiceException {
name = "UnsupportedGrantTypeException";
$fault = "client";
error;
error_description;
constructor(opts) {
super({
name: "UnsupportedGrantTypeException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, UnsupportedGrantTypeException.prototype);
this.error = opts.error;
this.error_description = opts.error_description;
}
}
var _ADE = "AccessDeniedException";
var _APE = "AuthorizationPendingException";
var _AT = "AccessToken";
var _CS = "ClientSecret";
var _CT = "CreateToken";
var _CTR = "CreateTokenRequest";
var _CTRr = "CreateTokenResponse";
var _CV = "CodeVerifier";
var _ETE = "ExpiredTokenException";
var _ICE = "InvalidClientException";
var _IGE = "InvalidGrantException";
var _IRE = "InvalidRequestException";
var _ISE = "InternalServerException";
var _ISEn = "InvalidScopeException";
var _IT = "IdToken";
var _RT = "RefreshToken";
var _SDE = "SlowDownException";
var _UCE = "UnauthorizedClientException";
var _UGTE = "UnsupportedGrantTypeException";
var _aT = "accessToken";
var _c = "client";
var _cI = "clientId";
var _cS = "clientSecret";
var _cV = "codeVerifier";
var _co = "code";
var _dC = "deviceCode";
var _e = "error";
var _eI = "expiresIn";
var _ed = "error_description";
var _gT = "grantType";
var _h = "http";
var _hE = "httpError";
var _iT = "idToken";
var _r = "reason";
var _rT = "refreshToken";
var _rU = "redirectUri";
var _s = "smithy.ts.sdk.synthetic.com.amazonaws.ssooidc";
var _sc = "scope";
var _se = "server";
var _tT = "tokenType";
var n0 = "com.amazonaws.ssooidc";
var _s_registry = TypeRegistry.for(_s);
var SSOOIDCServiceException$ = [-3, _s, "SSOOIDCServiceException", 0, [], []];
_s_registry.registerError(SSOOIDCServiceException$, SSOOIDCServiceException);
var n0_registry = TypeRegistry.for(n0);
var AccessDeniedException$ = [
-3,
n0,
_ADE,
{ [_e]: _c, [_hE]: 400 },
[_e, _r, _ed],
[0, 0, 0]
];
n0_registry.registerError(AccessDeniedException$, AccessDeniedException);
var AuthorizationPendingException$ = [
-3,
n0,
_APE,
{ [_e]: _c, [_hE]: 400 },
[_e, _ed],
[0, 0]
];
n0_registry.registerError(AuthorizationPendingException$, AuthorizationPendingException);
var ExpiredTokenException$ = [
-3,
n0,
_ETE,
{ [_e]: _c, [_hE]: 400 },
[_e, _ed],
[0, 0]
];
n0_registry.registerError(ExpiredTokenException$, ExpiredTokenException);
var InternalServerException$ = [
-3,
n0,
_ISE,
{ [_e]: _se, [_hE]: 500 },
[_e, _ed],
[0, 0]
];
n0_registry.registerError(InternalServerException$, InternalServerException);
var InvalidClientException$ = [
-3,
n0,
_ICE,
{ [_e]: _c, [_hE]: 401 },
[_e, _ed],
[0, 0]
];
n0_registry.registerError(InvalidClientException$, InvalidClientException);
var InvalidGrantException$ = [
-3,
n0,
_IGE,
{ [_e]: _c, [_hE]: 400 },
[_e, _ed],
[0, 0]
];
n0_registry.registerError(InvalidGrantException$, InvalidGrantException);
var InvalidRequestException$ = [
-3,
n0,
_IRE,
{ [_e]: _c, [_hE]: 400 },
[_e, _r, _ed],
[0, 0, 0]
];
n0_registry.registerError(InvalidRequestException$, InvalidRequestException);
var InvalidScopeException$ = [
-3,
n0,
_ISEn,
{ [_e]: _c, [_hE]: 400 },
[_e, _ed],
[0, 0]
];
n0_registry.registerError(InvalidScopeException$, InvalidScopeException);
var SlowDownException$ = [
-3,
n0,
_SDE,
{ [_e]: _c, [_hE]: 400 },
[_e, _ed],
[0, 0]
];
n0_registry.registerError(SlowDownException$, SlowDownException);
var UnauthorizedClientException$ = [
-3,
n0,
_UCE,
{ [_e]: _c, [_hE]: 400 },
[_e, _ed],
[0, 0]
];
n0_registry.registerError(UnauthorizedClientException$, UnauthorizedClientException);
var UnsupportedGrantTypeException$ = [
-3,
n0,
_UGTE,
{ [_e]: _c, [_hE]: 400 },
[_e, _ed],
[0, 0]
];
n0_registry.registerError(UnsupportedGrantTypeException$, UnsupportedGrantTypeException);
var errorTypeRegistries = [
_s_registry,
n0_registry
];
var AccessToken = [0, n0, _AT, 8, 0];
var ClientSecret = [0, n0, _CS, 8, 0];
var CodeVerifier = [0, n0, _CV, 8, 0];
var IdToken = [0, n0, _IT, 8, 0];
var RefreshToken = [0, n0, _RT, 8, 0];
var CreateTokenRequest$ = [
3,
n0,
_CTR,
0,
[_cI, _cS, _gT, _dC, _co, _rT, _sc, _rU, _cV],
[0, [() => ClientSecret, 0], 0, 0, 0, [() => RefreshToken, 0], 64 | 0, 0, [() => CodeVerifier, 0]],
3
];
var CreateTokenResponse$ = [
3,
n0,
_CTRr,
0,
[_aT, _tT, _eI, _rT, _iT],
[[() => AccessToken, 0], 0, 1, [() => RefreshToken, 0], [() => IdToken, 0]]
];
var CreateToken$ = [
9,
n0,
_CT,
{ [_h]: ["POST", "/token", 200] },
() => CreateTokenRequest$,
() => CreateTokenResponse$
];
var getRuntimeConfig$1 = (config) => {
return {
apiVersion: "2019-06-10",
base64Decoder: config?.base64Decoder ?? fromBase64,
base64Encoder: config?.base64Encoder ?? toBase64,
disableHostPrefix: config?.disableHostPrefix ?? false,
endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
extensions: config?.extensions ?? [],
httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultSSOOIDCHttpAuthSchemeProvider,
httpAuthSchemes: config?.httpAuthSchemes ?? [
{
schemeId: "aws.auth#sigv4",
identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
signer: new AwsSdkSigV4Signer
},
{
schemeId: "smithy.api#noAuth",
identityProvider: (ipc) => ipc.getIdentityProvider("smithy.api#noAuth") || (async () => ({})),
signer: new NoAuthSigner
}
],
logger: config?.logger ?? new NoOpLogger,
protocol: config?.protocol ?? AwsRestJsonProtocol,
protocolSettings: config?.protocolSettings ?? {
defaultNamespace: "com.amazonaws.ssooidc",
errorTypeRegistries,
version: "2019-06-10",
serviceTarget: "AWSSSOOIDCService"
},
serviceId: config?.serviceId ?? "SSO OIDC",
sha256: config?.sha256 ?? Sha256,
urlParser: config?.urlParser ?? parseUrl,
utf8Decoder: config?.utf8Decoder ?? fromUtf8,
utf8Encoder: config?.utf8Encoder ?? toUtf8
};
};
var getRuntimeConfig = (config) => {
emitWarningIfUnsupportedVersion(process.version);
const defaultsMode = resolveDefaultsModeConfig(config);
const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
const clientSharedValues = getRuntimeConfig$1(config);
emitWarningIfUnsupportedVersion$1(process.version);
const loaderConfig = {
profile: config?.profile,
logger: clientSharedValues.logger
};
return {
...clientSharedValues,
...config,
runtime: "node",
defaultsMode,
authSchemePreference: config?.authSchemePreference ?? loadConfig(NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
defaultUserAgentProvider: config?.defaultUserAgentProvider ?? createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: packageInfo.version }),
maxAttempts: config?.maxAttempts ?? loadConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
region: config?.region ?? loadConfig(NODE_REGION_CONFIG_OPTIONS, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
requestHandler: NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
retryMode: config?.retryMode ?? loadConfig({
...NODE_RETRY_MODE_CONFIG_OPTIONS,
default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE
}, config),
streamCollector: config?.streamCollector ?? streamCollector,
useDualstackEndpoint: config?.useDualstackEndpoint ?? loadConfig(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
useFipsEndpoint: config?.useFipsEndpoint ?? loadConfig(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
userAgentAppId: config?.userAgentAppId ?? loadConfig(NODE_APP_ID_CONFIG_OPTIONS, loaderConfig)
};
};
var getHttpAuthExtensionConfiguration = (runtimeConfig) => {
const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
let _credentials = runtimeConfig.credentials;
return {
setHttpAuthScheme(httpAuthScheme) {
const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
if (index === -1) {
_httpAuthSchemes.push(httpAuthScheme);
} else {
_httpAuthSchemes.splice(index, 1, httpAuthScheme);
}
},
httpAuthSchemes() {
return _httpAuthSchemes;
},
setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
_httpAuthSchemeProvider = httpAuthSchemeProvider;
},
httpAuthSchemeProvider() {
return _httpAuthSchemeProvider;
},
setCredentials(credentials) {
_credentials = credentials;
},
credentials() {
return _credentials;
}
};
};
var resolveHttpAuthRuntimeConfig = (config) => {
return {
httpAuthSchemes: config.httpAuthSchemes(),
httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
credentials: config.credentials()
};
};
var resolveRuntimeExtensions = (runtimeConfig, extensions) => {
const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
extensions.forEach((extension) => extension.configure(extensionConfiguration));
return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
};
class SSOOIDCClient extends Client {
config;
constructor(...[configuration]) {
const _config_0 = getRuntimeConfig(configuration || {});
super(_config_0);
this.initConfig = _config_0;
const _config_1 = resolveClientEndpointParameters(_config_0);
const _config_2 = resolveUserAgentConfig(_config_1);
const _config_3 = resolveRetryConfig(_config_2);
const _config_4 = resolveRegionConfig(_config_3);
const _config_5 = resolveHostHeaderConfig(_config_4);
const _config_6 = resolveEndpointConfig(_config_5);
const _config_7 = resolveHttpAuthSchemeConfig(_config_6);
const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
this.config = _config_8;
this.middlewareStack.use(getSchemaSerdePlugin(this.config));
this.middlewareStack.use(getUserAgentPlugin(this.config));
this.middlewareStack.use(getRetryPlugin(this.config));
this.middlewareStack.use(getContentLengthPlugin(this.config));
this.middlewareStack.use(getHostHeaderPlugin(this.config));
this.middlewareStack.use(getLoggerPlugin(this.config));
this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
httpAuthSchemeParametersProvider: defaultSSOOIDCHttpAuthSchemeParametersProvider,
identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
"aws.auth#sigv4": config.credentials
})
}));
this.middlewareStack.use(getHttpSigningPlugin(this.config));
}
destroy() {
super.destroy();
}
}
var command = makeBuilder(commonParams, "AWSSSOOIDCService", "SSOOIDCClient", getEndpointPlugin);
var _ep0 = {};
var _mw0 = (Command, cs, config, o) => [];
class CreateTokenCommand extends command(_ep0, _mw0, "CreateToken", CreateToken$) {
}
var commands = {
CreateTokenCommand
};
class SSOOIDC extends SSOOIDCClient {
}
createAggregatedClient(commands, SSOOIDC);
var AccessDeniedExceptionReason = {
KMS_ACCESS_DENIED: "KMS_AccessDeniedException"
};
var InvalidRequestExceptionReason = {
KMS_DISABLED_KEY: "KMS_DisabledException",
KMS_INVALID_KEY_USAGE: "KMS_InvalidKeyUsageException",
KMS_INVALID_STATE: "KMS_InvalidStateException",
KMS_KEY_NOT_FOUND: "KMS_NotFoundException"
};
exports.AccessDeniedException = AccessDeniedException;
exports.AccessDeniedException$ = AccessDeniedException$;
exports.AccessDeniedExceptionReason = AccessDeniedExceptionReason;
exports.AuthorizationPendingException = AuthorizationPendingException;
exports.AuthorizationPendingException$ = AuthorizationPendingException$;
exports.CreateToken$ = CreateToken$;
exports.CreateTokenCommand = CreateTokenCommand;
exports.CreateTokenRequest$ = CreateTokenRequest$;
exports.CreateTokenResponse$ = CreateTokenResponse$;
exports.ExpiredTokenException = ExpiredTokenException;
exports.ExpiredTokenException$ = ExpiredTokenException$;
exports.InternalServerException = InternalServerException;
exports.InternalServerException$ = InternalServerException$;
exports.InvalidClientException = InvalidClientException;
exports.InvalidClientException$ = InvalidClientException$;
exports.InvalidGrantException = InvalidGrantException;
exports.InvalidGrantException$ = InvalidGrantException$;
exports.InvalidRequestException = InvalidRequestException;
exports.InvalidRequestException$ = InvalidRequestException$;
exports.InvalidRequestExceptionReason = InvalidRequestExceptionReason;
exports.InvalidScopeException = InvalidScopeException;
exports.InvalidScopeException$ = InvalidScopeException$;
exports.SSOOIDC = SSOOIDC;
exports.SSOOIDCClient = SSOOIDCClient;
exports.SSOOIDCServiceException = SSOOIDCServiceException;
exports.SSOOIDCServiceException$ = SSOOIDCServiceException$;
exports.SlowDownException = SlowDownException;
exports.SlowDownException$ = SlowDownException$;
exports.UnauthorizedClientException = UnauthorizedClientException;
exports.UnauthorizedClientException$ = UnauthorizedClientException$;
exports.UnsupportedGrantTypeException = UnsupportedGrantTypeException;
exports.UnsupportedGrantTypeException$ = UnsupportedGrantTypeException$;
exports.errorTypeRegistries = errorTypeRegistries;
});
// ../../node_modules/.bun/@aws-sdk+token-providers@3.1116.0/node_modules/@aws-sdk/token-providers/dist-es/getSsoOidcClient.js
var getSsoOidcClient = async (ssoRegion, init = {}, callerClientConfig) => {
const { SSOOIDCClient } = await Promise.resolve().then(() => __toESM(require_sso_oidc()));
const coalesce = (prop) => init.clientConfig?.[prop] ?? init.parentClientConfig?.[prop] ?? callerClientConfig?.[prop];
const ssoOidcClient = new SSOOIDCClient(Object.assign({}, init.clientConfig ?? {}, {
region: ssoRegion ?? init.clientConfig?.region,
logger: coalesce("logger"),
userAgentAppId: coalesce("userAgentAppId")
}));
return ssoOidcClient;
};
// ../../node_modules/.bun/@aws-sdk+token-providers@3.1116.0/node_modules/@aws-sdk/token-providers/dist-es/getNewSsoOidcToken.js
var getNewSsoOidcToken = async (ssoToken, ssoRegion, init = {}, callerClientConfig) => {
const { CreateTokenCommand } = await Promise.resolve().then(() => __toESM(require_sso_oidc()));
const ssoOidcClient = await getSsoOidcClient(ssoRegion, init, callerClientConfig);
return ssoOidcClient.send(new CreateTokenCommand({
clientId: ssoToken.clientId,
clientSecret: ssoToken.clientSecret,
refreshToken: ssoToken.refreshToken,
grantType: "refresh_token"
}));
};
var init_getNewSsoOidcToken = () => {};
// ../../node_modules/.bun/@aws-sdk+token-providers@3.1116.0/node_modules/@aws-sdk/token-providers/dist-es/validateTokenExpiry.js
var import_config11, validateTokenExpiry = (token) => {
if (token.expiration && token.expiration.getTime() < Date.now()) {
throw new import_config11.TokenProviderError(`Token is expired. ${REFRESH_MESSAGE}`, false);
}
};
var init_validateTokenExpiry = __esm(() => {
init_constants();
import_config11 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+token-providers@3.1116.0/node_modules/@aws-sdk/token-providers/dist-es/validateTokenKey.js
var import_config12, validateTokenKey = (key, value, forRefresh = false) => {
if (typeof value === "undefined") {
throw new import_config12.TokenProviderError(`Value not present for '${key}' in SSO Token${forRefresh ? ". Cannot refresh" : ""}. ${REFRESH_MESSAGE}`, false);
}
};
var init_validateTokenKey = __esm(() => {
init_constants();
import_config12 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+token-providers@3.1116.0/node_modules/@aws-sdk/token-providers/dist-es/writeSSOTokenToFile.js
import { promises as fsPromises } from "fs";
var import_config13, writeFile, writeSSOTokenToFile = (id, ssoToken) => {
const tokenFilepath = import_config13.getSSOTokenFilepath(id);
const tokenString = JSON.stringify(ssoToken, null, 2);
return writeFile(tokenFilepath, tokenString);
};
var init_writeSSOTokenToFile = __esm(() => {
import_config13 = __toESM(require_config());
({ writeFile } = fsPromises);
});
// ../../node_modules/.bun/@aws-sdk+token-providers@3.1116.0/node_modules/@aws-sdk/token-providers/dist-es/fromSso.js
var import_config14, lastRefreshAttemptTimes, fromSso = (init = {}) => async ({ callerClientConfig } = {}) => {
init.logger?.debug("@aws-sdk/token-providers - fromSso");
const profiles = await import_config14.parseKnownFiles(init);
const profileName = import_config14.getProfileName({
profile: init.profile ?? callerClientConfig?.profile
});
const profile = profiles[profileName];
if (!profile) {
throw new import_config14.TokenProviderError(`Profile '${profileName}' could not be found in shared credentials file.`, false);
} else if (!profile["sso_session"]) {
throw new import_config14.TokenProviderError(`Profile '${profileName}' is missing required property 'sso_session'.`);
}
const ssoSessionName = profile["sso_session"];
const ssoSessions = await import_config14.loadSsoSessionData(init);
const ssoSession = ssoSessions[ssoSessionName];
if (!ssoSession) {
throw new import_config14.TokenProviderError(`Sso session '${ssoSessionName}' could not be found in shared credentials file.`, false);
}
for (const ssoSessionRequiredKey of ["sso_start_url", "sso_region"]) {
if (!ssoSession[ssoSessionRequiredKey]) {
throw new import_config14.TokenProviderError(`Sso session '${ssoSessionName}' is missing required property '${ssoSessionRequiredKey}'.`, false);
}
}
const ssoStartUrl = ssoSession["sso_start_url"];
const ssoRegion = ssoSession["sso_region"];
let ssoToken;
try {
ssoToken = await import_config14.getSSOTokenFromFile(ssoSessionName);
} catch (e) {
throw new import_config14.TokenProviderError(`The SSO session token associated with profile=${profileName} was not found or is invalid. ${REFRESH_MESSAGE}`, false);
}
validateTokenKey("accessToken", ssoToken.accessToken);
validateTokenKey("expiresAt", ssoToken.expiresAt);
const { accessToken, expiresAt } = ssoToken;
const existingToken = {
token: accessToken,
expiration: new Date(expiresAt)
};
if (existingToken.expiration.getTime() - Date.now() > EXPIRE_WINDOW_MS) {
return existingToken;
}
const lastRefreshAttemptTime = lastRefreshAttemptTimes.get(ssoSessionName) ?? 0;
if (Date.now() - lastRefreshAttemptTime < 30 * 1000) {
validateTokenExpiry(existingToken);
return existingToken;
}
validateTokenKey("clientId", ssoToken.clientId, true);
validateTokenKey("clientSecret", ssoToken.clientSecret, true);
validateTokenKey("refreshToken", ssoToken.refreshToken, true);
try {
lastRefreshAttemptTimes.set(ssoSessionName, Date.now());
const newSsoOidcToken = await getNewSsoOidcToken(ssoToken, ssoRegion, init, callerClientConfig);
validateTokenKey("accessToken", newSsoOidcToken.accessToken);
validateTokenKey("expiresIn", newSsoOidcToken.expiresIn);
const newTokenExpiration = new Date(Date.now() + newSsoOidcToken.expiresIn * 1000);
try {
await writeSSOTokenToFile(ssoSessionName, {
...ssoToken,
accessToken: newSsoOidcToken.accessToken,
expiresAt: newTokenExpiration.toISOString(),
refreshToken: newSsoOidcToken.refreshToken
});
} catch (error) {}
return {
token: newSsoOidcToken.accessToken,
expiration: newTokenExpiration
};
} catch (error) {
validateTokenExpiry(existingToken);
return existingToken;
}
};
var init_fromSso = __esm(() => {
init_constants();
init_getNewSsoOidcToken();
init_validateTokenExpiry();
init_validateTokenKey();
init_writeSSOTokenToFile();
import_config14 = __toESM(require_config());
lastRefreshAttemptTimes = new Map;
});
// ../../node_modules/.bun/@aws-sdk+token-providers@3.1116.0/node_modules/@aws-sdk/token-providers/dist-es/index.js
var init_dist_es4 = __esm(() => {
init_fromSso();
});
// ../../node_modules/.bun/@aws-sdk+nested-clients@3.997.44/node_modules/@aws-sdk/nested-clients/dist-cjs/submodules/sso/index.js
function createAwsAuthSigv4HttpAuthOption2(authParameters) {
return {
schemeId: "aws.auth#sigv4",
signingProperties: {
name: "awsssoportal",
region: authParameters.region
},
propertiesExtractor: (config, context) => ({
signingProperties: {
config,
context
}
})
};
}
function createSmithyApiNoAuthHttpAuthOption(authParameters) {
return {
schemeId: "smithy.api#noAuth"
};
}
var awsEndpointFunctions, emitWarningIfUnsupportedVersion$1, createDefaultUserAgentProvider, NODE_APP_ID_CONFIG_OPTIONS, getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin, NoAuthSigner, getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin, normalizeProvider2, getSmithyContext2, ServiceException, NoOpLogger, emitWarningIfUnsupportedVersion, loadConfigsForDefaultMode, getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, makeBuilder, createAggregatedClient, $Command, resolveDefaultsModeConfig, loadConfig3, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS, resolveRegionConfig, BinaryDecisionDiagram, EndpointCache, decideEndpoint, customEndpointFunctions, resolveEndpointConfig, getEndpointPlugin, parseUrl2, getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin, DEFAULT_RETRY_MODE, NODE_RETRY_MODE_CONFIG_OPTIONS, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, resolveRetryConfig, getRetryPlugin, TypeRegistry, getSchemaSerdePlugin, resolveAwsSdkSigV4Config2, AwsSdkSigV4Signer, NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, toUtf8, fromUtf8, toBase64, fromBase64, calculateBodyLength, streamCollector, NodeHttpHandler2, AwsRestJsonProtocol, Sha256, defaultSSOHttpAuthSchemeParametersProvider = async (config, context, input) => {
return {
operation: getSmithyContext2(context).operation,
region: await normalizeProvider2(config.region)() || (() => {
throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
})()
};
}, defaultSSOHttpAuthSchemeProvider = (authParameters) => {
const options = [];
switch (authParameters.operation) {
case "GetRoleCredentials": {
options.push(createSmithyApiNoAuthHttpAuthOption());
break;
}
default: {
options.push(createAwsAuthSigv4HttpAuthOption2(authParameters));
}
}
return options;
}, resolveHttpAuthSchemeConfig2 = (config) => {
const config_0 = resolveAwsSdkSigV4Config2(config);
return Object.assign(config_0, {
authSchemePreference: normalizeProvider2(config.authSchemePreference ?? [])
});
}, resolveClientEndpointParameters2 = (options) => {
return Object.assign(options, {
useDualstackEndpoint: options.useDualstackEndpoint ?? false,
useFipsEndpoint: options.useFipsEndpoint ?? false,
defaultSigningName: "awsssoportal"
});
}, commonParams2, version = "3.997.43", packageInfo, k = "ref", a = -1, b = true, c = "isSet", d = "PartitionResult", e2 = "booleanEquals", f = "getAttr", g, h, i, j, _data, root = 2, r2 = 1e8, nodes, bdd, cache, defaultEndpointResolver = (endpointParams, context = {}) => {
return cache.get(endpointParams, () => decideEndpoint(bdd, {
endpointParams,
logger: context.logger
}));
}, SSOServiceException, InvalidRequestException, ResourceNotFoundException, TooManyRequestsException, UnauthorizedException, _ATT = "AccessTokenType", _GRC = "GetRoleCredentials", _GRCR = "GetRoleCredentialsRequest", _GRCRe = "GetRoleCredentialsResponse", _IRE = "InvalidRequestException", _RC = "RoleCredentials", _RNFE = "ResourceNotFoundException", _SAKT = "SecretAccessKeyType", _STT = "SessionTokenType", _TMRE = "TooManyRequestsException", _UE = "UnauthorizedException", _aI = "accountId", _aKI = "accessKeyId", _aT = "accessToken", _ai = "account_id", _c = "client", _e = "error", _ex = "expiration", _h = "http", _hE = "httpError", _hH = "httpHeader", _hQ = "httpQuery", _m = "message", _rC = "roleCredentials", _rN = "roleName", _rn = "role_name", _s = "smithy.ts.sdk.synthetic.com.amazonaws.sso", _sAK = "secretAccessKey", _sT = "sessionToken", _xasbt = "x-amz-sso_bearer_token", n0 = "com.amazonaws.sso", _s_registry, SSOServiceException$, n0_registry, InvalidRequestException$, ResourceNotFoundException$, TooManyRequestsException$, UnauthorizedException$, errorTypeRegistries, AccessTokenType, SecretAccessKeyType, SessionTokenType, GetRoleCredentialsRequest$, GetRoleCredentialsResponse$, RoleCredentials$, GetRoleCredentials$, getRuntimeConfig$1 = (config) => {
return {
apiVersion: "2019-06-10",
base64Decoder: config?.base64Decoder ?? fromBase64,
base64Encoder: config?.base64Encoder ?? toBase64,
disableHostPrefix: config?.disableHostPrefix ?? false,
endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
extensions: config?.extensions ?? [],
httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultSSOHttpAuthSchemeProvider,
httpAuthSchemes: config?.httpAuthSchemes ?? [
{
schemeId: "aws.auth#sigv4",
identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
signer: new AwsSdkSigV4Signer
},
{
schemeId: "smithy.api#noAuth",
identityProvider: (ipc) => ipc.getIdentityProvider("smithy.api#noAuth") || (async () => ({})),
signer: new NoAuthSigner
}
],
logger: config?.logger ?? new NoOpLogger,
protocol: config?.protocol ?? AwsRestJsonProtocol,
protocolSettings: config?.protocolSettings ?? {
defaultNamespace: "com.amazonaws.sso",
errorTypeRegistries,
version: "2019-06-10",
serviceTarget: "SWBPortalService"
},
serviceId: config?.serviceId ?? "SSO",
sha256: config?.sha256 ?? Sha256,
urlParser: config?.urlParser ?? parseUrl2,
utf8Decoder: config?.utf8Decoder ?? fromUtf8,
utf8Encoder: config?.utf8Encoder ?? toUtf8
};
}, getRuntimeConfig = (config) => {
emitWarningIfUnsupportedVersion(process.version);
const defaultsMode = resolveDefaultsModeConfig(config);
const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
const clientSharedValues = getRuntimeConfig$1(config);
emitWarningIfUnsupportedVersion$1(process.version);
const loaderConfig = {
profile: config?.profile,
logger: clientSharedValues.logger
};
return {
...clientSharedValues,
...config,
runtime: "node",
defaultsMode,
authSchemePreference: config?.authSchemePreference ?? loadConfig3(NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
defaultUserAgentProvider: config?.defaultUserAgentProvider ?? createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: packageInfo.version }),
maxAttempts: config?.maxAttempts ?? loadConfig3(NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
region: config?.region ?? loadConfig3(NODE_REGION_CONFIG_OPTIONS, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
requestHandler: NodeHttpHandler2.create(config?.requestHandler ?? defaultConfigProvider),
retryMode: config?.retryMode ?? loadConfig3({
...NODE_RETRY_MODE_CONFIG_OPTIONS,
default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE
}, config),
streamCollector: config?.streamCollector ?? streamCollector,
useDualstackEndpoint: config?.useDualstackEndpoint ?? loadConfig3(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
useFipsEndpoint: config?.useFipsEndpoint ?? loadConfig3(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
userAgentAppId: config?.userAgentAppId ?? loadConfig3(NODE_APP_ID_CONFIG_OPTIONS, loaderConfig)
};
}, getHttpAuthExtensionConfiguration = (runtimeConfig) => {
const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
let _credentials = runtimeConfig.credentials;
return {
setHttpAuthScheme(httpAuthScheme) {
const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
if (index === -1) {
_httpAuthSchemes.push(httpAuthScheme);
} else {
_httpAuthSchemes.splice(index, 1, httpAuthScheme);
}
},
httpAuthSchemes() {
return _httpAuthSchemes;
},
setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
_httpAuthSchemeProvider = httpAuthSchemeProvider;
},
httpAuthSchemeProvider() {
return _httpAuthSchemeProvider;
},
setCredentials(credentials) {
_credentials = credentials;
},
credentials() {
return _credentials;
}
};
}, resolveHttpAuthRuntimeConfig = (config) => {
return {
httpAuthSchemes: config.httpAuthSchemes(),
httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
credentials: config.credentials()
};
}, resolveRuntimeExtensions = (runtimeConfig, extensions) => {
const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
extensions.forEach((extension) => extension.configure(extensionConfiguration));
return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
}, SSOClient, command, _ep0, _mw0 = (Command, cs, config, o) => [], GetRoleCredentialsCommand, commands, SSO, $GetRoleCredentialsCommand, $SSOClient;
var init_sso = __esm(() => {
({ awsEndpointFunctions, emitWarningIfUnsupportedVersion: emitWarningIfUnsupportedVersion$1, createDefaultUserAgentProvider, NODE_APP_ID_CONFIG_OPTIONS, getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require_client2());
({ NoAuthSigner, getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin } = require_dist_cjs2());
({ normalizeProvider: normalizeProvider2, getSmithyContext: getSmithyContext2, ServiceException, NoOpLogger, emitWarningIfUnsupportedVersion, loadConfigsForDefaultMode, getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, makeBuilder, createAggregatedClient } = require_client());
({ Command: $Command } = require_client());
({ resolveDefaultsModeConfig, loadConfig: loadConfig3, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS, resolveRegionConfig } = require_config());
({ BinaryDecisionDiagram, EndpointCache, decideEndpoint, customEndpointFunctions, resolveEndpointConfig, getEndpointPlugin } = require_endpoints());
({ parseUrl: parseUrl2, getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require_protocols());
({ DEFAULT_RETRY_MODE, NODE_RETRY_MODE_CONFIG_OPTIONS, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, resolveRetryConfig, getRetryPlugin } = require_retry());
({ TypeRegistry, getSchemaSerdePlugin } = require_schema());
({ resolveAwsSdkSigV4Config: resolveAwsSdkSigV4Config2, AwsSdkSigV4Signer, NODE_AUTH_SCHEME_PREFERENCE_OPTIONS } = require_httpAuthSchemes());
({ toUtf8, fromUtf8, toBase64, fromBase64, calculateBodyLength } = require_serde());
({ streamCollector, NodeHttpHandler: NodeHttpHandler2 } = require_dist_cjs4());
({ AwsRestJsonProtocol } = require_protocols2());
({ Sha256 } = require_checksum());
commonParams2 = {
UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
Endpoint: { type: "builtInParams", name: "endpoint" },
Region: { type: "builtInParams", name: "region" },
UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
};
packageInfo = {
version
};
g = { [k]: "Endpoint" };
h = { [k]: d };
i = {};
j = [{ [k]: "Region" }];
_data = {
conditions: [
[c, [g]],
[c, j],
["aws.partition", j, d],
[e2, [{ [k]: "UseFIPS" }, b]],
[e2, [{ [k]: "UseDualStack" }, b]],
[e2, [{ fn: f, argv: [h, "supportsDualStack"] }, b]],
[e2, [{ fn: f, argv: [h, "supportsFIPS"] }, b]],
["stringEquals", [{ fn: f, argv: [h, "name"] }, "aws-us-gov"]]
],
results: [
[a],
[a, "Invalid Configuration: FIPS and custom endpoint are not supported"],
[a, "Invalid Configuration: Dualstack and custom endpoint are not supported"],
[g, i],
["https://portal.sso-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", i],
[a, "FIPS and DualStack are enabled, but this partition does not support one or both"],
["https://portal.sso.{Region}.amazonaws.com", i],
["https://portal.sso-fips.{Region}.{PartitionResult#dnsSuffix}", i],
[a, "FIPS is enabled but this partition does not support FIPS"],
["https://portal.sso.{Region}.{PartitionResult#dualStackDnsSuffix}", i],
[a, "DualStack is enabled but this partition does not support DualStack"],
["https://portal.sso.{Region}.{PartitionResult#dnsSuffix}", i],
[a, "Invalid Configuration: Missing Region"]
]
};
nodes = new Int32Array([
-1,
1,
-1,
0,
13,
3,
1,
4,
r2 + 12,
2,
5,
r2 + 12,
3,
8,
6,
4,
7,
r2 + 11,
5,
r2 + 9,
r2 + 10,
4,
11,
9,
6,
10,
r2 + 8,
7,
r2 + 6,
r2 + 7,
5,
12,
r2 + 5,
6,
r2 + 4,
r2 + 5,
3,
r2 + 1,
14,
4,
r2 + 2,
r2 + 3
]);
bdd = BinaryDecisionDiagram.from(nodes, root, _data.conditions, _data.results);
cache = new EndpointCache({
size: 50,
params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"]
});
customEndpointFunctions.aws = awsEndpointFunctions;
SSOServiceException = class SSOServiceException extends ServiceException {
constructor(options) {
super(options);
Object.setPrototypeOf(this, SSOServiceException.prototype);
}
};
InvalidRequestException = class InvalidRequestException extends SSOServiceException {
name = "InvalidRequestException";
$fault = "client";
constructor(opts) {
super({
name: "InvalidRequestException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidRequestException.prototype);
}
};
ResourceNotFoundException = class ResourceNotFoundException extends SSOServiceException {
name = "ResourceNotFoundException";
$fault = "client";
constructor(opts) {
super({
name: "ResourceNotFoundException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
}
};
TooManyRequestsException = class TooManyRequestsException extends SSOServiceException {
name = "TooManyRequestsException";
$fault = "client";
constructor(opts) {
super({
name: "TooManyRequestsException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TooManyRequestsException.prototype);
}
};
UnauthorizedException = class UnauthorizedException extends SSOServiceException {
name = "UnauthorizedException";
$fault = "client";
constructor(opts) {
super({
name: "UnauthorizedException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, UnauthorizedException.prototype);
}
};
_s_registry = TypeRegistry.for(_s);
SSOServiceException$ = [-3, _s, "SSOServiceException", 0, [], []];
_s_registry.registerError(SSOServiceException$, SSOServiceException);
n0_registry = TypeRegistry.for(n0);
InvalidRequestException$ = [
-3,
n0,
_IRE,
{ [_e]: _c, [_hE]: 400 },
[_m],
[0]
];
n0_registry.registerError(InvalidRequestException$, InvalidRequestException);
ResourceNotFoundException$ = [
-3,
n0,
_RNFE,
{ [_e]: _c, [_hE]: 404 },
[_m],
[0]
];
n0_registry.registerError(ResourceNotFoundException$, ResourceNotFoundException);
TooManyRequestsException$ = [
-3,
n0,
_TMRE,
{ [_e]: _c, [_hE]: 429 },
[_m],
[0]
];
n0_registry.registerError(TooManyRequestsException$, TooManyRequestsException);
UnauthorizedException$ = [
-3,
n0,
_UE,
{ [_e]: _c, [_hE]: 401 },
[_m],
[0]
];
n0_registry.registerError(UnauthorizedException$, UnauthorizedException);
errorTypeRegistries = [
_s_registry,
n0_registry
];
AccessTokenType = [0, n0, _ATT, 8, 0];
SecretAccessKeyType = [0, n0, _SAKT, 8, 0];
SessionTokenType = [0, n0, _STT, 8, 0];
GetRoleCredentialsRequest$ = [
3,
n0,
_GRCR,
0,
[_rN, _aI, _aT],
[[0, { [_hQ]: _rn }], [0, { [_hQ]: _ai }], [() => AccessTokenType, { [_hH]: _xasbt }]],
3
];
GetRoleCredentialsResponse$ = [
3,
n0,
_GRCRe,
0,
[_rC],
[[() => RoleCredentials$, 0]]
];
RoleCredentials$ = [
3,
n0,
_RC,
0,
[_aKI, _sAK, _sT, _ex],
[0, [() => SecretAccessKeyType, 0], [() => SessionTokenType, 0], 1]
];
GetRoleCredentials$ = [
9,
n0,
_GRC,
{ [_h]: ["GET", "/federation/credentials", 200] },
() => GetRoleCredentialsRequest$,
() => GetRoleCredentialsResponse$
];
SSOClient = class SSOClient extends Client {
config;
constructor(...[configuration]) {
const _config_0 = getRuntimeConfig(configuration || {});
super(_config_0);
this.initConfig = _config_0;
const _config_1 = resolveClientEndpointParameters2(_config_0);
const _config_2 = resolveUserAgentConfig(_config_1);
const _config_3 = resolveRetryConfig(_config_2);
const _config_4 = resolveRegionConfig(_config_3);
const _config_5 = resolveHostHeaderConfig(_config_4);
const _config_6 = resolveEndpointConfig(_config_5);
const _config_7 = resolveHttpAuthSchemeConfig2(_config_6);
const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
this.config = _config_8;
this.middlewareStack.use(getSchemaSerdePlugin(this.config));
this.middlewareStack.use(getUserAgentPlugin(this.config));
this.middlewareStack.use(getRetryPlugin(this.config));
this.middlewareStack.use(getContentLengthPlugin(this.config));
this.middlewareStack.use(getHostHeaderPlugin(this.config));
this.middlewareStack.use(getLoggerPlugin(this.config));
this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
httpAuthSchemeParametersProvider: defaultSSOHttpAuthSchemeParametersProvider,
identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
"aws.auth#sigv4": config.credentials
})
}));
this.middlewareStack.use(getHttpSigningPlugin(this.config));
}
destroy() {
super.destroy();
}
};
command = makeBuilder(commonParams2, "SWBPortalService", "SSOClient", getEndpointPlugin);
_ep0 = {};
GetRoleCredentialsCommand = class GetRoleCredentialsCommand extends command(_ep0, _mw0, "GetRoleCredentials", GetRoleCredentials$) {
};
commands = {
GetRoleCredentialsCommand
};
SSO = class SSO extends SSOClient {
};
createAggregatedClient(commands, SSO);
$GetRoleCredentialsCommand = GetRoleCredentialsCommand;
$SSOClient = SSOClient;
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-sso@3.973.14/node_modules/@aws-sdk/credential-provider-sso/dist-es/loadSso.js
var exports_loadSso = {};
__export(exports_loadSso, {
GetRoleCredentialsCommand: () => $GetRoleCredentialsCommand,
SSOClient: () => $SSOClient
});
var init_loadSso = __esm(() => {
init_sso();
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-sso@3.973.14/node_modules/@aws-sdk/credential-provider-sso/dist-es/resolveSSOCredentials.js
var import_client6, import_config15, SHOULD_FAIL_CREDENTIAL_CHAIN = false, resolveSSOCredentials = async ({ ssoStartUrl, ssoSession, ssoAccountId, ssoRegion, ssoRoleName, ssoClient, clientConfig, parentClientConfig, callerClientConfig, profile, filepath, configFilepath, ignoreCache, logger }) => {
let token;
const refreshMessage = `To refresh this SSO session run aws sso login with the corresponding profile.`;
if (ssoSession) {
try {
const _token = await fromSso({
profile,
filepath,
configFilepath,
ignoreCache,
clientConfig,
parentClientConfig,
logger
})({ callerClientConfig });
token = {
accessToken: _token.token,
expiresAt: new Date(_token.expiration).toISOString()
};
} catch (e) {
throw new import_config15.CredentialsProviderError(e.message, {
tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN,
logger
});
}
} else {
try {
token = await import_config15.getSSOTokenFromFile(ssoStartUrl);
} catch (e) {
throw new import_config15.CredentialsProviderError(`The SSO session associated with this profile is invalid. ${refreshMessage}`, {
tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN,
logger
});
}
}
if (new Date(token.expiresAt).getTime() - Date.now() <= 0) {
throw new import_config15.CredentialsProviderError(`The SSO session associated with this profile has expired. ${refreshMessage}`, {
tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN,
logger
});
}
const { accessToken } = token;
const { SSOClient, GetRoleCredentialsCommand } = await Promise.resolve().then(() => (init_loadSso(), exports_loadSso));
const sso = ssoClient || new SSOClient(Object.assign({}, clientConfig ?? {}, {
logger: clientConfig?.logger ?? callerClientConfig?.logger ?? parentClientConfig?.logger,
region: clientConfig?.region ?? ssoRegion,
userAgentAppId: clientConfig?.userAgentAppId ?? callerClientConfig?.userAgentAppId ?? parentClientConfig?.userAgentAppId
}));
let ssoResp;
try {
ssoResp = await sso.send(new GetRoleCredentialsCommand({
accountId: ssoAccountId,
roleName: ssoRoleName,
accessToken
}));
} catch (e) {
throw new import_config15.CredentialsProviderError(e, {
tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN,
logger
});
}
const { roleCredentials: { accessKeyId, secretAccessKey, sessionToken, expiration, credentialScope, accountId } = {} } = ssoResp;
if (!accessKeyId || !secretAccessKey || !sessionToken || !expiration) {
throw new import_config15.CredentialsProviderError("SSO returns an invalid temporary credential.", {
tryNextLink: SHOULD_FAIL_CREDENTIAL_CHAIN,
logger
});
}
const credentials = {
accessKeyId,
secretAccessKey,
sessionToken,
expiration: new Date(expiration),
...credentialScope && { credentialScope },
...accountId && { accountId }
};
if (ssoSession) {
import_client6.setCredentialFeature(credentials, "CREDENTIALS_SSO", "s");
} else {
import_client6.setCredentialFeature(credentials, "CREDENTIALS_SSO_LEGACY", "u");
}
return credentials;
};
var init_resolveSSOCredentials = __esm(() => {
init_dist_es4();
import_client6 = __toESM(require_client2());
import_config15 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-sso@3.973.14/node_modules/@aws-sdk/credential-provider-sso/dist-es/validateSsoProfile.js
var import_config16, validateSsoProfile = (profile, logger) => {
const { sso_start_url, sso_account_id, sso_region, sso_role_name } = profile;
if (!sso_start_url || !sso_account_id || !sso_region || !sso_role_name) {
throw new import_config16.CredentialsProviderError(`Profile is configured with invalid SSO credentials. Required parameters "sso_account_id", ` + `"sso_region", "sso_role_name", "sso_start_url". Got ${Object.keys(profile).join(", ")}
Reference: https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-sso.html`, { tryNextLink: false, logger });
}
return profile;
};
var init_validateSsoProfile = __esm(() => {
import_config16 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-sso@3.973.14/node_modules/@aws-sdk/credential-provider-sso/dist-es/fromSSO.js
var import_config17, fromSSO = (init = {}) => async ({ callerClientConfig } = {}) => {
init.logger?.debug("@aws-sdk/credential-provider-sso - fromSSO");
const { ssoStartUrl, ssoAccountId, ssoRegion, ssoRoleName, ssoSession } = init;
const { ssoClient } = init;
const profileName = import_config17.getProfileName({
profile: init.profile ?? callerClientConfig?.profile
});
if (!ssoStartUrl && !ssoAccountId && !ssoRegion && !ssoRoleName && !ssoSession) {
const profiles = await import_config17.parseKnownFiles(init);
const profile = profiles[profileName];
if (!profile) {
throw new import_config17.CredentialsProviderError(`Profile ${profileName} was not found.`, { logger: init.logger });
}
if (!isSsoProfile(profile)) {
throw new import_config17.CredentialsProviderError(`Profile ${profileName} is not configured with SSO credentials.`, {
logger: init.logger
});
}
if (profile?.sso_session) {
const ssoSessions = await import_config17.loadSsoSessionData(init);
const session = ssoSessions[profile.sso_session];
const conflictMsg = ` configurations in profile ${profileName} and sso-session ${profile.sso_session}`;
if (ssoRegion && ssoRegion !== session.sso_region) {
throw new import_config17.CredentialsProviderError(`Conflicting SSO region` + conflictMsg, {
tryNextLink: false,
logger: init.logger
});
}
if (ssoStartUrl && ssoStartUrl !== session.sso_start_url) {
throw new import_config17.CredentialsProviderError(`Conflicting SSO start_url` + conflictMsg, {
tryNextLink: false,
logger: init.logger
});
}
profile.sso_region = session.sso_region;
profile.sso_start_url = session.sso_start_url;
}
const { sso_start_url, sso_account_id, sso_region, sso_role_name, sso_session } = validateSsoProfile(profile, init.logger);
return resolveSSOCredentials({
ssoStartUrl: sso_start_url,
ssoSession: sso_session,
ssoAccountId: sso_account_id,
ssoRegion: sso_region,
ssoRoleName: sso_role_name,
ssoClient,
clientConfig: init.clientConfig,
parentClientConfig: init.parentClientConfig,
callerClientConfig: init.callerClientConfig,
profile: profileName,
filepath: init.filepath,
configFilepath: init.configFilepath,
ignoreCache: init.ignoreCache,
logger: init.logger
});
} else if (!ssoStartUrl || !ssoAccountId || !ssoRegion || !ssoRoleName) {
throw new import_config17.CredentialsProviderError("Incomplete configuration. The fromSSO() argument hash must include " + '"ssoStartUrl", "ssoAccountId", "ssoRegion", "ssoRoleName"', { tryNextLink: false, logger: init.logger });
} else {
return resolveSSOCredentials({
ssoStartUrl,
ssoSession,
ssoAccountId,
ssoRegion,
ssoRoleName,
ssoClient,
clientConfig: init.clientConfig,
parentClientConfig: init.parentClientConfig,
callerClientConfig: init.callerClientConfig,
profile: profileName,
filepath: init.filepath,
configFilepath: init.configFilepath,
ignoreCache: init.ignoreCache,
logger: init.logger
});
}
};
var init_fromSSO = __esm(() => {
init_resolveSSOCredentials();
init_validateSsoProfile();
import_config17 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-sso@3.973.14/node_modules/@aws-sdk/credential-provider-sso/dist-es/index.js
var init_dist_es5 = __esm(() => {
init_fromSSO();
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.973.15/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveCredentialSource.js
var import_client7, import_config18, resolveCredentialSource = (credentialSource, profileName, logger) => {
const sourceProvidersMap = {
EcsContainer: async (options) => {
await Promise.resolve().then(() => init_dist_es3());
await Promise.resolve().then(() => init_dist_es2());
logger?.debug("@aws-sdk/credential-provider-ini - credential_source is EcsContainer");
return async () => import_config18.chain(fromHttp(options ?? {}), fromContainerMetadata(options))().then(setNamedProvider);
},
Ec2InstanceMetadata: async (options) => {
logger?.debug("@aws-sdk/credential-provider-ini - credential_source is Ec2InstanceMetadata");
await Promise.resolve().then(() => init_dist_es2());
return async () => fromInstanceMetadata(options)().then(setNamedProvider);
},
Environment: async (options) => {
logger?.debug("@aws-sdk/credential-provider-ini - credential_source is Environment");
await Promise.resolve().then(() => init_dist_es());
return async () => fromEnv(options)().then(setNamedProvider);
}
};
if (credentialSource in sourceProvidersMap) {
return sourceProvidersMap[credentialSource];
} else {
throw new import_config18.CredentialsProviderError(`Unsupported credential source in profile ${profileName}. Got ${credentialSource}, expected EcsContainer or Ec2InstanceMetadata or Environment.`, { logger });
}
}, setNamedProvider = (creds) => import_client7.setCredentialFeature(creds, "CREDENTIALS_PROFILE_NAMED_PROVIDER", "p");
var init_resolveCredentialSource = __esm(() => {
import_client7 = __toESM(require_client2());
import_config18 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+signature-v4-multi-region@3.996.46/node_modules/@aws-sdk/signature-v4-multi-region/dist-cjs/index.js
var require_dist_cjs6 = __commonJS(function(exports) {
var { SignatureV4, signatureV4aContainer } = require_dist_cjs3();
var signatureV4CrtContainer = {
CrtSignerV4: null
};
var SESSION_TOKEN_QUERY_PARAM = "X-Amz-S3session-Token";
var SESSION_TOKEN_HEADER = SESSION_TOKEN_QUERY_PARAM.toLowerCase();
class SignatureV4SignWithCredentials extends SignatureV4 {
async signWithCredentials(requestToSign, credentials, options) {
const credentialsWithoutSessionToken = getCredentialsWithoutSessionToken(credentials);
requestToSign.headers[SESSION_TOKEN_HEADER] = credentials.sessionToken;
const privateAccess = this;
setSingleOverride(privateAccess, credentialsWithoutSessionToken);
return privateAccess.signRequest(requestToSign, options ?? {});
}
async presignWithCredentials(requestToSign, credentials, options) {
const credentialsWithoutSessionToken = getCredentialsWithoutSessionToken(credentials);
delete requestToSign.headers[SESSION_TOKEN_HEADER];
requestToSign.headers[SESSION_TOKEN_QUERY_PARAM] = credentials.sessionToken;
requestToSign.query = requestToSign.query ?? {};
requestToSign.query[SESSION_TOKEN_QUERY_PARAM] = credentials.sessionToken;
const privateAccess = this;
setSingleOverride(privateAccess, credentialsWithoutSessionToken);
return this.presign(requestToSign, options);
}
}
function getCredentialsWithoutSessionToken(credentials) {
return {
accessKeyId: credentials.accessKeyId,
secretAccessKey: credentials.secretAccessKey,
expiration: credentials.expiration
};
}
function setSingleOverride(privateAccess, credentialsWithoutSessionToken) {
const currentCredentialProvider = privateAccess.credentialProvider;
privateAccess.credentialProvider = () => {
privateAccess.credentialProvider = currentCredentialProvider;
return Promise.resolve(credentialsWithoutSessionToken);
};
}
class SignatureV4MultiRegion {
sigv4aSigner;
sigv4Signer;
signerOptions;
static sigv4aDependency() {
if (typeof signatureV4CrtContainer.CrtSignerV4 === "function") {
return "crt";
} else if (typeof signatureV4aContainer.SignatureV4a === "function") {
return "js";
}
return "none";
}
constructor(options) {
this.sigv4Signer = new SignatureV4SignWithCredentials(options);
this.signerOptions = options;
}
async sign(requestToSign, options = {}) {
if (options.signingRegion === "*") {
return this.getSigv4aSigner().sign(requestToSign, options);
}
return this.sigv4Signer.sign(requestToSign, options);
}
async signWithCredentials(requestToSign, credentials, options = {}) {
if (options.signingRegion === "*") {
const signer = this.getSigv4aSigner();
const CrtSignerV4 = signatureV4CrtContainer.CrtSignerV4;
if (CrtSignerV4 && signer instanceof CrtSignerV4) {
return signer.signWithCredentials(requestToSign, credentials, options);
} else {
throw new Error(`signWithCredentials with signingRegion '*' is only supported when using the CRT dependency @aws-sdk/signature-v4-crt. ` + `Please check whether you have installed the "@aws-sdk/signature-v4-crt" package explicitly. ` + `You must also register the package by calling [require("@aws-sdk/signature-v4-crt");] ` + `or an ESM equivalent such as [import "@aws-sdk/signature-v4-crt";]. ` + `For more information please go to https://github.com/aws/aws-sdk-js-v3#functionality-requiring-aws-common-runtime-crt`);
}
}
return this.sigv4Signer.signWithCredentials(requestToSign, credentials, options);
}
async presign(originalRequest, options = {}) {
if (options.signingRegion === "*") {
const signer = this.getSigv4aSigner();
const CrtSignerV4 = signatureV4CrtContainer.CrtSignerV4;
if (CrtSignerV4 && signer instanceof CrtSignerV4) {
return signer.presign(originalRequest, options);
} else {
throw new Error(`presign with signingRegion '*' is only supported when using the CRT dependency @aws-sdk/signature-v4-crt. ` + `Please check whether you have installed the "@aws-sdk/signature-v4-crt" package explicitly. ` + `You must also register the package by calling [require("@aws-sdk/signature-v4-crt");] ` + `or an ESM equivalent such as [import "@aws-sdk/signature-v4-crt";]. ` + `For more information please go to https://github.com/aws/aws-sdk-js-v3#functionality-requiring-aws-common-runtime-crt`);
}
}
return this.sigv4Signer.presign(originalRequest, options);
}
async presignWithCredentials(originalRequest, credentials, options = {}) {
if (options.signingRegion === "*") {
throw new Error("Method presignWithCredentials is not supported for [signingRegion=*].");
}
return this.sigv4Signer.presignWithCredentials(originalRequest, credentials, options);
}
getSigv4aSigner() {
if (!this.sigv4aSigner) {
const CrtSignerV4 = signatureV4CrtContainer.CrtSignerV4;
const JsSigV4aSigner = signatureV4aContainer.SignatureV4a;
if (this.signerOptions.runtime === "node") {
if (!CrtSignerV4 && !JsSigV4aSigner) {
throw new Error("Neither CRT nor JS SigV4a implementation is available. " + "Please load either @aws-sdk/signature-v4-crt or @aws-sdk/signature-v4a. " + "For more information please go to " + "https://github.com/aws/aws-sdk-js-v3#functionality-requiring-aws-common-runtime-crt");
}
if (CrtSignerV4 && typeof CrtSignerV4 === "function") {
this.sigv4aSigner = new CrtSignerV4({
...this.signerOptions,
signingAlgorithm: 1
});
} else if (JsSigV4aSigner && typeof JsSigV4aSigner === "function") {
this.sigv4aSigner = new JsSigV4aSigner({
...this.signerOptions
});
} else {
throw new Error("Available SigV4a implementation is not a valid constructor. " + "Please ensure you've properly imported @aws-sdk/signature-v4-crt or @aws-sdk/signature-v4a." + "For more information please go to " + "https://github.com/aws/aws-sdk-js-v3#functionality-requiring-aws-common-runtime-crt");
}
} else {
if (!JsSigV4aSigner || typeof JsSigV4aSigner !== "function") {
throw new Error("JS SigV4a implementation is not available or not a valid constructor. " + "Please check whether you have installed the @aws-sdk/signature-v4a package explicitly. The CRT implementation is not available for browsers. " + "You must also register the package by calling [require('@aws-sdk/signature-v4a');] " + "or an ESM equivalent such as [import '@aws-sdk/signature-v4a';]. " + "For more information please go to " + "https://github.com/aws/aws-sdk-js-v3#using-javascript-non-crt-implementation-of-sigv4a");
}
this.sigv4aSigner = new JsSigV4aSigner({
...this.signerOptions
});
}
}
return this.sigv4aSigner;
}
}
exports.SignatureV4MultiRegion = SignatureV4MultiRegion;
exports.SignatureV4SignWithCredentials = SignatureV4SignWithCredentials;
exports.signatureV4CrtContainer = signatureV4CrtContainer;
});
// ../../node_modules/.bun/@aws-sdk+nested-clients@3.997.44/node_modules/@aws-sdk/nested-clients/dist-cjs/submodules/sts/index.js
var require_sts = __commonJS(function(exports) {
var { awsEndpointFunctions, emitWarningIfUnsupportedVersion: emitWarningIfUnsupportedVersion$1, createDefaultUserAgentProvider, NODE_APP_ID_CONFIG_OPTIONS, getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin, setCredentialFeature, stsRegionDefaultResolver } = require_client2();
var { NoAuthSigner, getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin } = require_dist_cjs2();
var { normalizeProvider, getSmithyContext, ServiceException, NoOpLogger, emitWarningIfUnsupportedVersion, loadConfigsForDefaultMode, getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, makeBuilder, createAggregatedClient } = require_client();
var { Command: $Command } = require_client();
exports.$Command = $Command;
exports.__Client = Client;
var { resolveDefaultsModeConfig, loadConfig, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS, resolveRegionConfig } = require_config();
var { BinaryDecisionDiagram, EndpointCache, decideEndpoint, customEndpointFunctions, resolveParams, resolveEndpointConfig, getEndpointPlugin } = require_endpoints();
var { parseUrl, getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require_protocols();
var { DEFAULT_RETRY_MODE, NODE_RETRY_MODE_CONFIG_OPTIONS, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, resolveRetryConfig, getRetryPlugin } = require_retry();
var { TypeRegistry, getSchemaSerdePlugin } = require_schema();
var { resolveAwsSdkSigV4Config, resolveAwsSdkSigV4AConfig, AwsSdkSigV4Signer, AwsSdkSigV4ASigner, NODE_SIGV4A_CONFIG_OPTIONS, NODE_AUTH_SCHEME_PREFERENCE_OPTIONS } = require_httpAuthSchemes();
var { SignatureV4MultiRegion } = require_dist_cjs6();
var { toUtf8, fromUtf8, toBase64, fromBase64, calculateBodyLength } = require_serde();
var { streamCollector, NodeHttpHandler } = require_dist_cjs4();
var { AwsQueryProtocol } = require_protocols2();
var { Sha256 } = require_checksum();
var q = "ref";
var a = -1;
var b = true;
var c = "isSet";
var d = "PartitionResult";
var e = "booleanEquals";
var f = "stringEquals";
var g = "getAttr";
var h = "us-east-1";
var i = "sigv4";
var j = "sts";
var k = "https://sts.{Region}.{PartitionResult#dnsSuffix}";
var l = { [q]: "Endpoint" };
var m = { [q]: "Region" };
var n = { [q]: d };
var o = {};
var p = [m];
var _data = {
conditions: [
[c, [l]],
[c, p],
["aws.partition", p, d],
[e, [{ [q]: "UseFIPS" }, b]],
[e, [{ [q]: "UseDualStack" }, b]],
[f, [m, "aws-global"]],
[e, [{ [q]: "UseGlobalEndpoint" }, b]],
[f, [m, "eu-central-1"]],
[e, [{ fn: g, argv: [n, "supportsDualStack"] }, b]],
[e, [{ fn: g, argv: [n, "supportsFIPS"] }, b]],
[f, [m, "ap-south-1"]],
[f, [m, "eu-north-1"]],
[f, [m, "eu-west-1"]],
[f, [m, "eu-west-2"]],
[f, [m, "eu-west-3"]],
[f, [m, "sa-east-1"]],
[f, [m, h]],
[f, [m, "us-east-2"]],
[f, [m, "us-west-2"]],
[f, [m, "us-west-1"]],
[f, [m, "ca-central-1"]],
[f, [m, "ap-southeast-1"]],
[f, [m, "ap-northeast-1"]],
[f, [m, "ap-southeast-2"]],
[f, [{ fn: g, argv: [n, "name"] }, "aws-us-gov"]]
],
results: [
[a],
["https://sts.amazonaws.com", { authSchemes: [{ name: i, signingName: j, signingRegion: h }] }],
[k, { authSchemes: [{ name: i, signingName: j, signingRegion: "{Region}" }] }],
[a, "Invalid Configuration: FIPS and custom endpoint are not supported"],
[a, "Invalid Configuration: Dualstack and custom endpoint are not supported"],
[l, o],
["https://sts-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", o],
[a, "FIPS and DualStack are enabled, but this partition does not support one or both"],
["https://sts.{Region}.amazonaws.com", o],
["https://sts-fips.{Region}.{PartitionResult#dnsSuffix}", o],
[a, "FIPS is enabled but this partition does not support FIPS"],
["https://sts.{Region}.{PartitionResult#dualStackDnsSuffix}", o],
[a, "DualStack is enabled but this partition does not support DualStack"],
[k, o],
[a, "Invalid Configuration: Missing Region"]
]
};
var root = 2;
var r = 1e8;
var nodes = new Int32Array([
-1,
1,
-1,
0,
30,
3,
1,
4,
r + 14,
2,
5,
r + 14,
3,
25,
6,
4,
24,
7,
5,
r + 1,
8,
6,
9,
r + 13,
7,
r + 1,
10,
10,
r + 1,
11,
11,
r + 1,
12,
12,
r + 1,
13,
13,
r + 1,
14,
14,
r + 1,
15,
15,
r + 1,
16,
16,
r + 1,
17,
17,
r + 1,
18,
18,
r + 1,
19,
19,
r + 1,
20,
20,
r + 1,
21,
21,
r + 1,
22,
22,
r + 1,
23,
23,
r + 1,
r + 2,
8,
r + 11,
r + 12,
4,
28,
26,
9,
27,
r + 10,
24,
r + 8,
r + 9,
8,
29,
r + 7,
9,
r + 6,
r + 7,
3,
r + 3,
31,
4,
r + 4,
r + 5
]);
var bdd = BinaryDecisionDiagram.from(nodes, root, _data.conditions, _data.results);
var cache = new EndpointCache({
size: 50,
params: ["Endpoint", "Region", "UseDualStack", "UseFIPS", "UseGlobalEndpoint"]
});
var defaultEndpointResolver = (endpointParams, context = {}) => {
return cache.get(endpointParams, () => decideEndpoint(bdd, {
endpointParams,
logger: context.logger
}));
};
customEndpointFunctions.aws = awsEndpointFunctions;
var createEndpointRuleSetHttpAuthSchemeParametersProvider = (defaultHttpAuthSchemeParametersProvider) => async (config, context, input) => {
if (!input) {
throw new Error("Could not find `input` for `defaultEndpointRuleSetHttpAuthSchemeParametersProvider`");
}
const defaultParameters = await defaultHttpAuthSchemeParametersProvider(config, context, input);
const instructionsFn = getSmithyContext(context)?.commandInstance?.constructor?.getEndpointParameterInstructions;
if (!instructionsFn) {
throw new Error(`getEndpointParameterInstructions() is not defined on '${context.commandName}'`);
}
const endpointParameters = await resolveParams(input, { getEndpointParameterInstructions: instructionsFn }, config);
return Object.assign(defaultParameters, endpointParameters);
};
var _defaultSTSHttpAuthSchemeParametersProvider = async (config, context, input) => {
return {
operation: getSmithyContext(context).operation,
region: await normalizeProvider(config.region)() || (() => {
throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
})()
};
};
var defaultSTSHttpAuthSchemeParametersProvider = createEndpointRuleSetHttpAuthSchemeParametersProvider(_defaultSTSHttpAuthSchemeParametersProvider);
function createAwsAuthSigv4HttpAuthOption(authParameters) {
return {
schemeId: "aws.auth#sigv4",
signingProperties: {
name: "sts",
region: authParameters.region
},
propertiesExtractor: (config, context) => ({
signingProperties: {
config,
context
}
})
};
}
function createAwsAuthSigv4aHttpAuthOption(authParameters) {
return {
schemeId: "aws.auth#sigv4a",
signingProperties: {
name: "sts",
region: authParameters.region
},
propertiesExtractor: (config, context) => ({
signingProperties: {
config,
context
}
})
};
}
function createSmithyApiNoAuthHttpAuthOption(authParameters) {
return {
schemeId: "smithy.api#noAuth"
};
}
var createEndpointRuleSetHttpAuthSchemeProvider = (defaultEndpointResolver, defaultHttpAuthSchemeResolver, createHttpAuthOptionFunctions) => {
const endpointRuleSetHttpAuthSchemeProvider = (authParameters) => {
const endpoint = defaultEndpointResolver(authParameters);
const authSchemes = endpoint.properties?.authSchemes;
if (!authSchemes) {
return defaultHttpAuthSchemeResolver(authParameters);
}
const options = [];
for (const scheme of authSchemes) {
const { name: resolvedName, properties = {}, ...rest } = scheme;
const name = resolvedName.toLowerCase();
if (resolvedName !== name) {
console.warn(`HttpAuthScheme has been normalized with lowercasing: '${resolvedName}' to '${name}'`);
}
let schemeId;
if (name === "sigv4a") {
schemeId = "aws.auth#sigv4a";
const sigv4Present = authSchemes.find((s) => {
const name = s.name.toLowerCase();
return name !== "sigv4a" && name.startsWith("sigv4");
});
if (SignatureV4MultiRegion.sigv4aDependency() === "none" && sigv4Present) {
continue;
}
} else if (name.startsWith("sigv4")) {
schemeId = "aws.auth#sigv4";
} else {
throw new Error(`Unknown HttpAuthScheme found in '@smithy.rules#endpointRuleSet': '${name}'`);
}
const createOption = createHttpAuthOptionFunctions[schemeId];
if (!createOption) {
throw new Error(`Could not find HttpAuthOption create function for '${schemeId}'`);
}
const option = createOption(authParameters);
option.schemeId = schemeId;
option.signingProperties = { ...option.signingProperties || {}, ...rest, ...properties };
options.push(option);
}
return options;
};
return endpointRuleSetHttpAuthSchemeProvider;
};
var _defaultSTSHttpAuthSchemeProvider = (authParameters) => {
const options = [];
switch (authParameters.operation) {
case "AssumeRoleWithWebIdentity": {
options.push(createSmithyApiNoAuthHttpAuthOption());
options.push(createAwsAuthSigv4aHttpAuthOption(authParameters));
break;
}
default: {
options.push(createAwsAuthSigv4HttpAuthOption(authParameters));
options.push(createAwsAuthSigv4aHttpAuthOption(authParameters));
}
}
return options;
};
var defaultSTSHttpAuthSchemeProvider = createEndpointRuleSetHttpAuthSchemeProvider(defaultEndpointResolver, _defaultSTSHttpAuthSchemeProvider, {
"aws.auth#sigv4": createAwsAuthSigv4HttpAuthOption,
"aws.auth#sigv4a": createAwsAuthSigv4aHttpAuthOption,
"smithy.api#noAuth": createSmithyApiNoAuthHttpAuthOption
});
var resolveHttpAuthSchemeConfig = (config) => {
const config_0 = resolveAwsSdkSigV4Config(config);
const config_1 = resolveAwsSdkSigV4AConfig(config_0);
return Object.assign(config_1, {
authSchemePreference: normalizeProvider(config.authSchemePreference ?? [])
});
};
var resolveClientEndpointParameters = (options) => {
return Object.assign(options, {
useDualstackEndpoint: options.useDualstackEndpoint ?? false,
useFipsEndpoint: options.useFipsEndpoint ?? false,
useGlobalEndpoint: options.useGlobalEndpoint ?? false,
defaultSigningName: "sts"
});
};
var commonParams = {
UseGlobalEndpoint: { type: "builtInParams", name: "useGlobalEndpoint" },
UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
Endpoint: { type: "builtInParams", name: "endpoint" },
Region: { type: "builtInParams", name: "region" },
UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
};
var version = "3.997.43";
var packageInfo = {
version
};
class STSServiceException extends ServiceException {
constructor(options) {
super(options);
Object.setPrototypeOf(this, STSServiceException.prototype);
}
}
class ExpiredTokenException extends STSServiceException {
name = "ExpiredTokenException";
$fault = "client";
constructor(opts) {
super({
name: "ExpiredTokenException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, ExpiredTokenException.prototype);
}
}
class MalformedPolicyDocumentException extends STSServiceException {
name = "MalformedPolicyDocumentException";
$fault = "client";
constructor(opts) {
super({
name: "MalformedPolicyDocumentException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, MalformedPolicyDocumentException.prototype);
}
}
class PackedPolicyTooLargeException extends STSServiceException {
name = "PackedPolicyTooLargeException";
$fault = "client";
constructor(opts) {
super({
name: "PackedPolicyTooLargeException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, PackedPolicyTooLargeException.prototype);
}
}
class RegionDisabledException extends STSServiceException {
name = "RegionDisabledException";
$fault = "client";
constructor(opts) {
super({
name: "RegionDisabledException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, RegionDisabledException.prototype);
}
}
class IDPRejectedClaimException extends STSServiceException {
name = "IDPRejectedClaimException";
$fault = "client";
constructor(opts) {
super({
name: "IDPRejectedClaimException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, IDPRejectedClaimException.prototype);
}
}
class InvalidIdentityTokenException extends STSServiceException {
name = "InvalidIdentityTokenException";
$fault = "client";
constructor(opts) {
super({
name: "InvalidIdentityTokenException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidIdentityTokenException.prototype);
}
}
class IDPCommunicationErrorException extends STSServiceException {
name = "IDPCommunicationErrorException";
$fault = "client";
$retryable = {};
constructor(opts) {
super({
name: "IDPCommunicationErrorException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, IDPCommunicationErrorException.prototype);
}
}
var _A = "Arn";
var _AKI = "AccessKeyId";
var _AR = "AssumeRole";
var _ARI = "AssumedRoleId";
var _ARR = "AssumeRoleRequest";
var _ARRs = "AssumeRoleResponse";
var _ARU = "AssumedRoleUser";
var _ARWWI = "AssumeRoleWithWebIdentity";
var _ARWWIR = "AssumeRoleWithWebIdentityRequest";
var _ARWWIRs = "AssumeRoleWithWebIdentityResponse";
var _Au = "Audience";
var _C = "Credentials";
var _CA = "ContextAssertion";
var _DS = "DurationSeconds";
var _E = "Expiration";
var _EI = "ExternalId";
var _ETE = "ExpiredTokenException";
var _IDPCEE = "IDPCommunicationErrorException";
var _IDPRCE = "IDPRejectedClaimException";
var _IITE = "InvalidIdentityTokenException";
var _K = "Key";
var _MPDE = "MalformedPolicyDocumentException";
var _P = "Policy";
var _PA = "PolicyArns";
var _PAr = "ProviderArn";
var _PC = "ProvidedContexts";
var _PCLT = "ProvidedContextsListType";
var _PCr = "ProvidedContext";
var _PDT = "PolicyDescriptorType";
var _PI = "ProviderId";
var _PPS = "PackedPolicySize";
var _PPTLE = "PackedPolicyTooLargeException";
var _Pr = "Provider";
var _RA = "RoleArn";
var _RDE = "RegionDisabledException";
var _RSN = "RoleSessionName";
var _SAK = "SecretAccessKey";
var _SFWIT = "SubjectFromWebIdentityToken";
var _SI = "SourceIdentity";
var _SN = "SerialNumber";
var _ST = "SessionToken";
var _T = "Tags";
var _TC = "TokenCode";
var _TTK = "TransitiveTagKeys";
var _Ta = "Tag";
var _V = "Value";
var _WIT = "WebIdentityToken";
var _a = "arn";
var _aKST = "accessKeySecretType";
var _aQE = "awsQueryError";
var _c = "client";
var _cTT = "clientTokenType";
var _e = "error";
var _hE = "httpError";
var _m = "message";
var _pDLT = "policyDescriptorListType";
var _s = "smithy.ts.sdk.synthetic.com.amazonaws.sts";
var _tLT = "tagListType";
var n0 = "com.amazonaws.sts";
var _s_registry = TypeRegistry.for(_s);
var STSServiceException$ = [-3, _s, "STSServiceException", 0, [], []];
_s_registry.registerError(STSServiceException$, STSServiceException);
var n0_registry = TypeRegistry.for(n0);
var ExpiredTokenException$ = [
-3,
n0,
_ETE,
{ [_aQE]: [`ExpiredTokenException`, 400], [_e]: _c, [_hE]: 400 },
[_m],
[0]
];
n0_registry.registerError(ExpiredTokenException$, ExpiredTokenException);
var IDPCommunicationErrorException$ = [
-3,
n0,
_IDPCEE,
{ [_aQE]: [`IDPCommunicationError`, 400], [_e]: _c, [_hE]: 400 },
[_m],
[0]
];
n0_registry.registerError(IDPCommunicationErrorException$, IDPCommunicationErrorException);
var IDPRejectedClaimException$ = [
-3,
n0,
_IDPRCE,
{ [_aQE]: [`IDPRejectedClaim`, 403], [_e]: _c, [_hE]: 403 },
[_m],
[0]
];
n0_registry.registerError(IDPRejectedClaimException$, IDPRejectedClaimException);
var InvalidIdentityTokenException$ = [
-3,
n0,
_IITE,
{ [_aQE]: [`InvalidIdentityToken`, 400], [_e]: _c, [_hE]: 400 },
[_m],
[0]
];
n0_registry.registerError(InvalidIdentityTokenException$, InvalidIdentityTokenException);
var MalformedPolicyDocumentException$ = [
-3,
n0,
_MPDE,
{ [_aQE]: [`MalformedPolicyDocument`, 400], [_e]: _c, [_hE]: 400 },
[_m],
[0]
];
n0_registry.registerError(MalformedPolicyDocumentException$, MalformedPolicyDocumentException);
var PackedPolicyTooLargeException$ = [
-3,
n0,
_PPTLE,
{ [_aQE]: [`PackedPolicyTooLarge`, 400], [_e]: _c, [_hE]: 400 },
[_m],
[0]
];
n0_registry.registerError(PackedPolicyTooLargeException$, PackedPolicyTooLargeException);
var RegionDisabledException$ = [
-3,
n0,
_RDE,
{ [_aQE]: [`RegionDisabledException`, 403], [_e]: _c, [_hE]: 403 },
[_m],
[0]
];
n0_registry.registerError(RegionDisabledException$, RegionDisabledException);
var errorTypeRegistries = [
_s_registry,
n0_registry
];
var accessKeySecretType = [0, n0, _aKST, 8, 0];
var clientTokenType = [0, n0, _cTT, 8, 0];
var AssumedRoleUser$ = [
3,
n0,
_ARU,
0,
[_ARI, _A],
[0, 0],
2
];
var AssumeRoleRequest$ = [
3,
n0,
_ARR,
0,
[_RA, _RSN, _PA, _P, _DS, _T, _TTK, _EI, _SN, _TC, _SI, _PC],
[0, 0, () => policyDescriptorListType, 0, 1, () => tagListType, 64 | 0, 0, 0, 0, 0, () => ProvidedContextsListType],
2
];
var AssumeRoleResponse$ = [
3,
n0,
_ARRs,
0,
[_C, _ARU, _PPS, _SI],
[[() => Credentials$, 0], () => AssumedRoleUser$, 1, 0]
];
var AssumeRoleWithWebIdentityRequest$ = [
3,
n0,
_ARWWIR,
0,
[_RA, _RSN, _WIT, _PI, _PA, _P, _DS],
[0, 0, [() => clientTokenType, 0], 0, () => policyDescriptorListType, 0, 1],
3
];
var AssumeRoleWithWebIdentityResponse$ = [
3,
n0,
_ARWWIRs,
0,
[_C, _SFWIT, _ARU, _PPS, _Pr, _Au, _SI],
[[() => Credentials$, 0], 0, () => AssumedRoleUser$, 1, 0, 0, 0]
];
var Credentials$ = [
3,
n0,
_C,
0,
[_AKI, _SAK, _ST, _E],
[0, [() => accessKeySecretType, 0], 0, 4],
4
];
var PolicyDescriptorType$ = [
3,
n0,
_PDT,
0,
[_a],
[0]
];
var ProvidedContext$ = [
3,
n0,
_PCr,
0,
[_PAr, _CA],
[0, 0]
];
var Tag$ = [
3,
n0,
_Ta,
0,
[_K, _V],
[0, 0],
2
];
var policyDescriptorListType = [
1,
n0,
_pDLT,
0,
() => PolicyDescriptorType$
];
var ProvidedContextsListType = [
1,
n0,
_PCLT,
0,
() => ProvidedContext$
];
var tagListType = [
1,
n0,
_tLT,
0,
() => Tag$
];
var AssumeRole$ = [
9,
n0,
_AR,
0,
() => AssumeRoleRequest$,
() => AssumeRoleResponse$
];
var AssumeRoleWithWebIdentity$ = [
9,
n0,
_ARWWI,
0,
() => AssumeRoleWithWebIdentityRequest$,
() => AssumeRoleWithWebIdentityResponse$
];
var getRuntimeConfig$1 = (config) => {
return {
apiVersion: "2011-06-15",
base64Decoder: config?.base64Decoder ?? fromBase64,
base64Encoder: config?.base64Encoder ?? toBase64,
disableHostPrefix: config?.disableHostPrefix ?? false,
endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
extensions: config?.extensions ?? [],
httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultSTSHttpAuthSchemeProvider,
httpAuthSchemes: config?.httpAuthSchemes ?? [
{
schemeId: "aws.auth#sigv4",
identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
signer: new AwsSdkSigV4Signer
},
{
schemeId: "aws.auth#sigv4a",
identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4a"),
signer: new AwsSdkSigV4ASigner
},
{
schemeId: "smithy.api#noAuth",
identityProvider: (ipc) => ipc.getIdentityProvider("smithy.api#noAuth") || (async () => ({})),
signer: new NoAuthSigner
}
],
logger: config?.logger ?? new NoOpLogger,
protocol: config?.protocol ?? AwsQueryProtocol,
protocolSettings: config?.protocolSettings ?? {
defaultNamespace: "com.amazonaws.sts",
errorTypeRegistries,
xmlNamespace: "https://sts.amazonaws.com/doc/2011-06-15/",
version: "2011-06-15",
serviceTarget: "AWSSecurityTokenServiceV20110615"
},
serviceId: config?.serviceId ?? "STS",
sha256: config?.sha256 ?? Sha256,
signerConstructor: config?.signerConstructor ?? SignatureV4MultiRegion,
urlParser: config?.urlParser ?? parseUrl,
utf8Decoder: config?.utf8Decoder ?? fromUtf8,
utf8Encoder: config?.utf8Encoder ?? toUtf8
};
};
var getRuntimeConfig = (config) => {
emitWarningIfUnsupportedVersion(process.version);
const defaultsMode = resolveDefaultsModeConfig(config);
const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
const clientSharedValues = getRuntimeConfig$1(config);
emitWarningIfUnsupportedVersion$1(process.version);
const loaderConfig = {
profile: config?.profile,
logger: clientSharedValues.logger
};
return {
...clientSharedValues,
...config,
runtime: "node",
defaultsMode,
authSchemePreference: config?.authSchemePreference ?? loadConfig(NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
defaultUserAgentProvider: config?.defaultUserAgentProvider ?? createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: packageInfo.version }),
httpAuthSchemes: config?.httpAuthSchemes ?? [
{
schemeId: "aws.auth#sigv4",
identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4") || (async (idProps) => await config.credentialDefaultProvider(idProps?.__config || {})()),
signer: new AwsSdkSigV4Signer
},
{
schemeId: "aws.auth#sigv4a",
identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4a"),
signer: new AwsSdkSigV4ASigner
},
{
schemeId: "smithy.api#noAuth",
identityProvider: (ipc) => ipc.getIdentityProvider("smithy.api#noAuth") || (async () => ({})),
signer: new NoAuthSigner
}
],
maxAttempts: config?.maxAttempts ?? loadConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
region: config?.region ?? loadConfig(NODE_REGION_CONFIG_OPTIONS, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
requestHandler: NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
retryMode: config?.retryMode ?? loadConfig({
...NODE_RETRY_MODE_CONFIG_OPTIONS,
default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE
}, config),
sigv4aSigningRegionSet: config?.sigv4aSigningRegionSet ?? loadConfig(NODE_SIGV4A_CONFIG_OPTIONS, loaderConfig),
streamCollector: config?.streamCollector ?? streamCollector,
useDualstackEndpoint: config?.useDualstackEndpoint ?? loadConfig(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
useFipsEndpoint: config?.useFipsEndpoint ?? loadConfig(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
userAgentAppId: config?.userAgentAppId ?? loadConfig(NODE_APP_ID_CONFIG_OPTIONS, loaderConfig)
};
};
var getHttpAuthExtensionConfiguration = (runtimeConfig) => {
const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
let _credentials = runtimeConfig.credentials;
return {
setHttpAuthScheme(httpAuthScheme) {
const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
if (index === -1) {
_httpAuthSchemes.push(httpAuthScheme);
} else {
_httpAuthSchemes.splice(index, 1, httpAuthScheme);
}
},
httpAuthSchemes() {
return _httpAuthSchemes;
},
setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
_httpAuthSchemeProvider = httpAuthSchemeProvider;
},
httpAuthSchemeProvider() {
return _httpAuthSchemeProvider;
},
setCredentials(credentials) {
_credentials = credentials;
},
credentials() {
return _credentials;
}
};
};
var resolveHttpAuthRuntimeConfig = (config) => {
return {
httpAuthSchemes: config.httpAuthSchemes(),
httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
credentials: config.credentials()
};
};
var resolveRuntimeExtensions = (runtimeConfig, extensions) => {
const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
extensions.forEach((extension) => extension.configure(extensionConfiguration));
return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
};
class STSClient extends Client {
config;
constructor(...[configuration]) {
const _config_0 = getRuntimeConfig(configuration || {});
super(_config_0);
this.initConfig = _config_0;
const _config_1 = resolveClientEndpointParameters(_config_0);
const _config_2 = resolveUserAgentConfig(_config_1);
const _config_3 = resolveRetryConfig(_config_2);
const _config_4 = resolveRegionConfig(_config_3);
const _config_5 = resolveHostHeaderConfig(_config_4);
const _config_6 = resolveEndpointConfig(_config_5);
const _config_7 = resolveHttpAuthSchemeConfig(_config_6);
const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
this.config = _config_8;
this.middlewareStack.use(getSchemaSerdePlugin(this.config));
this.middlewareStack.use(getUserAgentPlugin(this.config));
this.middlewareStack.use(getRetryPlugin(this.config));
this.middlewareStack.use(getContentLengthPlugin(this.config));
this.middlewareStack.use(getHostHeaderPlugin(this.config));
this.middlewareStack.use(getLoggerPlugin(this.config));
this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
httpAuthSchemeParametersProvider: defaultSTSHttpAuthSchemeParametersProvider,
identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
"aws.auth#sigv4": config.credentials,
"aws.auth#sigv4a": config.credentials
})
}));
this.middlewareStack.use(getHttpSigningPlugin(this.config));
}
destroy() {
super.destroy();
}
}
var command = makeBuilder(commonParams, "AWSSecurityTokenServiceV20110615", "STSClient", getEndpointPlugin);
var _ep0 = {};
var _mw0 = (Command, cs, config, o) => [];
class AssumeRoleCommand extends command(_ep0, _mw0, "AssumeRole", AssumeRole$) {
}
class AssumeRoleWithWebIdentityCommand extends command(_ep0, _mw0, "AssumeRoleWithWebIdentity", AssumeRoleWithWebIdentity$) {
}
var commands = {
AssumeRoleCommand,
AssumeRoleWithWebIdentityCommand
};
class STS extends STSClient {
}
createAggregatedClient(commands, STS);
var getAccountIdFromAssumedRoleUser = (assumedRoleUser) => {
if (typeof assumedRoleUser?.Arn === "string") {
const arnComponents = assumedRoleUser.Arn.split(":");
if (arnComponents.length > 4 && arnComponents[4] !== "") {
return arnComponents[4];
}
}
return;
};
var resolveRegion = async (_region, _parentRegion, credentialProviderLogger, loaderConfig = {}) => {
const region = typeof _region === "function" ? await _region() : _region;
const parentRegion = typeof _parentRegion === "function" ? await _parentRegion() : _parentRegion;
let stsDefaultRegion = "";
const resolvedRegion = region ?? parentRegion ?? (stsDefaultRegion = await stsRegionDefaultResolver(loaderConfig)());
credentialProviderLogger?.debug?.("@aws-sdk/client-sts::resolveRegion", "accepting first of:", `${region} (credential provider clientConfig)`, `${parentRegion} (contextual client)`, `${stsDefaultRegion} (STS default: AWS_REGION, profile region, or us-east-1)`);
return resolvedRegion;
};
var getDefaultRoleAssumer$1 = (stsOptions, STSClient) => {
let stsClient;
let closureSourceCreds;
return async (sourceCreds, params) => {
closureSourceCreds = sourceCreds;
if (!stsClient) {
const { logger = stsOptions?.parentClientConfig?.logger, profile = stsOptions?.parentClientConfig?.profile, region, requestHandler = stsOptions?.parentClientConfig?.requestHandler, credentialProviderLogger, userAgentAppId = stsOptions?.parentClientConfig?.userAgentAppId } = stsOptions;
const resolvedRegion = await resolveRegion(region, stsOptions?.parentClientConfig?.region, credentialProviderLogger, {
logger,
profile
});
const isCompatibleRequestHandler = !isH2(requestHandler);
stsClient = new STSClient({
...stsOptions,
userAgentAppId,
profile,
credentialDefaultProvider: () => async () => closureSourceCreds,
region: resolvedRegion,
requestHandler: isCompatibleRequestHandler ? requestHandler : undefined,
logger
});
}
const { Credentials, AssumedRoleUser } = await stsClient.send(new AssumeRoleCommand(params));
if (!Credentials || !Credentials.AccessKeyId || !Credentials.SecretAccessKey) {
throw new Error(`Invalid response from STS.assumeRole call with role ${params.RoleArn}`);
}
const accountId = getAccountIdFromAssumedRoleUser(AssumedRoleUser);
const credentials = {
accessKeyId: Credentials.AccessKeyId,
secretAccessKey: Credentials.SecretAccessKey,
sessionToken: Credentials.SessionToken,
expiration: Credentials.Expiration,
...Credentials.CredentialScope && { credentialScope: Credentials.CredentialScope },
...accountId && { accountId }
};
setCredentialFeature(credentials, "CREDENTIALS_STS_ASSUME_ROLE", "i");
return credentials;
};
};
var getDefaultRoleAssumerWithWebIdentity$1 = (stsOptions, STSClient) => {
let stsClient;
return async (params) => {
if (!stsClient) {
const { logger = stsOptions?.parentClientConfig?.logger, profile = stsOptions?.parentClientConfig?.profile, region, requestHandler = stsOptions?.parentClientConfig?.requestHandler, credentialProviderLogger, userAgentAppId = stsOptions?.parentClientConfig?.userAgentAppId } = stsOptions;
const resolvedRegion = await resolveRegion(region, stsOptions?.parentClientConfig?.region, credentialProviderLogger, {
logger,
profile
});
const isCompatibleRequestHandler = !isH2(requestHandler);
stsClient = new STSClient({
...stsOptions,
userAgentAppId,
profile,
region: resolvedRegion,
requestHandler: isCompatibleRequestHandler ? requestHandler : undefined,
logger
});
}
const { Credentials, AssumedRoleUser } = await stsClient.send(new AssumeRoleWithWebIdentityCommand(params));
if (!Credentials || !Credentials.AccessKeyId || !Credentials.SecretAccessKey) {
throw new Error(`Invalid response from STS.assumeRoleWithWebIdentity call with role ${params.RoleArn}`);
}
const accountId = getAccountIdFromAssumedRoleUser(AssumedRoleUser);
const credentials = {
accessKeyId: Credentials.AccessKeyId,
secretAccessKey: Credentials.SecretAccessKey,
sessionToken: Credentials.SessionToken,
expiration: Credentials.Expiration,
...Credentials.CredentialScope && { credentialScope: Credentials.CredentialScope },
...accountId && { accountId }
};
if (accountId) {
setCredentialFeature(credentials, "RESOLVED_ACCOUNT_ID", "T");
}
setCredentialFeature(credentials, "CREDENTIALS_STS_ASSUME_ROLE_WEB_ID", "k");
return credentials;
};
};
var isH2 = (requestHandler) => {
return requestHandler?.metadata?.handlerProtocol === "h2";
};
var getCustomizableStsClientCtor = (baseCtor, customizations) => {
if (!customizations)
return baseCtor;
else
return class CustomizableSTSClient extends baseCtor {
constructor(config) {
super(config);
for (const customization of customizations) {
this.middlewareStack.use(customization);
}
}
};
};
var getDefaultRoleAssumer = (stsOptions = {}, stsPlugins) => getDefaultRoleAssumer$1(stsOptions, getCustomizableStsClientCtor(STSClient, stsPlugins));
var getDefaultRoleAssumerWithWebIdentity = (stsOptions = {}, stsPlugins) => getDefaultRoleAssumerWithWebIdentity$1(stsOptions, getCustomizableStsClientCtor(STSClient, stsPlugins));
var decorateDefaultCredentialProvider = (provider) => (input) => provider({
roleAssumer: getDefaultRoleAssumer(input),
roleAssumerWithWebIdentity: getDefaultRoleAssumerWithWebIdentity(input),
...input
});
exports.AssumeRole$ = AssumeRole$;
exports.AssumeRoleCommand = AssumeRoleCommand;
exports.AssumeRoleRequest$ = AssumeRoleRequest$;
exports.AssumeRoleResponse$ = AssumeRoleResponse$;
exports.AssumeRoleWithWebIdentity$ = AssumeRoleWithWebIdentity$;
exports.AssumeRoleWithWebIdentityCommand = AssumeRoleWithWebIdentityCommand;
exports.AssumeRoleWithWebIdentityRequest$ = AssumeRoleWithWebIdentityRequest$;
exports.AssumeRoleWithWebIdentityResponse$ = AssumeRoleWithWebIdentityResponse$;
exports.AssumedRoleUser$ = AssumedRoleUser$;
exports.Credentials$ = Credentials$;
exports.ExpiredTokenException = ExpiredTokenException;
exports.ExpiredTokenException$ = ExpiredTokenException$;
exports.IDPCommunicationErrorException = IDPCommunicationErrorException;
exports.IDPCommunicationErrorException$ = IDPCommunicationErrorException$;
exports.IDPRejectedClaimException = IDPRejectedClaimException;
exports.IDPRejectedClaimException$ = IDPRejectedClaimException$;
exports.InvalidIdentityTokenException = InvalidIdentityTokenException;
exports.InvalidIdentityTokenException$ = InvalidIdentityTokenException$;
exports.MalformedPolicyDocumentException = MalformedPolicyDocumentException;
exports.MalformedPolicyDocumentException$ = MalformedPolicyDocumentException$;
exports.PackedPolicyTooLargeException = PackedPolicyTooLargeException;
exports.PackedPolicyTooLargeException$ = PackedPolicyTooLargeException$;
exports.PolicyDescriptorType$ = PolicyDescriptorType$;
exports.ProvidedContext$ = ProvidedContext$;
exports.RegionDisabledException = RegionDisabledException;
exports.RegionDisabledException$ = RegionDisabledException$;
exports.STS = STS;
exports.STSClient = STSClient;
exports.STSServiceException = STSServiceException;
exports.STSServiceException$ = STSServiceException$;
exports.Tag$ = Tag$;
exports.decorateDefaultCredentialProvider = decorateDefaultCredentialProvider;
exports.errorTypeRegistries = errorTypeRegistries;
exports.getDefaultRoleAssumer = getDefaultRoleAssumer;
exports.getDefaultRoleAssumerWithWebIdentity = getDefaultRoleAssumerWithWebIdentity;
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.973.15/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveAssumeRoleCredentials.js
var import_client8, import_config19, isAssumeRoleProfile = (arg, { profile = "default", logger } = {}) => {
return Boolean(arg) && typeof arg === "object" && typeof arg.role_arn === "string" && ["undefined", "string"].indexOf(typeof arg.role_session_name) > -1 && ["undefined", "string"].indexOf(typeof arg.external_id) > -1 && ["undefined", "string"].indexOf(typeof arg.mfa_serial) > -1 && (isAssumeRoleWithSourceProfile(arg, { profile, logger }) || isCredentialSourceProfile(arg, { profile, logger }));
}, isAssumeRoleWithSourceProfile = (arg, { profile, logger }) => {
const withSourceProfile = typeof arg.source_profile === "string" && typeof arg.credential_source === "undefined";
if (withSourceProfile) {
logger?.debug?.(` ${profile} isAssumeRoleWithSourceProfile source_profile=${arg.source_profile}`);
}
return withSourceProfile;
}, isCredentialSourceProfile = (arg, { profile, logger }) => {
const withProviderProfile = typeof arg.credential_source === "string" && typeof arg.source_profile === "undefined";
if (withProviderProfile) {
logger?.debug?.(` ${profile} isCredentialSourceProfile credential_source=${arg.credential_source}`);
}
return withProviderProfile;
}, resolveAssumeRoleCredentials = async (profileName, profiles, options, callerClientConfig, visitedProfiles = {}, resolveProfileData) => {
options.logger?.debug("@aws-sdk/credential-provider-ini - resolveAssumeRoleCredentials (STS)");
const profileData = profiles[profileName];
const { source_profile, region } = profileData;
if (!options.roleAssumer) {
const { getDefaultRoleAssumer } = await Promise.resolve().then(() => __toESM(require_sts()));
options.roleAssumer = getDefaultRoleAssumer({
...options.clientConfig,
credentialProviderLogger: options.logger,
parentClientConfig: {
...callerClientConfig,
...options?.parentClientConfig,
region: region ?? options?.parentClientConfig?.region ?? callerClientConfig?.region
}
}, options.clientPlugins);
}
if (source_profile && source_profile in visitedProfiles) {
throw new import_config19.CredentialsProviderError(`Detected a cycle attempting to resolve credentials for profile ${import_config19.getProfileName(options)}. Profiles visited: ` + Object.keys(visitedProfiles).join(", "), { logger: options.logger });
}
options.logger?.debug(`@aws-sdk/credential-provider-ini - finding credential resolver using ${source_profile ? `source_profile=[${source_profile}]` : `profile=[${profileName}]`}`);
const sourceCredsProvider = source_profile ? resolveProfileData(source_profile, profiles, options, callerClientConfig, {
...visitedProfiles,
[source_profile]: true
}, isCredentialSourceWithoutRoleArn(profiles[source_profile] ?? {})) : (await resolveCredentialSource(profileData.credential_source, profileName, options.logger)(options))();
if (isCredentialSourceWithoutRoleArn(profileData)) {
return sourceCredsProvider.then((creds) => import_client8.setCredentialFeature(creds, "CREDENTIALS_PROFILE_SOURCE_PROFILE", "o"));
} else {
const params = {
RoleArn: profileData.role_arn,
RoleSessionName: profileData.role_session_name || `aws-sdk-js-${Date.now()}`,
ExternalId: profileData.external_id,
DurationSeconds: parseInt(profileData.duration_seconds || "3600", 10)
};
const { mfa_serial } = profileData;
if (mfa_serial) {
if (!options.mfaCodeProvider) {
throw new import_config19.CredentialsProviderError(`Profile ${profileName} requires multi-factor authentication, but no MFA code callback was provided.`, { logger: options.logger, tryNextLink: false });
}
params.SerialNumber = mfa_serial;
params.TokenCode = await options.mfaCodeProvider(mfa_serial);
}
const sourceCreds = await sourceCredsProvider;
return options.roleAssumer(sourceCreds, params).then((creds) => import_client8.setCredentialFeature(creds, "CREDENTIALS_PROFILE_SOURCE_PROFILE", "o"));
}
}, isCredentialSourceWithoutRoleArn = (section) => {
return !section.role_arn && !!section.credential_source;
};
var init_resolveAssumeRoleCredentials = __esm(() => {
init_resolveCredentialSource();
import_client8 = __toESM(require_client2());
import_config19 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+nested-clients@3.997.44/node_modules/@aws-sdk/nested-clients/dist-cjs/submodules/signin/index.js
var require_signin = __commonJS(function(exports) {
var { awsEndpointFunctions, emitWarningIfUnsupportedVersion: emitWarningIfUnsupportedVersion$1, createDefaultUserAgentProvider, NODE_APP_ID_CONFIG_OPTIONS, getAwsRegionExtensionConfiguration, resolveAwsRegionExtensionConfiguration, resolveUserAgentConfig, resolveHostHeaderConfig, getUserAgentPlugin, getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin } = require_client2();
var { NoAuthSigner, getHttpAuthSchemeEndpointRuleSetPlugin, DefaultIdentityProviderConfig, getHttpSigningPlugin } = require_dist_cjs2();
var { normalizeProvider, getSmithyContext, ServiceException, NoOpLogger, emitWarningIfUnsupportedVersion, loadConfigsForDefaultMode, getDefaultExtensionConfiguration, resolveDefaultRuntimeConfig, Client, makeBuilder, createAggregatedClient } = require_client();
var { Command: $Command } = require_client();
exports.$Command = $Command;
exports.__Client = Client;
var { resolveDefaultsModeConfig, loadConfig, NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, NODE_REGION_CONFIG_OPTIONS, NODE_REGION_CONFIG_FILE_OPTIONS, resolveRegionConfig } = require_config();
var { BinaryDecisionDiagram, EndpointCache, decideEndpoint, customEndpointFunctions, resolveEndpointConfig, getEndpointPlugin } = require_endpoints();
var { parseUrl, getHttpHandlerExtensionConfiguration, resolveHttpHandlerRuntimeConfig, getContentLengthPlugin } = require_protocols();
var { DEFAULT_RETRY_MODE, NODE_RETRY_MODE_CONFIG_OPTIONS, NODE_MAX_ATTEMPT_CONFIG_OPTIONS, resolveRetryConfig, getRetryPlugin } = require_retry();
var { TypeRegistry, getSchemaSerdePlugin } = require_schema();
var { resolveAwsSdkSigV4Config, AwsSdkSigV4Signer, NODE_AUTH_SCHEME_PREFERENCE_OPTIONS } = require_httpAuthSchemes();
var { toUtf8, fromUtf8, toBase64, fromBase64, calculateBodyLength } = require_serde();
var { streamCollector, NodeHttpHandler } = require_dist_cjs4();
var { AwsRestJsonProtocol } = require_protocols2();
var { Sha256 } = require_checksum();
var defaultSigninHttpAuthSchemeParametersProvider = async (config, context, input) => {
return {
operation: getSmithyContext(context).operation,
region: await normalizeProvider(config.region)() || (() => {
throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
})()
};
};
function createAwsAuthSigv4HttpAuthOption(authParameters) {
return {
schemeId: "aws.auth#sigv4",
signingProperties: {
name: "signin",
region: authParameters.region
},
propertiesExtractor: (config, context) => ({
signingProperties: {
config,
context
}
})
};
}
function createSmithyApiNoAuthHttpAuthOption(authParameters) {
return {
schemeId: "smithy.api#noAuth"
};
}
var defaultSigninHttpAuthSchemeProvider = (authParameters) => {
const options = [];
switch (authParameters.operation) {
case "CreateOAuth2Token": {
options.push(createSmithyApiNoAuthHttpAuthOption());
break;
}
default: {
options.push(createAwsAuthSigv4HttpAuthOption(authParameters));
}
}
return options;
};
var resolveHttpAuthSchemeConfig = (config) => {
const config_0 = resolveAwsSdkSigV4Config(config);
return Object.assign(config_0, {
authSchemePreference: normalizeProvider(config.authSchemePreference ?? [])
});
};
var resolveClientEndpointParameters = (options) => {
return Object.assign(options, {
useDualstackEndpoint: options.useDualstackEndpoint ?? false,
useFipsEndpoint: options.useFipsEndpoint ?? false,
defaultSigningName: "signin"
});
};
var commonParams = {
UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
Endpoint: { type: "builtInParams", name: "endpoint" },
Region: { type: "builtInParams", name: "region" },
UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
};
var version = "3.997.43";
var packageInfo = {
version
};
var s = "ref";
var a = -1;
var b = false;
var c = true;
var d = "isSet";
var e = "booleanEquals";
var f = "coalesce";
var g = "PartitionResult";
var h = "stringEquals";
var i = "getAttr";
var j = "https://signin.{Region}.{PartitionResult#dualStackDnsSuffix}";
var k = { [s]: "Endpoint" };
var l = { fn: i, argv: [{ [s]: g }, "name"] };
var m = { [s]: "Region" };
var n = { [s]: g };
var o = { authSchemes: [{ name: "sigv4", signingName: "signin", signingRegion: "{Region}" }] };
var p = {};
var q = [m];
var _data = {
conditions: [
[d, q],
[e, [{ fn: f, argv: [{ [s]: "IsControlPlane" }, b] }, c]],
[d, [k]],
["aws.partition", q, g],
[e, [{ [s]: "UseFIPS" }, c]],
[h, [l, "aws"]],
[e, [{ fn: f, argv: [{ [s]: "IsOAuthEndpoint" }, b] }, c]],
[e, [{ [s]: "UseDualStack" }, c]],
[h, [l, "aws-cn"]],
[h, [m, "us-gov-west-1"]],
[h, [l, "aws-us-gov"]],
[e, [{ fn: i, argv: [n, "supportsFIPS"] }, c]],
[h, [l, "aws-iso"]],
[h, [l, "aws-iso-b"]],
[h, [l, "aws-iso-f"]],
[h, [l, "aws-iso-e"]],
[h, [l, "aws-eusc"]],
[e, [{ fn: i, argv: [n, "supportsDualStack"] }, c]]
],
results: [
[a],
["https://signin.{Region}.api.aws", o],
["https://signin.{Region}.api.amazonwebservices.com.cn", o],
[j, o],
[a, "FIPS endpoints are not supported for OAuth operations. Disable FIPS or use a non-OAuth operation."],
["https://{Region}.oauth.signin.aws", o],
["https://{Region}.signin.aws.amazon.com", p],
["https://{Region}.signin.amazonaws.cn", p],
["https://{Region}.signin.amazonaws-us-gov.com", p],
["https://{Region}.signin.c2shome.ic.gov", p],
["https://{Region}.signin.sc2shome.sgov.gov", p],
["https://{Region}.signin.csphome.hci.ic.gov", p],
["https://{Region}.signin.csphome.adc-e.uk", p],
["https://{Region}.signin.amazonaws-eusc.eu", p],
["https://signin-fips.amazonaws-us-gov.com", p],
["https://{Region}.signin-fips.amazonaws-us-gov.com", p],
["https://{Region}.signin.{PartitionResult#dnsSuffix}", p],
[a, "Invalid Configuration: FIPS and custom endpoint are not supported"],
[a, "Invalid Configuration: Dualstack and custom endpoint are not supported"],
[k, p],
["https://signin-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", p],
[a, "FIPS and DualStack are enabled, but this partition does not support one or both"],
["https://signin-fips.{Region}.{PartitionResult#dnsSuffix}", p],
[a, "FIPS is enabled but this partition does not support FIPS"],
[j, p],
[a, "DualStack is enabled but this partition does not support DualStack"],
["https://signin.{Region}.{PartitionResult#dnsSuffix}", p],
[a, "Invalid Configuration: Missing Region"]
]
};
var root = 2;
var r = 1e8;
var nodes = new Int32Array([
-1,
1,
-1,
0,
6,
3,
2,
36,
4,
4,
5,
r + 27,
6,
r + 4,
r + 27,
1,
29,
7,
2,
36,
8,
3,
9,
31,
4,
22,
10,
5,
19,
11,
7,
21,
12,
8,
r + 7,
13,
10,
r + 8,
14,
12,
r + 9,
15,
13,
r + 10,
16,
14,
r + 11,
17,
15,
r + 12,
18,
16,
r + 13,
r + 16,
6,
r + 5,
20,
7,
21,
r + 6,
17,
r + 24,
r + 25,
6,
r + 4,
23,
7,
27,
24,
9,
r + 14,
25,
10,
r + 15,
26,
11,
r + 22,
r + 23,
11,
28,
r + 21,
17,
r + 20,
r + 21,
2,
35,
30,
3,
39,
31,
4,
32,
r + 27,
6,
r + 4,
33,
7,
r + 27,
34,
9,
r + 14,
r + 27,
3,
39,
36,
4,
38,
37,
7,
r + 18,
r + 19,
6,
r + 4,
r + 17,
5,
r + 1,
40,
8,
r + 2,
r + 3
]);
var bdd = BinaryDecisionDiagram.from(nodes, root, _data.conditions, _data.results);
var cache = new EndpointCache({
size: 50,
params: ["Endpoint", "IsControlPlane", "IsOAuthEndpoint", "Region", "UseDualStack", "UseFIPS"]
});
var defaultEndpointResolver = (endpointParams, context = {}) => {
return cache.get(endpointParams, () => decideEndpoint(bdd, {
endpointParams,
logger: context.logger
}));
};
customEndpointFunctions.aws = awsEndpointFunctions;
class SigninServiceException extends ServiceException {
constructor(options) {
super(options);
Object.setPrototypeOf(this, SigninServiceException.prototype);
}
}
class AccessDeniedException extends SigninServiceException {
name = "AccessDeniedException";
$fault = "client";
error;
constructor(opts) {
super({
name: "AccessDeniedException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, AccessDeniedException.prototype);
this.error = opts.error;
}
}
class InternalServerException extends SigninServiceException {
name = "InternalServerException";
$fault = "server";
error;
constructor(opts) {
super({
name: "InternalServerException",
$fault: "server",
...opts
});
Object.setPrototypeOf(this, InternalServerException.prototype);
this.error = opts.error;
}
}
class TooManyRequestsError extends SigninServiceException {
name = "TooManyRequestsError";
$fault = "client";
error;
constructor(opts) {
super({
name: "TooManyRequestsError",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TooManyRequestsError.prototype);
this.error = opts.error;
}
}
class ValidationException extends SigninServiceException {
name = "ValidationException";
$fault = "client";
error;
constructor(opts) {
super({
name: "ValidationException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, ValidationException.prototype);
this.error = opts.error;
}
}
var _ADE = "AccessDeniedException";
var _AT = "AccessToken";
var _COAT = "CreateOAuth2Token";
var _COATR = "CreateOAuth2TokenRequest";
var _COATRB = "CreateOAuth2TokenRequestBody";
var _COATRBr = "CreateOAuth2TokenResponseBody";
var _COATRr = "CreateOAuth2TokenResponse";
var _COATWIAM = "CreateOAuth2TokenWithIAM";
var _COATWIAMR = "CreateOAuth2TokenWithIAMRequest";
var _COATWIAMRr = "CreateOAuth2TokenWithIAMResponse";
var _ISE = "InternalServerException";
var _OAAT = "OAuthAccessToken";
var _RT = "RefreshToken";
var _TMRE = "TooManyRequestsError";
var _VE = "ValidationException";
var _aKI = "accessKeyId";
var _aT = "accessToken";
var _at = "access_token";
var _c = "client";
var _cI = "clientId";
var _cV = "codeVerifier";
var _co = "code";
var _e = "error";
var _eI = "expiresIn";
var _ei = "expires_in";
var _gT = "grantType";
var _gt = "grant_type";
var _h = "http";
var _hE = "httpError";
var _iT = "idToken";
var _jN = "jsonName";
var _m = "message";
var _r = "resource";
var _rT = "refreshToken";
var _rU = "redirectUri";
var _s = "smithy.ts.sdk.synthetic.com.amazonaws.signin";
var _sAK = "secretAccessKey";
var _sT = "sessionToken";
var _se = "server";
var _tI = "tokenInput";
var _tO = "tokenOutput";
var _tT = "tokenType";
var _tt = "token_type";
var n0 = "com.amazonaws.signin";
var _s_registry = TypeRegistry.for(_s);
var SigninServiceException$ = [-3, _s, "SigninServiceException", 0, [], []];
_s_registry.registerError(SigninServiceException$, SigninServiceException);
var n0_registry = TypeRegistry.for(n0);
var AccessDeniedException$ = [
-3,
n0,
_ADE,
{ [_e]: _c },
[_e, _m],
[0, 0],
2
];
n0_registry.registerError(AccessDeniedException$, AccessDeniedException);
var InternalServerException$ = [
-3,
n0,
_ISE,
{ [_e]: _se, [_hE]: 500 },
[_e, _m],
[0, 0],
2
];
n0_registry.registerError(InternalServerException$, InternalServerException);
var TooManyRequestsError$ = [
-3,
n0,
_TMRE,
{ [_e]: _c, [_hE]: 429 },
[_e, _m],
[0, 0],
2
];
n0_registry.registerError(TooManyRequestsError$, TooManyRequestsError);
var ValidationException$ = [
-3,
n0,
_VE,
{ [_e]: _c, [_hE]: 400 },
[_e, _m],
[0, 0],
2
];
n0_registry.registerError(ValidationException$, ValidationException);
var errorTypeRegistries = [
_s_registry,
n0_registry
];
var OAuthAccessToken = [0, n0, _OAAT, 8, 0];
var RefreshToken = [0, n0, _RT, 8, 0];
var AccessToken$ = [
3,
n0,
_AT,
8,
[_aKI, _sAK, _sT],
[[0, { [_jN]: _aKI }], [0, { [_jN]: _sAK }], [0, { [_jN]: _sT }]],
3
];
var CreateOAuth2TokenRequest$ = [
3,
n0,
_COATR,
0,
[_tI],
[[() => CreateOAuth2TokenRequestBody$, 16]],
1
];
var CreateOAuth2TokenRequestBody$ = [
3,
n0,
_COATRB,
0,
[_cI, _gT, _co, _rU, _cV, _rT],
[[0, { [_jN]: _cI }], [0, { [_jN]: _gT }], 0, [0, { [_jN]: _rU }], [0, { [_jN]: _cV }], [() => RefreshToken, { [_jN]: _rT }]],
2
];
var CreateOAuth2TokenResponse$ = [
3,
n0,
_COATRr,
0,
[_tO],
[[() => CreateOAuth2TokenResponseBody$, 16]],
1
];
var CreateOAuth2TokenResponseBody$ = [
3,
n0,
_COATRBr,
0,
[_aT, _tT, _eI, _rT, _iT],
[[() => AccessToken$, { [_jN]: _aT }], [0, { [_jN]: _tT }], [1, { [_jN]: _eI }], [() => RefreshToken, { [_jN]: _rT }], [0, { [_jN]: _iT }]],
4
];
var CreateOAuth2TokenWithIAMRequest$ = [
3,
n0,
_COATWIAMR,
0,
[_gT, _r],
[[0, { [_jN]: _gt }], 0],
2
];
var CreateOAuth2TokenWithIAMResponse$ = [
3,
n0,
_COATWIAMRr,
0,
[_aT, _tT, _eI],
[[() => OAuthAccessToken, { [_jN]: _at }], [0, { [_jN]: _tt }], [1, { [_jN]: _ei }]],
3
];
var CreateOAuth2Token$ = [
9,
n0,
_COAT,
{ [_h]: ["POST", "/v1/token", 200] },
() => CreateOAuth2TokenRequest$,
() => CreateOAuth2TokenResponse$
];
var CreateOAuth2TokenWithIAM$ = [
9,
n0,
_COATWIAM,
{ [_h]: ["POST", "/v1/token?x-amz-client-auth-method=iam", 200] },
() => CreateOAuth2TokenWithIAMRequest$,
() => CreateOAuth2TokenWithIAMResponse$
];
var getRuntimeConfig$1 = (config) => {
return {
apiVersion: "2023-01-01",
base64Decoder: config?.base64Decoder ?? fromBase64,
base64Encoder: config?.base64Encoder ?? toBase64,
disableHostPrefix: config?.disableHostPrefix ?? false,
endpointProvider: config?.endpointProvider ?? defaultEndpointResolver,
extensions: config?.extensions ?? [],
httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultSigninHttpAuthSchemeProvider,
httpAuthSchemes: config?.httpAuthSchemes ?? [
{
schemeId: "aws.auth#sigv4",
identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
signer: new AwsSdkSigV4Signer
},
{
schemeId: "smithy.api#noAuth",
identityProvider: (ipc) => ipc.getIdentityProvider("smithy.api#noAuth") || (async () => ({})),
signer: new NoAuthSigner
}
],
logger: config?.logger ?? new NoOpLogger,
protocol: config?.protocol ?? AwsRestJsonProtocol,
protocolSettings: config?.protocolSettings ?? {
defaultNamespace: "com.amazonaws.signin",
errorTypeRegistries,
version: "2023-01-01",
serviceTarget: "Signin"
},
serviceId: config?.serviceId ?? "Signin",
sha256: config?.sha256 ?? Sha256,
urlParser: config?.urlParser ?? parseUrl,
utf8Decoder: config?.utf8Decoder ?? fromUtf8,
utf8Encoder: config?.utf8Encoder ?? toUtf8
};
};
var getRuntimeConfig = (config) => {
emitWarningIfUnsupportedVersion(process.version);
const defaultsMode = resolveDefaultsModeConfig(config);
const defaultConfigProvider = () => defaultsMode().then(loadConfigsForDefaultMode);
const clientSharedValues = getRuntimeConfig$1(config);
emitWarningIfUnsupportedVersion$1(process.version);
const loaderConfig = {
profile: config?.profile,
logger: clientSharedValues.logger
};
return {
...clientSharedValues,
...config,
runtime: "node",
defaultsMode,
authSchemePreference: config?.authSchemePreference ?? loadConfig(NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
bodyLengthChecker: config?.bodyLengthChecker ?? calculateBodyLength,
defaultUserAgentProvider: config?.defaultUserAgentProvider ?? createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: packageInfo.version }),
maxAttempts: config?.maxAttempts ?? loadConfig(NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
region: config?.region ?? loadConfig(NODE_REGION_CONFIG_OPTIONS, { ...NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
requestHandler: NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
retryMode: config?.retryMode ?? loadConfig({
...NODE_RETRY_MODE_CONFIG_OPTIONS,
default: async () => (await defaultConfigProvider()).retryMode || DEFAULT_RETRY_MODE
}, config),
streamCollector: config?.streamCollector ?? streamCollector,
useDualstackEndpoint: config?.useDualstackEndpoint ?? loadConfig(NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
useFipsEndpoint: config?.useFipsEndpoint ?? loadConfig(NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
userAgentAppId: config?.userAgentAppId ?? loadConfig(NODE_APP_ID_CONFIG_OPTIONS, loaderConfig)
};
};
var getHttpAuthExtensionConfiguration = (runtimeConfig) => {
const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
let _credentials = runtimeConfig.credentials;
return {
setHttpAuthScheme(httpAuthScheme) {
const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
if (index === -1) {
_httpAuthSchemes.push(httpAuthScheme);
} else {
_httpAuthSchemes.splice(index, 1, httpAuthScheme);
}
},
httpAuthSchemes() {
return _httpAuthSchemes;
},
setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
_httpAuthSchemeProvider = httpAuthSchemeProvider;
},
httpAuthSchemeProvider() {
return _httpAuthSchemeProvider;
},
setCredentials(credentials) {
_credentials = credentials;
},
credentials() {
return _credentials;
}
};
};
var resolveHttpAuthRuntimeConfig = (config) => {
return {
httpAuthSchemes: config.httpAuthSchemes(),
httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
credentials: config.credentials()
};
};
var resolveRuntimeExtensions = (runtimeConfig, extensions) => {
const extensionConfiguration = Object.assign(getAwsRegionExtensionConfiguration(runtimeConfig), getDefaultExtensionConfiguration(runtimeConfig), getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration(runtimeConfig));
extensions.forEach((extension) => extension.configure(extensionConfiguration));
return Object.assign(runtimeConfig, resolveAwsRegionExtensionConfiguration(extensionConfiguration), resolveDefaultRuntimeConfig(extensionConfiguration), resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig(extensionConfiguration));
};
class SigninClient extends Client {
config;
constructor(...[configuration]) {
const _config_0 = getRuntimeConfig(configuration || {});
super(_config_0);
this.initConfig = _config_0;
const _config_1 = resolveClientEndpointParameters(_config_0);
const _config_2 = resolveUserAgentConfig(_config_1);
const _config_3 = resolveRetryConfig(_config_2);
const _config_4 = resolveRegionConfig(_config_3);
const _config_5 = resolveHostHeaderConfig(_config_4);
const _config_6 = resolveEndpointConfig(_config_5);
const _config_7 = resolveHttpAuthSchemeConfig(_config_6);
const _config_8 = resolveRuntimeExtensions(_config_7, configuration?.extensions || []);
this.config = _config_8;
this.middlewareStack.use(getSchemaSerdePlugin(this.config));
this.middlewareStack.use(getUserAgentPlugin(this.config));
this.middlewareStack.use(getRetryPlugin(this.config));
this.middlewareStack.use(getContentLengthPlugin(this.config));
this.middlewareStack.use(getHostHeaderPlugin(this.config));
this.middlewareStack.use(getLoggerPlugin(this.config));
this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
httpAuthSchemeParametersProvider: defaultSigninHttpAuthSchemeParametersProvider,
identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
"aws.auth#sigv4": config.credentials
})
}));
this.middlewareStack.use(getHttpSigningPlugin(this.config));
}
destroy() {
super.destroy();
}
}
var command = makeBuilder(commonParams, "Signin", "SigninClient", getEndpointPlugin);
var _ep0 = {
IsControlPlane: { type: "staticContextParams", value: false }
};
var _ep1 = {
IsOAuthEndpoint: { type: "staticContextParams", value: true }
};
var _mw0 = (Command, cs, config, o) => [];
class CreateOAuth2TokenCommand extends command(_ep0, _mw0, "CreateOAuth2Token", CreateOAuth2Token$) {
}
class CreateOAuth2TokenWithIAMCommand extends command(_ep1, _mw0, "CreateOAuth2TokenWithIAM", CreateOAuth2TokenWithIAM$) {
}
var commands = {
CreateOAuth2TokenCommand,
CreateOAuth2TokenWithIAMCommand
};
class Signin extends SigninClient {
}
createAggregatedClient(commands, Signin);
var OAuth2ErrorCode = {
AUTHCODE_EXPIRED: "AUTHCODE_EXPIRED",
CONFLICT: "CONFLICT",
INSUFFICIENT_PERMISSIONS: "INSUFFICIENT_PERMISSIONS",
INVALID_REQUEST: "INVALID_REQUEST",
RESOURCE_NOT_FOUND: "RESOURCE_NOT_FOUND",
SERVER_ERROR: "server_error",
SERVICE_QUOTA_EXCEEDED: "SERVICE_QUOTA_EXCEEDED",
TOKEN_EXPIRED: "TOKEN_EXPIRED",
USER_CREDENTIALS_CHANGED: "USER_CREDENTIALS_CHANGED"
};
exports.AccessDeniedException = AccessDeniedException;
exports.AccessDeniedException$ = AccessDeniedException$;
exports.AccessToken$ = AccessToken$;
exports.CreateOAuth2Token$ = CreateOAuth2Token$;
exports.CreateOAuth2TokenCommand = CreateOAuth2TokenCommand;
exports.CreateOAuth2TokenRequest$ = CreateOAuth2TokenRequest$;
exports.CreateOAuth2TokenRequestBody$ = CreateOAuth2TokenRequestBody$;
exports.CreateOAuth2TokenResponse$ = CreateOAuth2TokenResponse$;
exports.CreateOAuth2TokenResponseBody$ = CreateOAuth2TokenResponseBody$;
exports.CreateOAuth2TokenWithIAM$ = CreateOAuth2TokenWithIAM$;
exports.CreateOAuth2TokenWithIAMCommand = CreateOAuth2TokenWithIAMCommand;
exports.CreateOAuth2TokenWithIAMRequest$ = CreateOAuth2TokenWithIAMRequest$;
exports.CreateOAuth2TokenWithIAMResponse$ = CreateOAuth2TokenWithIAMResponse$;
exports.InternalServerException = InternalServerException;
exports.InternalServerException$ = InternalServerException$;
exports.OAuth2ErrorCode = OAuth2ErrorCode;
exports.Signin = Signin;
exports.SigninClient = SigninClient;
exports.SigninServiceException = SigninServiceException;
exports.SigninServiceException$ = SigninServiceException$;
exports.TooManyRequestsError = TooManyRequestsError;
exports.TooManyRequestsError$ = TooManyRequestsError$;
exports.ValidationException = ValidationException;
exports.ValidationException$ = ValidationException$;
exports.errorTypeRegistries = errorTypeRegistries;
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-login@3.972.77/node_modules/@aws-sdk/credential-provider-login/dist-es/LoginCredentialsFetcher.js
import { createHash, createPrivateKey, createPublicKey, sign } from "crypto";
import { promises as fs2 } from "fs";
import { homedir as homedir2 } from "os";
import { dirname as dirname3, join as join4 } from "path";
var import_config20, import_protocols3, LoginCredentialsFetcher;
var init_LoginCredentialsFetcher = __esm(() => {
import_config20 = __toESM(require_config());
import_protocols3 = __toESM(require_protocols());
LoginCredentialsFetcher = class LoginCredentialsFetcher {
profileData;
init;
callerClientConfig;
static REFRESH_THRESHOLD = 5 * 60 * 1000;
constructor(profileData, init, callerClientConfig) {
this.profileData = profileData;
this.init = init;
this.callerClientConfig = callerClientConfig;
}
async loadCredentials() {
const token = await this.loadToken();
if (!token) {
throw new import_config20.CredentialsProviderError(`Failed to load a token for session ${this.loginSession}, please re-authenticate using aws login`, { tryNextLink: false, logger: this.logger });
}
const accessToken = token.accessToken;
const now = Date.now();
const expiryTime = new Date(accessToken.expiresAt).getTime();
const timeUntilExpiry = expiryTime - now;
if (timeUntilExpiry <= LoginCredentialsFetcher.REFRESH_THRESHOLD) {
return this.refresh(token);
}
return this.toCredentials(token.accessToken);
}
get logger() {
return this.init?.logger;
}
get loginSession() {
return this.profileData.login_session;
}
toCredentials(token) {
return {
accessKeyId: token.accessKeyId,
secretAccessKey: token.secretAccessKey,
sessionToken: token.sessionToken,
accountId: token.accountId,
expiration: new Date(token.expiresAt)
};
}
async refresh(token) {
const diskToken = await this.loadToken().catch(() => token);
const now = Date.now();
const diskExpiry = new Date(diskToken.accessToken.expiresAt).getTime();
const tokenExpiry = new Date(token.accessToken.expiresAt).getTime();
const freshToken = diskExpiry <= now && tokenExpiry > now ? token : diskToken;
const freshExpiry = new Date(freshToken.accessToken.expiresAt).getTime();
if (freshExpiry - Date.now() > LoginCredentialsFetcher.REFRESH_THRESHOLD) {
return this.toCredentials(freshToken.accessToken);
}
const { SigninClient, CreateOAuth2TokenCommand } = await Promise.resolve().then(() => __toESM(require_signin()));
const { logger, userAgentAppId } = this.callerClientConfig ?? {};
const isH2 = (requestHandler) => {
return requestHandler?.metadata?.handlerProtocol === "h2";
};
const requestHandler = isH2(this.callerClientConfig?.requestHandler) ? undefined : this.callerClientConfig?.requestHandler;
const region = this.profileData.region ?? await this.callerClientConfig?.region?.() ?? process.env.AWS_REGION;
const client = new SigninClient({
credentials: {
accessKeyId: "",
secretAccessKey: ""
},
region,
requestHandler,
logger,
userAgentAppId,
...this.init?.clientConfig
});
this.createDPoPInterceptor(client.middlewareStack);
const commandInput = {
tokenInput: {
clientId: freshToken.clientId,
refreshToken: freshToken.refreshToken,
grantType: "refresh_token"
}
};
try {
const response = await client.send(new CreateOAuth2TokenCommand(commandInput));
const { accessKeyId, secretAccessKey, sessionToken } = response.tokenOutput?.accessToken ?? {};
const { refreshToken, expiresIn } = response.tokenOutput ?? {};
if (!accessKeyId || !secretAccessKey || !sessionToken || !refreshToken) {
throw new import_config20.CredentialsProviderError("Token refresh response missing required fields", {
logger: this.logger,
tryNextLink: false
});
}
const expiresInMs = (expiresIn ?? 900) * 1000;
const expiration = new Date(Date.now() + expiresInMs);
const updatedToken = {
...freshToken,
accessToken: {
...freshToken.accessToken,
accessKeyId,
secretAccessKey,
sessionToken,
expiresAt: expiration.toISOString()
},
refreshToken
};
await this.saveToken(updatedToken);
return this.toCredentials(updatedToken.accessToken);
} catch (error) {
if (error.name === "AccessDeniedException") {
const errorType = error.error;
let message;
switch (errorType) {
case "TOKEN_EXPIRED":
message = "Your session has expired. Please reauthenticate.";
break;
case "USER_CREDENTIALS_CHANGED":
message = "Unable to refresh credentials because of a change in your password. Please reauthenticate with your new password.";
break;
case "INSUFFICIENT_PERMISSIONS":
message = "Unable to refresh credentials due to insufficient permissions. You may be missing permission for the 'CreateOAuth2Token' action.";
break;
default:
message = `Failed to refresh token: ${String(error)}. Please re-authenticate using \`aws login\``;
}
throw new import_config20.CredentialsProviderError(message, {
logger: this.logger,
tryNextLink: false
});
}
const tokenExpiry = new Date(freshToken.accessToken.expiresAt).getTime();
if (tokenExpiry > Date.now()) {
this.logger?.warn?.(`Failed to refresh token: ${String(error)}. Using existing token until expiry.`);
return this.toCredentials(freshToken.accessToken);
}
throw new import_config20.CredentialsProviderError(`Failed to refresh token: ${String(error)}. Please re-authenticate using aws login`, { logger: this.logger });
}
}
async loadToken() {
const tokenFilePath = this.getTokenFilePath();
try {
const tokenData = await fs2.readFile(tokenFilePath, "utf8");
const token = JSON.parse(tokenData);
const missingFields = ["accessToken", "clientId", "refreshToken", "dpopKey"].filter((k) => !token[k]);
if (!token.accessToken?.accountId) {
missingFields.push("accountId");
}
if (missingFields.length > 0) {
throw new import_config20.CredentialsProviderError(`Token validation failed, missing fields: ${missingFields.join(", ")}`, {
logger: this.logger,
tryNextLink: false
});
}
return token;
} catch (error) {
throw new import_config20.CredentialsProviderError(`Failed to load token from ${tokenFilePath}: ${String(error)}`, {
logger: this.logger,
tryNextLink: false
});
}
}
async saveToken(token) {
const tokenFilePath = this.getTokenFilePath();
const directory = dirname3(tokenFilePath);
try {
await fs2.mkdir(directory, { recursive: true });
} catch (error) {}
await fs2.writeFile(tokenFilePath, JSON.stringify(token, null, 2), "utf8");
}
getTokenFilePath() {
const directory = process.env.AWS_LOGIN_CACHE_DIRECTORY ?? join4(homedir2(), ".aws", "login", "cache");
const loginSessionBytes = Buffer.from(this.loginSession, "utf8");
const loginSessionSha256 = createHash("sha256").update(loginSessionBytes).digest("hex");
return join4(directory, `${loginSessionSha256}.json`);
}
derToRawSignature(derSignature) {
let offset = 2;
if (derSignature[offset] !== 2) {
throw new Error("Invalid DER signature");
}
offset++;
const rLength = derSignature[offset++];
let r = derSignature.subarray(offset, offset + rLength);
offset += rLength;
if (derSignature[offset] !== 2) {
throw new Error("Invalid DER signature");
}
offset++;
const sLength = derSignature[offset++];
let s = derSignature.subarray(offset, offset + sLength);
r = r[0] === 0 ? r.subarray(1) : r;
s = s[0] === 0 ? s.subarray(1) : s;
const rPadded = Buffer.concat([Buffer.alloc(32 - r.length), r]);
const sPadded = Buffer.concat([Buffer.alloc(32 - s.length), s]);
return Buffer.concat([rPadded, sPadded]);
}
createDPoPInterceptor(middlewareStack) {
middlewareStack.add((next) => async (args) => {
if (import_protocols3.HttpRequest.isInstance(args.request)) {
const request = args.request;
const actualEndpoint = `${request.protocol}//${request.hostname}${request.port ? `:${request.port}` : ""}${request.path}`;
const dpop = await this.generateDpop(request.method, actualEndpoint);
request.headers = {
...request.headers,
DPoP: dpop
};
}
return next(args);
}, {
step: "finalizeRequest",
name: "dpopInterceptor",
override: true
});
}
async generateDpop(method = "POST", endpoint) {
const token = await this.loadToken();
try {
const privateKey = createPrivateKey({
key: token.dpopKey,
format: "pem",
type: "sec1"
});
const publicKey = createPublicKey(privateKey);
const publicDer = publicKey.export({ format: "der", type: "spki" });
let pointStart = -1;
for (let i = 0;i < publicDer.length; i++) {
if (publicDer[i] === 4) {
pointStart = i;
break;
}
}
const x = publicDer.slice(pointStart + 1, pointStart + 33);
const y = publicDer.slice(pointStart + 33, pointStart + 65);
const header = {
alg: "ES256",
typ: "dpop+jwt",
jwk: {
kty: "EC",
crv: "P-256",
x: x.toString("base64url"),
y: y.toString("base64url")
}
};
const payload = {
jti: crypto.randomUUID(),
htm: method,
htu: endpoint,
iat: Math.floor(Date.now() / 1000)
};
const headerB64 = Buffer.from(JSON.stringify(header)).toString("base64url");
const payloadB64 = Buffer.from(JSON.stringify(payload)).toString("base64url");
const message = `${headerB64}.${payloadB64}`;
const asn1Signature = sign("sha256", Buffer.from(message), privateKey);
const rawSignature = this.derToRawSignature(asn1Signature);
const signatureB64 = rawSignature.toString("base64url");
return `${message}.${signatureB64}`;
} catch (error) {
throw new import_config20.CredentialsProviderError(`Failed to generate Dpop proof: ${error instanceof Error ? error.message : String(error)}`, { logger: this.logger, tryNextLink: false });
}
}
};
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-login@3.972.77/node_modules/@aws-sdk/credential-provider-login/dist-es/fromLoginCredentials.js
var import_client9, import_config21, fromLoginCredentials = (init) => async ({ callerClientConfig } = {}) => {
init?.logger?.debug?.("@aws-sdk/credential-providers - fromLoginCredentials");
const profiles = await import_config21.parseKnownFiles(init || {});
const profileName = import_config21.getProfileName({
profile: init?.profile ?? callerClientConfig?.profile
});
const profile = profiles[profileName];
if (!profile?.login_session) {
throw new import_config21.CredentialsProviderError(`Profile ${profileName} does not contain login_session.`, {
tryNextLink: true,
logger: init?.logger
});
}
const fetcher = new LoginCredentialsFetcher(profile, init, callerClientConfig);
const credentials = await fetcher.loadCredentials();
return import_client9.setCredentialFeature(credentials, "CREDENTIALS_LOGIN", "AD");
};
var init_fromLoginCredentials = __esm(() => {
init_LoginCredentialsFetcher();
import_client9 = __toESM(require_client2());
import_config21 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-login@3.972.77/node_modules/@aws-sdk/credential-provider-login/dist-es/index.js
var init_dist_es6 = __esm(() => {
init_fromLoginCredentials();
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.973.15/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveLoginCredentials.js
var import_client10, isLoginProfile = (data) => {
return Boolean(data && data.login_session);
}, resolveLoginCredentials = async (profileName, options, callerClientConfig) => {
await Promise.resolve().then(() => init_dist_es6());
const credentials = await fromLoginCredentials({
...options,
profile: profileName
})({ callerClientConfig });
return import_client10.setCredentialFeature(credentials, "CREDENTIALS_PROFILE_LOGIN", "AC");
};
var init_resolveLoginCredentials = __esm(() => {
import_client10 = __toESM(require_client2());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-process@3.972.70/node_modules/@aws-sdk/credential-provider-process/dist-es/getValidatedProcessCredentials.js
var import_client11, getValidatedProcessCredentials = (profileName, data, profiles) => {
if (data.Version !== 1) {
throw Error(`Profile ${profileName} credential_process did not return Version 1.`);
}
if (data.AccessKeyId === undefined || data.SecretAccessKey === undefined) {
throw Error(`Profile ${profileName} credential_process returned invalid credentials.`);
}
if (data.Expiration) {
const currentTime = new Date;
const expireTime = new Date(data.Expiration);
if (expireTime < currentTime) {
throw Error(`Profile ${profileName} credential_process returned expired credentials.`);
}
}
let accountId = data.AccountId;
if (!accountId && profiles?.[profileName]?.aws_account_id) {
accountId = profiles[profileName].aws_account_id;
}
const credentials = {
accessKeyId: data.AccessKeyId,
secretAccessKey: data.SecretAccessKey,
...data.SessionToken && { sessionToken: data.SessionToken },
...data.Expiration && { expiration: new Date(data.Expiration) },
...data.CredentialScope && { credentialScope: data.CredentialScope },
...accountId && { accountId }
};
import_client11.setCredentialFeature(credentials, "CREDENTIALS_PROCESS", "w");
return credentials;
};
var init_getValidatedProcessCredentials = __esm(() => {
import_client11 = __toESM(require_client2());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-process@3.972.70/node_modules/@aws-sdk/credential-provider-process/dist-es/resolveProcessCredentials.js
import { exec } from "child_process";
import { promisify } from "util";
var import_config22, resolveProcessCredentials = async (profileName, profiles, logger) => {
const profile = profiles[profileName];
if (profiles[profileName]) {
const credentialProcess = profile["credential_process"];
if (credentialProcess !== undefined) {
const execPromise = promisify(import_config22.externalDataInterceptor?.getTokenRecord?.().exec ?? exec);
try {
const { stdout } = await execPromise(credentialProcess);
let data;
try {
data = JSON.parse(stdout.trim());
} catch {
throw Error(`Profile ${profileName} credential_process returned invalid JSON.`);
}
return getValidatedProcessCredentials(profileName, data, profiles);
} catch (error) {
throw new import_config22.CredentialsProviderError(error.message, { logger });
}
} else {
throw new import_config22.CredentialsProviderError(`Profile ${profileName} did not contain credential_process.`, { logger });
}
} else {
throw new import_config22.CredentialsProviderError(`Profile ${profileName} could not be found in shared credentials file.`, {
logger
});
}
};
var init_resolveProcessCredentials = __esm(() => {
init_getValidatedProcessCredentials();
import_config22 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-process@3.972.70/node_modules/@aws-sdk/credential-provider-process/dist-es/fromProcess.js
var import_config23, fromProcess = (init = {}) => async ({ callerClientConfig } = {}) => {
init.logger?.debug("@aws-sdk/credential-provider-process - fromProcess");
const profiles = await import_config23.parseKnownFiles(init);
return resolveProcessCredentials(import_config23.getProfileName({
profile: init.profile ?? callerClientConfig?.profile
}), profiles, init.logger);
};
var init_fromProcess = __esm(() => {
init_resolveProcessCredentials();
import_config23 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-process@3.972.70/node_modules/@aws-sdk/credential-provider-process/dist-es/index.js
var init_dist_es7 = __esm(() => {
init_fromProcess();
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.973.15/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveProcessCredentials.js
var import_client12, isProcessProfile = (arg) => Boolean(arg) && typeof arg === "object" && typeof arg.credential_process === "string", resolveProcessCredentials2 = async (options, profile) => {
await Promise.resolve().then(() => init_dist_es7());
const credentials = await fromProcess({
...options,
profile
})();
return import_client12.setCredentialFeature(credentials, "CREDENTIALS_PROFILE_PROCESS", "v");
};
var init_resolveProcessCredentials2 = __esm(() => {
import_client12 = __toESM(require_client2());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.973.15/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveSsoCredentials.js
var import_client13, resolveSsoCredentials = async (profile, profileData, options = {}, callerClientConfig) => {
await Promise.resolve().then(() => init_dist_es5());
return fromSSO({
profile,
logger: options.logger,
parentClientConfig: options.parentClientConfig,
clientConfig: options.clientConfig
})({
callerClientConfig
}).then((creds) => {
if (profileData.sso_session) {
return import_client13.setCredentialFeature(creds, "CREDENTIALS_PROFILE_SSO", "r");
} else {
return import_client13.setCredentialFeature(creds, "CREDENTIALS_PROFILE_SSO_LEGACY", "t");
}
});
}, isSsoProfile3 = (arg) => arg && (typeof arg.sso_start_url === "string" || typeof arg.sso_account_id === "string" || typeof arg.sso_session === "string" || typeof arg.sso_region === "string" || typeof arg.sso_role_name === "string");
var init_resolveSsoCredentials = __esm(() => {
import_client13 = __toESM(require_client2());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.973.15/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveStaticCredentials.js
var import_client14, isStaticCredsProfile = (arg) => Boolean(arg) && typeof arg === "object" && typeof arg.aws_access_key_id === "string" && typeof arg.aws_secret_access_key === "string" && ["undefined", "string"].indexOf(typeof arg.aws_session_token) > -1 && ["undefined", "string"].indexOf(typeof arg.aws_account_id) > -1, resolveStaticCredentials = async (profile, options) => {
options?.logger?.debug("@aws-sdk/credential-provider-ini - resolveStaticCredentials");
const credentials = {
accessKeyId: profile.aws_access_key_id,
secretAccessKey: profile.aws_secret_access_key,
sessionToken: profile.aws_session_token,
...profile.aws_credential_scope && { credentialScope: profile.aws_credential_scope },
...profile.aws_account_id && { accountId: profile.aws_account_id }
};
return import_client14.setCredentialFeature(credentials, "CREDENTIALS_PROFILE", "n");
};
var init_resolveStaticCredentials = __esm(() => {
import_client14 = __toESM(require_client2());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-web-identity@3.972.76/node_modules/@aws-sdk/credential-provider-web-identity/dist-es/fromWebToken.js
var fromWebToken = (init) => async (awsIdentityProperties) => {
init.logger?.debug("@aws-sdk/credential-provider-web-identity - fromWebToken");
const { roleArn, roleSessionName, webIdentityToken, providerId, policyArns, policy, durationSeconds } = init;
let { roleAssumerWithWebIdentity } = init;
if (!roleAssumerWithWebIdentity) {
const { getDefaultRoleAssumerWithWebIdentity } = await Promise.resolve().then(() => __toESM(require_sts()));
roleAssumerWithWebIdentity = getDefaultRoleAssumerWithWebIdentity({
...init.clientConfig,
credentialProviderLogger: init.logger,
parentClientConfig: {
...awsIdentityProperties?.callerClientConfig,
...init.parentClientConfig
}
}, init.clientPlugins);
}
return roleAssumerWithWebIdentity({
RoleArn: roleArn,
RoleSessionName: roleSessionName ?? `aws-sdk-js-session-${Date.now()}`,
WebIdentityToken: webIdentityToken,
ProviderId: providerId,
PolicyArns: policyArns,
Policy: policy,
DurationSeconds: durationSeconds
});
};
// ../../node_modules/.bun/@aws-sdk+credential-provider-web-identity@3.972.76/node_modules/@aws-sdk/credential-provider-web-identity/dist-es/fromTokenFile.js
import { readFileSync as readFileSync4 } from "fs";
var import_client15, import_config24, ENV_TOKEN_FILE = "AWS_WEB_IDENTITY_TOKEN_FILE", ENV_ROLE_ARN = "AWS_ROLE_ARN", ENV_ROLE_SESSION_NAME = "AWS_ROLE_SESSION_NAME", fromTokenFile = (init = {}) => async (awsIdentityProperties) => {
init.logger?.debug("@aws-sdk/credential-provider-web-identity - fromTokenFile");
const webIdentityTokenFile = init?.webIdentityTokenFile ?? process.env[ENV_TOKEN_FILE];
const roleArn = init?.roleArn ?? process.env[ENV_ROLE_ARN];
const roleSessionName = init?.roleSessionName ?? process.env[ENV_ROLE_SESSION_NAME];
if (!webIdentityTokenFile || !roleArn) {
throw new import_config24.CredentialsProviderError("Web identity configuration not specified", {
logger: init.logger
});
}
const credentials = await fromWebToken({
...init,
webIdentityToken: import_config24.externalDataInterceptor?.getTokenRecord?.()[webIdentityTokenFile] ?? readFileSync4(webIdentityTokenFile, { encoding: "ascii" }),
roleArn,
roleSessionName
})(awsIdentityProperties);
if (webIdentityTokenFile === process.env[ENV_TOKEN_FILE]) {
import_client15.setCredentialFeature(credentials, "CREDENTIALS_ENV_VARS_STS_WEB_ID_TOKEN", "h");
}
return credentials;
};
var init_fromTokenFile = __esm(() => {
import_client15 = __toESM(require_client2());
import_config24 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-web-identity@3.972.76/node_modules/@aws-sdk/credential-provider-web-identity/dist-es/index.js
var init_dist_es8 = __esm(() => {
init_fromTokenFile();
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.973.15/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveWebIdentityCredentials.js
var import_client16, isWebIdentityProfile = (arg) => Boolean(arg) && typeof arg === "object" && typeof arg.web_identity_token_file === "string" && typeof arg.role_arn === "string" && ["undefined", "string"].indexOf(typeof arg.role_session_name) > -1, resolveWebIdentityCredentials = async (profile, options, callerClientConfig) => {
await Promise.resolve().then(() => init_dist_es8());
const credentials = await fromTokenFile({
webIdentityTokenFile: profile.web_identity_token_file,
roleArn: profile.role_arn,
roleSessionName: profile.role_session_name,
roleAssumerWithWebIdentity: options.roleAssumerWithWebIdentity,
logger: options.logger,
parentClientConfig: options.parentClientConfig
})({
callerClientConfig
});
return import_client16.setCredentialFeature(credentials, "CREDENTIALS_PROFILE_STS_WEB_ID_TOKEN", "q");
};
var init_resolveWebIdentityCredentials = __esm(() => {
import_client16 = __toESM(require_client2());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.973.15/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveProfileData.js
var import_config25, resolveProfileData = async (profileName, profiles, options, callerClientConfig, visitedProfiles = {}, isAssumeRoleRecursiveCall = false) => {
const data = profiles[profileName];
if (Object.keys(visitedProfiles).length > 0 && isStaticCredsProfile(data)) {
return resolveStaticCredentials(data, options);
}
if (isAssumeRoleRecursiveCall || isAssumeRoleProfile(data, { profile: profileName, logger: options.logger })) {
return resolveAssumeRoleCredentials(profileName, profiles, options, callerClientConfig, visitedProfiles, resolveProfileData);
}
if (isStaticCredsProfile(data)) {
return resolveStaticCredentials(data, options);
}
if (isWebIdentityProfile(data)) {
return resolveWebIdentityCredentials(data, options, callerClientConfig);
}
if (isProcessProfile(data)) {
return resolveProcessCredentials2(options, profileName);
}
if (isSsoProfile3(data)) {
return await resolveSsoCredentials(profileName, data, options, callerClientConfig);
}
if (isLoginProfile(data)) {
return resolveLoginCredentials(profileName, options, callerClientConfig);
}
throw new import_config25.CredentialsProviderError(`Could not resolve credentials using profile: [${profileName}] in configuration/credentials file(s).`, { logger: options.logger });
};
var init_resolveProfileData = __esm(() => {
init_resolveAssumeRoleCredentials();
init_resolveLoginCredentials();
init_resolveProcessCredentials2();
init_resolveSsoCredentials();
init_resolveStaticCredentials();
init_resolveWebIdentityCredentials();
import_config25 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.973.15/node_modules/@aws-sdk/credential-provider-ini/dist-es/fromIni.js
var import_config26, fromIni = (init = {}) => async ({ callerClientConfig } = {}) => {
init.logger?.debug("@aws-sdk/credential-provider-ini - fromIni");
const profiles = await import_config26.parseKnownFiles(init);
return resolveProfileData(import_config26.getProfileName({
profile: init.profile ?? callerClientConfig?.profile
}), profiles, init, callerClientConfig);
};
var init_fromIni = __esm(() => {
init_resolveProfileData();
import_config26 = __toESM(require_config());
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.973.15/node_modules/@aws-sdk/credential-provider-ini/dist-es/index.js
var init_dist_es9 = __esm(() => {
init_fromIni();
});
// src/mcp/harness.ts
import { WebStandardStreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js";
function invalidPortMessage(source, value) {
return `Invalid ${source} "${value}". Expected an integer between ${PORT_MIN} and ${PORT_MAX}.`;
}
function validatePort(port, source) {
if (!Number.isInteger(port) || port < PORT_MIN || port > PORT_MAX) {
throw new Error(invalidPortMessage(source, String(port)));
}
return port;
}
function parsePortValue(value, source) {
const trimmed = value.trim();
if (!/^\d+$/.test(trimmed)) {
throw new Error(invalidPortMessage(source, value));
}
return validatePort(Number(trimmed), source);
}
function isStdioMode(argv = process.argv, env = process.env) {
return argv.includes("--stdio") || env.MCP_STDIO === "1";
}
function isHttpMode(argv = process.argv, env = process.env) {
return argv.includes("--http") || env.MCP_HTTP === "1";
}
function parseHttpArgv(argv = process.argv) {
const http = isHttpMode(argv);
let port;
const portEqualsArg = argv.find((arg) => arg.startsWith("--port="));
if (portEqualsArg) {
port = parsePortValue(portEqualsArg.slice("--port=".length), "--port");
}
const portIdx = argv.indexOf("--port");
if (portIdx !== -1) {
const value = argv[portIdx + 1];
if (value === undefined) {
throw new Error(invalidPortMessage("--port", ""));
}
port = parsePortValue(value, "--port");
}
return { http, port };
}
function resolveMcpHttpPort(opts) {
const argv = opts?.argv ?? process.argv;
const env = opts?.env ?? process.env;
if (opts?.explicit != null) {
return validatePort(opts.explicit, "--port");
}
const { port } = parseHttpArgv(argv);
if (port != null)
return port;
const envPort = env.MCP_HTTP_PORT;
if (envPort && envPort.trim() !== "") {
return parsePortValue(envPort, "MCP_HTTP_PORT");
}
return opts?.default ?? DEFAULT_MCP_HTTP_PORT;
}
function healthPayload(name) {
return { status: "ok", name };
}
async function handleMcpHttpRequest(req, buildServer, options) {
try {
const server = await buildServer();
const transport = new WebStandardStreamableHTTPServerTransport({
sessionIdGenerator: undefined,
enableJsonResponse: options?.enableJsonResponse
});
await server.connect(transport);
return await transport.handleRequest(req);
} catch (error) {
console.error("[mcp] HTTP error:", error);
return Response.json({ jsonrpc: "2.0", error: { code: -32603, message: "Internal server error" }, id: null }, { status: 500 });
}
}
function startBunHttpServer(buildServer, options) {
const host = options.host ?? "127.0.0.1";
const serviceName = options.serviceName;
const enableJsonResponse = options.enableJsonResponse;
const server = Bun.serve({
hostname: host,
port: options.port,
async fetch(req) {
const url = new URL(req.url);
if (url.pathname === "/health" && req.method === "GET") {
return Response.json(healthPayload(serviceName));
}
if (url.pathname === "/mcp") {
return handleMcpHttpRequest(req, buildServer, { enableJsonResponse });
}
return new Response("Not Found", { status: 404 });
}
});
process.stderr.write(`${serviceName} MCP HTTP listening on http://${host}:${server.port}/mcp
`);
return { port: server.port ?? options.port, stop: () => server.stop(true) };
}
var PORT_MIN = 0, PORT_MAX = 65535, DEFAULT_MCP_HTTP_PORT = 8899;
var init_harness = () => {};
// src/mcp/http.ts
function isStdioMode2(argv = process.argv) {
return isStdioMode(argv);
}
function resolveMcpHttpPort2(argv = process.argv, env = process.env) {
return resolveMcpHttpPort({ argv, env, default: DEFAULT_MCP_HTTP_PORT2 });
}
async function startHttpServer(buildServer, port) {
return startBunHttpServer(buildServer, {
port,
host: MCP_HTTP_HOST,
serviceName: MCP_SERVER_NAME
});
}
var MCP_HTTP_HOST = "127.0.0.1", MCP_SERVER_NAME = "domains", DEFAULT_MCP_HTTP_PORT2 = 8859;
var init_http = __esm(() => {
init_harness();
});
// src/mcp/index.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/helpers/util.js
var util;
(function(util) {
util.assertEqual = (_) => {};
function assertIs(_arg) {}
util.assertIs = assertIs;
function assertNever(_x) {
throw new Error;
}
util.assertNever = assertNever;
util.arrayToEnum = (items) => {
const obj = {};
for (const item of items) {
obj[item] = item;
}
return obj;
};
util.getValidEnumValues = (obj) => {
const validKeys = util.objectKeys(obj).filter((k) => typeof obj[obj[k]] !== "number");
const filtered = {};
for (const k of validKeys) {
filtered[k] = obj[k];
}
return util.objectValues(filtered);
};
util.objectValues = (obj) => {
return util.objectKeys(obj).map(function(e) {
return obj[e];
});
};
util.objectKeys = typeof Object.keys === "function" ? (obj) => Object.keys(obj) : (object) => {
const keys = [];
for (const key in object) {
if (Object.prototype.hasOwnProperty.call(object, key)) {
keys.push(key);
}
}
return keys;
};
util.find = (arr, checker) => {
for (const item of arr) {
if (checker(item))
return item;
}
return;
};
util.isInteger = typeof Number.isInteger === "function" ? (val) => Number.isInteger(val) : (val) => typeof val === "number" && Number.isFinite(val) && Math.floor(val) === val;
function joinValues(array, separator = " | ") {
return array.map((val) => typeof val === "string" ? `'${val}'` : val).join(separator);
}
util.joinValues = joinValues;
util.jsonStringifyReplacer = (_, value) => {
if (typeof value === "bigint") {
return value.toString();
}
return value;
};
})(util || (util = {}));
var objectUtil;
(function(objectUtil) {
objectUtil.mergeShapes = (first, second) => {
return {
...first,
...second
};
};
})(objectUtil || (objectUtil = {}));
var ZodParsedType = util.arrayToEnum([
"string",
"nan",
"number",
"integer",
"float",
"boolean",
"date",
"bigint",
"symbol",
"function",
"undefined",
"null",
"array",
"object",
"unknown",
"promise",
"void",
"never",
"map",
"set"
]);
var getParsedType = (data) => {
const t = typeof data;
switch (t) {
case "undefined":
return ZodParsedType.undefined;
case "string":
return ZodParsedType.string;
case "number":
return Number.isNaN(data) ? ZodParsedType.nan : ZodParsedType.number;
case "boolean":
return ZodParsedType.boolean;
case "function":
return ZodParsedType.function;
case "bigint":
return ZodParsedType.bigint;
case "symbol":
return ZodParsedType.symbol;
case "object":
if (Array.isArray(data)) {
return ZodParsedType.array;
}
if (data === null) {
return ZodParsedType.null;
}
if (data.then && typeof data.then === "function" && data.catch && typeof data.catch === "function") {
return ZodParsedType.promise;
}
if (typeof Map !== "undefined" && data instanceof Map) {
return ZodParsedType.map;
}
if (typeof Set !== "undefined" && data instanceof Set) {
return ZodParsedType.set;
}
if (typeof Date !== "undefined" && data instanceof Date) {
return ZodParsedType.date;
}
return ZodParsedType.object;
default:
return ZodParsedType.unknown;
}
};
// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/ZodError.js
var ZodIssueCode = util.arrayToEnum([
"invalid_type",
"invalid_literal",
"custom",
"invalid_union",
"invalid_union_discriminator",
"invalid_enum_value",
"unrecognized_keys",
"invalid_arguments",
"invalid_return_type",
"invalid_date",
"invalid_string",
"too_small",
"too_big",
"invalid_intersection_types",
"not_multiple_of",
"not_finite"
]);
class ZodError extends Error {
get errors() {
return this.issues;
}
constructor(issues) {
super();
this.issues = [];
this.addIssue = (sub) => {
this.issues = [...this.issues, sub];
};
this.addIssues = (subs = []) => {
this.issues = [...this.issues, ...subs];
};
const actualProto = new.target.prototype;
if (Object.setPrototypeOf) {
Object.setPrototypeOf(this, actualProto);
} else {
this.__proto__ = actualProto;
}
this.name = "ZodError";
this.issues = issues;
}
format(_mapper) {
const mapper = _mapper || function(issue) {
return issue.message;
};
const fieldErrors = { _errors: [] };
const processError = (error) => {
for (const issue of error.issues) {
if (issue.code === "invalid_union") {
issue.unionErrors.map(processError);
} else if (issue.code === "invalid_return_type") {
processError(issue.returnTypeError);
} else if (issue.code === "invalid_arguments") {
processError(issue.argumentsError);
} else if (issue.path.length === 0) {
fieldErrors._errors.push(mapper(issue));
} else {
let curr = fieldErrors;
let i = 0;
while (i < issue.path.length) {
const el = issue.path[i];
const terminal = i === issue.path.length - 1;
if (!terminal) {
curr[el] = curr[el] || { _errors: [] };
} else {
curr[el] = curr[el] || { _errors: [] };
curr[el]._errors.push(mapper(issue));
}
curr = curr[el];
i++;
}
}
}
};
processError(this);
return fieldErrors;
}
static assert(value) {
if (!(value instanceof ZodError)) {
throw new Error(`Not a ZodError: ${value}`);
}
}
toString() {
return this.message;
}
get message() {
return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);
}
get isEmpty() {
return this.issues.length === 0;
}
flatten(mapper = (issue) => issue.message) {
const fieldErrors = {};
const formErrors = [];
for (const sub of this.issues) {
if (sub.path.length > 0) {
const firstEl = sub.path[0];
fieldErrors[firstEl] = fieldErrors[firstEl] || [];
fieldErrors[firstEl].push(mapper(sub));
} else {
formErrors.push(mapper(sub));
}
}
return { formErrors, fieldErrors };
}
get formErrors() {
return this.flatten();
}
}
ZodError.create = (issues) => {
const error = new ZodError(issues);
return error;
};
// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/locales/en.js
var errorMap = (issue, _ctx) => {
let message;
switch (issue.code) {
case ZodIssueCode.invalid_type:
if (issue.received === ZodParsedType.undefined) {
message = "Required";
} else {
message = `Expected ${issue.expected}, received ${issue.received}`;
}
break;
case ZodIssueCode.invalid_literal:
message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`;
break;
case ZodIssueCode.unrecognized_keys:
message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
break;
case ZodIssueCode.invalid_union:
message = `Invalid input`;
break;
case ZodIssueCode.invalid_union_discriminator:
message = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`;
break;
case ZodIssueCode.invalid_enum_value:
message = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`;
break;
case ZodIssueCode.invalid_arguments:
message = `Invalid function arguments`;
break;
case ZodIssueCode.invalid_return_type:
message = `Invalid function return type`;
break;
case ZodIssueCode.invalid_date:
message = `Invalid date`;
break;
case ZodIssueCode.invalid_string:
if (typeof issue.validation === "object") {
if ("includes" in issue.validation) {
message = `Invalid input: must include "${issue.validation.includes}"`;
if (typeof issue.validation.position === "number") {
message = `${message} at one or more positions greater than or equal to ${issue.validation.position}`;
}
} else if ("startsWith" in issue.validation) {
message = `Invalid input: must start with "${issue.validation.startsWith}"`;
} else if ("endsWith" in issue.validation) {
message = `Invalid input: must end with "${issue.validation.endsWith}"`;
} else {
util.assertNever(issue.validation);
}
} else if (issue.validation !== "regex") {
message = `Invalid ${issue.validation}`;
} else {
message = "Invalid";
}
break;
case ZodIssueCode.too_small:
if (issue.type === "array")
message = `Array must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `more than`} ${issue.minimum} element(s)`;
else if (issue.type === "string")
message = `String must contain ${issue.exact ? "exactly" : issue.inclusive ? `at least` : `over`} ${issue.minimum} character(s)`;
else if (issue.type === "number")
message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
else if (issue.type === "bigint")
message = `Number must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${issue.minimum}`;
else if (issue.type === "date")
message = `Date must be ${issue.exact ? `exactly equal to ` : issue.inclusive ? `greater than or equal to ` : `greater than `}${new Date(Number(issue.minimum))}`;
else
message = "Invalid input";
break;
case ZodIssueCode.too_big:
if (issue.type === "array")
message = `Array must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `less than`} ${issue.maximum} element(s)`;
else if (issue.type === "string")
message = `String must contain ${issue.exact ? `exactly` : issue.inclusive ? `at most` : `under`} ${issue.maximum} character(s)`;
else if (issue.type === "number")
message = `Number must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
else if (issue.type === "bigint")
message = `BigInt must be ${issue.exact ? `exactly` : issue.inclusive ? `less than or equal to` : `less than`} ${issue.maximum}`;
else if (issue.type === "date")
message = `Date must be ${issue.exact ? `exactly` : issue.inclusive ? `smaller than or equal to` : `smaller than`} ${new Date(Number(issue.maximum))}`;
else
message = "Invalid input";
break;
case ZodIssueCode.custom:
message = `Invalid input`;
break;
case ZodIssueCode.invalid_intersection_types:
message = `Intersection results could not be merged`;
break;
case ZodIssueCode.not_multiple_of:
message = `Number must be a multiple of ${issue.multipleOf}`;
break;
case ZodIssueCode.not_finite:
message = "Number must be finite";
break;
default:
message = _ctx.defaultError;
util.assertNever(issue);
}
return { message };
};
var en_default = errorMap;
// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/errors.js
var overrideErrorMap = en_default;
function getErrorMap() {
return overrideErrorMap;
}
// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
var makeIssue = (params) => {
const { data, path, errorMaps, issueData } = params;
const fullPath = [...path, ...issueData.path || []];
const fullIssue = {
...issueData,
path: fullPath
};
if (issueData.message !== undefined) {
return {
...issueData,
path: fullPath,
message: issueData.message
};
}
let errorMessage = "";
const maps = errorMaps.filter((m) => !!m).slice().reverse();
for (const map of maps) {
errorMessage = map(fullIssue, { data, defaultError: errorMessage }).message;
}
return {
...issueData,
path: fullPath,
message: errorMessage
};
};
function addIssueToContext(ctx, issueData) {
const overrideMap = getErrorMap();
const issue = makeIssue({
issueData,
data: ctx.data,
path: ctx.path,
errorMaps: [
ctx.common.contextualErrorMap,
ctx.schemaErrorMap,
overrideMap,
overrideMap === en_default ? undefined : en_default
].filter((x) => !!x)
});
ctx.common.issues.push(issue);
}
class ParseStatus {
constructor() {
this.value = "valid";
}
dirty() {
if (this.value === "valid")
this.value = "dirty";
}
abort() {
if (this.value !== "aborted")
this.value = "aborted";
}
static mergeArray(status, results) {
const arrayValue = [];
for (const s of results) {
if (s.status === "aborted")
return INVALID;
if (s.status === "dirty")
status.dirty();
arrayValue.push(s.value);
}
return { status: status.value, value: arrayValue };
}
static async mergeObjectAsync(status, pairs) {
const syncPairs = [];
for (const pair of pairs) {
const key = await pair.key;
const value = await pair.value;
syncPairs.push({
key,
value
});
}
return ParseStatus.mergeObjectSync(status, syncPairs);
}
static mergeObjectSync(status, pairs) {
const finalObject = {};
for (const pair of pairs) {
const { key, value } = pair;
if (key.status === "aborted")
return INVALID;
if (value.status === "aborted")
return INVALID;
if (key.status === "dirty")
status.dirty();
if (value.status === "dirty")
status.dirty();
if (key.value !== "__proto__" && (typeof value.value !== "undefined" || pair.alwaysSet)) {
finalObject[key.value] = value.value;
}
}
return { status: status.value, value: finalObject };
}
}
var INVALID = Object.freeze({
status: "aborted"
});
var DIRTY = (value) => ({ status: "dirty", value });
var OK = (value) => ({ status: "valid", value });
var isAborted = (x) => x.status === "aborted";
var isDirty = (x) => x.status === "dirty";
var isValid = (x) => x.status === "valid";
var isAsync = (x) => typeof Promise !== "undefined" && x instanceof Promise;
// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/helpers/errorUtil.js
var errorUtil;
(function(errorUtil) {
errorUtil.errToObj = (message) => typeof message === "string" ? { message } : message || {};
errorUtil.toString = (message) => typeof message === "string" ? message : message?.message;
})(errorUtil || (errorUtil = {}));
// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/types.js
class ParseInputLazyPath {
constructor(parent, value, path, key) {
this._cachedPath = [];
this.parent = parent;
this.data = value;
this._path = path;
this._key = key;
}
get path() {
if (!this._cachedPath.length) {
if (Array.isArray(this._key)) {
this._cachedPath.push(...this._path, ...this._key);
} else {
this._cachedPath.push(...this._path, this._key);
}
}
return this._cachedPath;
}
}
var handleResult = (ctx, result) => {
if (isValid(result)) {
return { success: true, data: result.value };
} else {
if (!ctx.common.issues.length) {
throw new Error("Validation failed but no issues detected.");
}
return {
success: false,
get error() {
if (this._error)
return this._error;
const error = new ZodError(ctx.common.issues);
this._error = error;
return this._error;
}
};
}
};
function processCreateParams(params) {
if (!params)
return {};
const { errorMap, invalid_type_error, required_error, description } = params;
if (errorMap && (invalid_type_error || required_error)) {
throw new Error(`Can't use "invalid_type_error" or "required_error" in conjunction with custom error map.`);
}
if (errorMap)
return { errorMap, description };
const customMap = (iss, ctx) => {
const { message } = params;
if (iss.code === "invalid_enum_value") {
return { message: message ?? ctx.defaultError };
}
if (typeof ctx.data === "undefined") {
return { message: message ?? required_error ?? ctx.defaultError };
}
if (iss.code !== "invalid_type")
return { message: ctx.defaultError };
return { message: message ?? invalid_type_error ?? ctx.defaultError };
};
return { errorMap: customMap, description };
}
class ZodType {
get description() {
return this._def.description;
}
_getType(input) {
return getParsedType(input.data);
}
_getOrReturnCtx(input, ctx) {
return ctx || {
common: input.parent.common,
data: input.data,
parsedType: getParsedType(input.data),
schemaErrorMap: this._def.errorMap,
path: input.path,
parent: input.parent
};
}
_processInputParams(input) {
return {
status: new ParseStatus,
ctx: {
common: input.parent.common,
data: input.data,
parsedType: getParsedType(input.data),
schemaErrorMap: this._def.errorMap,
path: input.path,
parent: input.parent
}
};
}
_parseSync(input) {
const result = this._parse(input);
if (isAsync(result)) {
throw new Error("Synchronous parse encountered promise.");
}
return result;
}
_parseAsync(input) {
const result = this._parse(input);
return Promise.resolve(result);
}
parse(data, params) {
const result = this.safeParse(data, params);
if (result.success)
return result.data;
throw result.error;
}
safeParse(data, params) {
const ctx = {
common: {
issues: [],
async: params?.async ?? false,
contextualErrorMap: params?.errorMap
},
path: params?.path || [],
schemaErrorMap: this._def.errorMap,
parent: null,
data,
parsedType: getParsedType(data)
};
const result = this._parseSync({ data, path: ctx.path, parent: ctx });
return handleResult(ctx, result);
}
"~validate"(data) {
const ctx = {
common: {
issues: [],
async: !!this["~standard"].async
},
path: [],
schemaErrorMap: this._def.errorMap,
parent: null,
data,
parsedType: getParsedType(data)
};
if (!this["~standard"].async) {
try {
const result = this._parseSync({ data, path: [], parent: ctx });
return isValid(result) ? {
value: result.value
} : {
issues: ctx.common.issues
};
} catch (err) {
if (err?.message?.toLowerCase()?.includes("encountered")) {
this["~standard"].async = true;
}
ctx.common = {
issues: [],
async: true
};
}
}
return this._parseAsync({ data, path: [], parent: ctx }).then((result) => isValid(result) ? {
value: result.value
} : {
issues: ctx.common.issues
});
}
async parseAsync(data, params) {
const result = await this.safeParseAsync(data, params);
if (result.success)
return result.data;
throw result.error;
}
async safeParseAsync(data, params) {
const ctx = {
common: {
issues: [],
contextualErrorMap: params?.errorMap,
async: true
},
path: params?.path || [],
schemaErrorMap: this._def.errorMap,
parent: null,
data,
parsedType: getParsedType(data)
};
const maybeAsyncResult = this._parse({ data, path: ctx.path, parent: ctx });
const result = await (isAsync(maybeAsyncResult) ? maybeAsyncResult : Promise.resolve(maybeAsyncResult));
return handleResult(ctx, result);
}
refine(check, message) {
const getIssueProperties = (val) => {
if (typeof message === "string" || typeof message === "undefined") {
return { message };
} else if (typeof message === "function") {
return message(val);
} else {
return message;
}
};
return this._refinement((val, ctx) => {
const result = check(val);
const setError = () => ctx.addIssue({
code: ZodIssueCode.custom,
...getIssueProperties(val)
});
if (typeof Promise !== "undefined" && result instanceof Promise) {
return result.then((data) => {
if (!data) {
setError();
return false;
} else {
return true;
}
});
}
if (!result) {
setError();
return false;
} else {
return true;
}
});
}
refinement(check, refinementData) {
return this._refinement((val, ctx) => {
if (!check(val)) {
ctx.addIssue(typeof refinementData === "function" ? refinementData(val, ctx) : refinementData);
return false;
} else {
return true;
}
});
}
_refinement(refinement) {
return new ZodEffects({
schema: this,
typeName: ZodFirstPartyTypeKind.ZodEffects,
effect: { type: "refinement", refinement }
});
}
superRefine(refinement) {
return this._refinement(refinement);
}
constructor(def) {
this.spa = this.safeParseAsync;
this._def = def;
this.parse = this.parse.bind(this);
this.safeParse = this.safeParse.bind(this);
this.parseAsync = this.parseAsync.bind(this);
this.safeParseAsync = this.safeParseAsync.bind(this);
this.spa = this.spa.bind(this);
this.refine = this.refine.bind(this);
this.refinement = this.refinement.bind(this);
this.superRefine = this.superRefine.bind(this);
this.optional = this.optional.bind(this);
this.nullable = this.nullable.bind(this);
this.nullish = this.nullish.bind(this);
this.array = this.array.bind(this);
this.promise = this.promise.bind(this);
this.or = this.or.bind(this);
this.and = this.and.bind(this);
this.transform = this.transform.bind(this);
this.brand = this.brand.bind(this);
this.default = this.default.bind(this);
this.catch = this.catch.bind(this);
this.describe = this.describe.bind(this);
this.pipe = this.pipe.bind(this);
this.readonly = this.readonly.bind(this);
this.isNullable = this.isNullable.bind(this);
this.isOptional = this.isOptional.bind(this);
this["~standard"] = {
version: 1,
vendor: "zod",
validate: (data) => this["~validate"](data)
};
}
optional() {
return ZodOptional.create(this, this._def);
}
nullable() {
return ZodNullable.create(this, this._def);
}
nullish() {
return this.nullable().optional();
}
array() {
return ZodArray.create(this);
}
promise() {
return ZodPromise.create(this, this._def);
}
or(option) {
return ZodUnion.create([this, option], this._def);
}
and(incoming) {
return ZodIntersection.create(this, incoming, this._def);
}
transform(transform) {
return new ZodEffects({
...processCreateParams(this._def),
schema: this,
typeName: ZodFirstPartyTypeKind.ZodEffects,
effect: { type: "transform", transform }
});
}
default(def) {
const defaultValueFunc = typeof def === "function" ? def : () => def;
return new ZodDefault({
...processCreateParams(this._def),
innerType: this,
defaultValue: defaultValueFunc,
typeName: ZodFirstPartyTypeKind.ZodDefault
});
}
brand() {
return new ZodBranded({
typeName: ZodFirstPartyTypeKind.ZodBranded,
type: this,
...processCreateParams(this._def)
});
}
catch(def) {
const catchValueFunc = typeof def === "function" ? def : () => def;
return new ZodCatch({
...processCreateParams(this._def),
innerType: this,
catchValue: catchValueFunc,
typeName: ZodFirstPartyTypeKind.ZodCatch
});
}
describe(description) {
const This = this.constructor;
return new This({
...this._def,
description
});
}
pipe(target) {
return ZodPipeline.create(this, target);
}
readonly() {
return ZodReadonly.create(this);
}
isOptional() {
return this.safeParse(undefined).success;
}
isNullable() {
return this.safeParse(null).success;
}
}
var cuidRegex = /^c[^\s-]{8,}$/i;
var cuid2Regex = /^[0-9a-z]+$/;
var ulidRegex = /^[0-9A-HJKMNP-TV-Z]{26}$/i;
var uuidRegex = /^[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}$/i;
var nanoidRegex = /^[a-z0-9_-]{21}$/i;
var jwtRegex = /^[A-Za-z0-9-_]+\.[A-Za-z0-9-_]+\.[A-Za-z0-9-_]*$/;
var durationRegex = /^[-+]?P(?!$)(?:(?:[-+]?\d+Y)|(?:[-+]?\d+[.,]\d+Y$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:(?:[-+]?\d+W)|(?:[-+]?\d+[.,]\d+W$))?(?:(?:[-+]?\d+D)|(?:[-+]?\d+[.,]\d+D$))?(?:T(?=[\d+-])(?:(?:[-+]?\d+H)|(?:[-+]?\d+[.,]\d+H$))?(?:(?:[-+]?\d+M)|(?:[-+]?\d+[.,]\d+M$))?(?:[-+]?\d+(?:[.,]\d+)?S)?)??$/;
var emailRegex = /^(?!\.)(?!.*\.\.)([A-Z0-9_'+\-\.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9\-]*\.)+[A-Z]{2,}$/i;
var _emojiRegex = `^(\\p{Extended_Pictographic}|\\p{Emoji_Component})+$`;
var emojiRegex;
var ipv4Regex = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])$/;
var ipv4CidrRegex = /^(?:(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\.){3}(?:25[0-5]|2[0-4][0-9]|1[0-9][0-9]|[1-9][0-9]|[0-9])\/(3[0-2]|[12]?[0-9])$/;
var ipv6Regex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))$/;
var ipv6CidrRegex = /^(([0-9a-fA-F]{1,4}:){7,7}[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,7}:|([0-9a-fA-F]{1,4}:){1,6}:[0-9a-fA-F]{1,4}|([0-9a-fA-F]{1,4}:){1,5}(:[0-9a-fA-F]{1,4}){1,2}|([0-9a-fA-F]{1,4}:){1,4}(:[0-9a-fA-F]{1,4}){1,3}|([0-9a-fA-F]{1,4}:){1,3}(:[0-9a-fA-F]{1,4}){1,4}|([0-9a-fA-F]{1,4}:){1,2}(:[0-9a-fA-F]{1,4}){1,5}|[0-9a-fA-F]{1,4}:((:[0-9a-fA-F]{1,4}){1,6})|:((:[0-9a-fA-F]{1,4}){1,7}|:)|fe80:(:[0-9a-fA-F]{0,4}){0,4}%[0-9a-zA-Z]{1,}|::(ffff(:0{1,4}){0,1}:){0,1}((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])|([0-9a-fA-F]{1,4}:){1,4}:((25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9])\.){3,3}(25[0-5]|(2[0-4]|1{0,1}[0-9]){0,1}[0-9]))\/(12[0-8]|1[01][0-9]|[1-9]?[0-9])$/;
var base64Regex = /^([0-9a-zA-Z+/]{4})*(([0-9a-zA-Z+/]{2}==)|([0-9a-zA-Z+/]{3}=))?$/;
var base64urlRegex = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z-_]{3}(=)?))?$/;
var dateRegexSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
var dateRegex = new RegExp(`^${dateRegexSource}$`);
function timeRegexSource(args) {
let secondsRegexSource = `[0-5]\\d`;
if (args.precision) {
secondsRegexSource = `${secondsRegexSource}\\.\\d{${args.precision}}`;
} else if (args.precision == null) {
secondsRegexSource = `${secondsRegexSource}(\\.\\d+)?`;
}
const secondsQuantifier = args.precision ? "+" : "?";
return `([01]\\d|2[0-3]):[0-5]\\d(:${secondsRegexSource})${secondsQuantifier}`;
}
function timeRegex(args) {
return new RegExp(`^${timeRegexSource(args)}$`);
}
function datetimeRegex(args) {
let regex = `${dateRegexSource}T${timeRegexSource(args)}`;
const opts = [];
opts.push(args.local ? `Z?` : `Z`);
if (args.offset)
opts.push(`([+-]\\d{2}:?\\d{2})`);
regex = `${regex}(${opts.join("|")})`;
return new RegExp(`^${regex}$`);
}
function isValidIP(ip, version) {
if ((version === "v4" || !version) && ipv4Regex.test(ip)) {
return true;
}
if ((version === "v6" || !version) && ipv6Regex.test(ip)) {
return true;
}
return false;
}
function isValidJWT(jwt, alg) {
if (!jwtRegex.test(jwt))
return false;
try {
const [header] = jwt.split(".");
if (!header)
return false;
const base64 = header.replace(/-/g, "+").replace(/_/g, "/").padEnd(header.length + (4 - header.length % 4) % 4, "=");
const decoded = JSON.parse(atob(base64));
if (typeof decoded !== "object" || decoded === null)
return false;
if ("typ" in decoded && decoded?.typ !== "JWT")
return false;
if (!decoded.alg)
return false;
if (alg && decoded.alg !== alg)
return false;
return true;
} catch {
return false;
}
}
function isValidCidr(ip, version) {
if ((version === "v4" || !version) && ipv4CidrRegex.test(ip)) {
return true;
}
if ((version === "v6" || !version) && ipv6CidrRegex.test(ip)) {
return true;
}
return false;
}
class ZodString extends ZodType {
_parse(input) {
if (this._def.coerce) {
input.data = String(input.data);
}
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.string) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.string,
received: ctx.parsedType
});
return INVALID;
}
const status = new ParseStatus;
let ctx = undefined;
for (const check of this._def.checks) {
if (check.kind === "min") {
if (input.data.length < check.value) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.too_small,
minimum: check.value,
type: "string",
inclusive: true,
exact: false,
message: check.message
});
status.dirty();
}
} else if (check.kind === "max") {
if (input.data.length > check.value) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.too_big,
maximum: check.value,
type: "string",
inclusive: true,
exact: false,
message: check.message
});
status.dirty();
}
} else if (check.kind === "length") {
const tooBig = input.data.length > check.value;
const tooSmall = input.data.length < check.value;
if (tooBig || tooSmall) {
ctx = this._getOrReturnCtx(input, ctx);
if (tooBig) {
addIssueToContext(ctx, {
code: ZodIssueCode.too_big,
maximum: check.value,
type: "string",
inclusive: true,
exact: true,
message: check.message
});
} else if (tooSmall) {
addIssueToContext(ctx, {
code: ZodIssueCode.too_small,
minimum: check.value,
type: "string",
inclusive: true,
exact: true,
message: check.message
});
}
status.dirty();
}
} else if (check.kind === "email") {
if (!emailRegex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "email",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "emoji") {
if (!emojiRegex) {
emojiRegex = new RegExp(_emojiRegex, "u");
}
if (!emojiRegex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "emoji",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "uuid") {
if (!uuidRegex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "uuid",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "nanoid") {
if (!nanoidRegex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "nanoid",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "cuid") {
if (!cuidRegex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "cuid",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "cuid2") {
if (!cuid2Regex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "cuid2",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "ulid") {
if (!ulidRegex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "ulid",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "url") {
try {
new URL(input.data);
} catch {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "url",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "regex") {
check.regex.lastIndex = 0;
const testResult = check.regex.test(input.data);
if (!testResult) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "regex",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "trim") {
input.data = input.data.trim();
} else if (check.kind === "includes") {
if (!input.data.includes(check.value, check.position)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_string,
validation: { includes: check.value, position: check.position },
message: check.message
});
status.dirty();
}
} else if (check.kind === "toLowerCase") {
input.data = input.data.toLowerCase();
} else if (check.kind === "toUpperCase") {
input.data = input.data.toUpperCase();
} else if (check.kind === "startsWith") {
if (!input.data.startsWith(check.value)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_string,
validation: { startsWith: check.value },
message: check.message
});
status.dirty();
}
} else if (check.kind === "endsWith") {
if (!input.data.endsWith(check.value)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_string,
validation: { endsWith: check.value },
message: check.message
});
status.dirty();
}
} else if (check.kind === "datetime") {
const regex = datetimeRegex(check);
if (!regex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_string,
validation: "datetime",
message: check.message
});
status.dirty();
}
} else if (check.kind === "date") {
const regex = dateRegex;
if (!regex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_string,
validation: "date",
message: check.message
});
status.dirty();
}
} else if (check.kind === "time") {
const regex = timeRegex(check);
if (!regex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_string,
validation: "time",
message: check.message
});
status.dirty();
}
} else if (check.kind === "duration") {
if (!durationRegex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "duration",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "ip") {
if (!isValidIP(input.data, check.version)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "ip",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "jwt") {
if (!isValidJWT(input.data, check.alg)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "jwt",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "cidr") {
if (!isValidCidr(input.data, check.version)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "cidr",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "base64") {
if (!base64Regex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "base64",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else if (check.kind === "base64url") {
if (!base64urlRegex.test(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
validation: "base64url",
code: ZodIssueCode.invalid_string,
message: check.message
});
status.dirty();
}
} else {
util.assertNever(check);
}
}
return { status: status.value, value: input.data };
}
_regex(regex, validation, message) {
return this.refinement((data) => regex.test(data), {
validation,
code: ZodIssueCode.invalid_string,
...errorUtil.errToObj(message)
});
}
_addCheck(check) {
return new ZodString({
...this._def,
checks: [...this._def.checks, check]
});
}
email(message) {
return this._addCheck({ kind: "email", ...errorUtil.errToObj(message) });
}
url(message) {
return this._addCheck({ kind: "url", ...errorUtil.errToObj(message) });
}
emoji(message) {
return this._addCheck({ kind: "emoji", ...errorUtil.errToObj(message) });
}
uuid(message) {
return this._addCheck({ kind: "uuid", ...errorUtil.errToObj(message) });
}
nanoid(message) {
return this._addCheck({ kind: "nanoid", ...errorUtil.errToObj(message) });
}
cuid(message) {
return this._addCheck({ kind: "cuid", ...errorUtil.errToObj(message) });
}
cuid2(message) {
return this._addCheck({ kind: "cuid2", ...errorUtil.errToObj(message) });
}
ulid(message) {
return this._addCheck({ kind: "ulid", ...errorUtil.errToObj(message) });
}
base64(message) {
return this._addCheck({ kind: "base64", ...errorUtil.errToObj(message) });
}
base64url(message) {
return this._addCheck({
kind: "base64url",
...errorUtil.errToObj(message)
});
}
jwt(options) {
return this._addCheck({ kind: "jwt", ...errorUtil.errToObj(options) });
}
ip(options) {
return this._addCheck({ kind: "ip", ...errorUtil.errToObj(options) });
}
cidr(options) {
return this._addCheck({ kind: "cidr", ...errorUtil.errToObj(options) });
}
datetime(options) {
if (typeof options === "string") {
return this._addCheck({
kind: "datetime",
precision: null,
offset: false,
local: false,
message: options
});
}
return this._addCheck({
kind: "datetime",
precision: typeof options?.precision === "undefined" ? null : options?.precision,
offset: options?.offset ?? false,
local: options?.local ?? false,
...errorUtil.errToObj(options?.message)
});
}
date(message) {
return this._addCheck({ kind: "date", message });
}
time(options) {
if (typeof options === "string") {
return this._addCheck({
kind: "time",
precision: null,
message: options
});
}
return this._addCheck({
kind: "time",
precision: typeof options?.precision === "undefined" ? null : options?.precision,
...errorUtil.errToObj(options?.message)
});
}
duration(message) {
return this._addCheck({ kind: "duration", ...errorUtil.errToObj(message) });
}
regex(regex, message) {
return this._addCheck({
kind: "regex",
regex,
...errorUtil.errToObj(message)
});
}
includes(value, options) {
return this._addCheck({
kind: "includes",
value,
position: options?.position,
...errorUtil.errToObj(options?.message)
});
}
startsWith(value, message) {
return this._addCheck({
kind: "startsWith",
value,
...errorUtil.errToObj(message)
});
}
endsWith(value, message) {
return this._addCheck({
kind: "endsWith",
value,
...errorUtil.errToObj(message)
});
}
min(minLength, message) {
return this._addCheck({
kind: "min",
value: minLength,
...errorUtil.errToObj(message)
});
}
max(maxLength, message) {
return this._addCheck({
kind: "max",
value: maxLength,
...errorUtil.errToObj(message)
});
}
length(len, message) {
return this._addCheck({
kind: "length",
value: len,
...errorUtil.errToObj(message)
});
}
nonempty(message) {
return this.min(1, errorUtil.errToObj(message));
}
trim() {
return new ZodString({
...this._def,
checks: [...this._def.checks, { kind: "trim" }]
});
}
toLowerCase() {
return new ZodString({
...this._def,
checks: [...this._def.checks, { kind: "toLowerCase" }]
});
}
toUpperCase() {
return new ZodString({
...this._def,
checks: [...this._def.checks, { kind: "toUpperCase" }]
});
}
get isDatetime() {
return !!this._def.checks.find((ch) => ch.kind === "datetime");
}
get isDate() {
return !!this._def.checks.find((ch) => ch.kind === "date");
}
get isTime() {
return !!this._def.checks.find((ch) => ch.kind === "time");
}
get isDuration() {
return !!this._def.checks.find((ch) => ch.kind === "duration");
}
get isEmail() {
return !!this._def.checks.find((ch) => ch.kind === "email");
}
get isURL() {
return !!this._def.checks.find((ch) => ch.kind === "url");
}
get isEmoji() {
return !!this._def.checks.find((ch) => ch.kind === "emoji");
}
get isUUID() {
return !!this._def.checks.find((ch) => ch.kind === "uuid");
}
get isNANOID() {
return !!this._def.checks.find((ch) => ch.kind === "nanoid");
}
get isCUID() {
return !!this._def.checks.find((ch) => ch.kind === "cuid");
}
get isCUID2() {
return !!this._def.checks.find((ch) => ch.kind === "cuid2");
}
get isULID() {
return !!this._def.checks.find((ch) => ch.kind === "ulid");
}
get isIP() {
return !!this._def.checks.find((ch) => ch.kind === "ip");
}
get isCIDR() {
return !!this._def.checks.find((ch) => ch.kind === "cidr");
}
get isBase64() {
return !!this._def.checks.find((ch) => ch.kind === "base64");
}
get isBase64url() {
return !!this._def.checks.find((ch) => ch.kind === "base64url");
}
get minLength() {
let min = null;
for (const ch of this._def.checks) {
if (ch.kind === "min") {
if (min === null || ch.value > min)
min = ch.value;
}
}
return min;
}
get maxLength() {
let max = null;
for (const ch of this._def.checks) {
if (ch.kind === "max") {
if (max === null || ch.value < max)
max = ch.value;
}
}
return max;
}
}
ZodString.create = (params) => {
return new ZodString({
checks: [],
typeName: ZodFirstPartyTypeKind.ZodString,
coerce: params?.coerce ?? false,
...processCreateParams(params)
});
};
function floatSafeRemainder(val, step) {
const valDecCount = (val.toString().split(".")[1] || "").length;
const stepDecCount = (step.toString().split(".")[1] || "").length;
const decCount = valDecCount > stepDecCount ? valDecCount : stepDecCount;
const valInt = Number.parseInt(val.toFixed(decCount).replace(".", ""));
const stepInt = Number.parseInt(step.toFixed(decCount).replace(".", ""));
return valInt % stepInt / 10 ** decCount;
}
class ZodNumber extends ZodType {
constructor() {
super(...arguments);
this.min = this.gte;
this.max = this.lte;
this.step = this.multipleOf;
}
_parse(input) {
if (this._def.coerce) {
input.data = Number(input.data);
}
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.number) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.number,
received: ctx.parsedType
});
return INVALID;
}
let ctx = undefined;
const status = new ParseStatus;
for (const check of this._def.checks) {
if (check.kind === "int") {
if (!util.isInteger(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: "integer",
received: "float",
message: check.message
});
status.dirty();
}
} else if (check.kind === "min") {
const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
if (tooSmall) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.too_small,
minimum: check.value,
type: "number",
inclusive: check.inclusive,
exact: false,
message: check.message
});
status.dirty();
}
} else if (check.kind === "max") {
const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
if (tooBig) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.too_big,
maximum: check.value,
type: "number",
inclusive: check.inclusive,
exact: false,
message: check.message
});
status.dirty();
}
} else if (check.kind === "multipleOf") {
if (floatSafeRemainder(input.data, check.value) !== 0) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.not_multiple_of,
multipleOf: check.value,
message: check.message
});
status.dirty();
}
} else if (check.kind === "finite") {
if (!Number.isFinite(input.data)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.not_finite,
message: check.message
});
status.dirty();
}
} else {
util.assertNever(check);
}
}
return { status: status.value, value: input.data };
}
gte(value, message) {
return this.setLimit("min", value, true, errorUtil.toString(message));
}
gt(value, message) {
return this.setLimit("min", value, false, errorUtil.toString(message));
}
lte(value, message) {
return this.setLimit("max", value, true, errorUtil.toString(message));
}
lt(value, message) {
return this.setLimit("max", value, false, errorUtil.toString(message));
}
setLimit(kind, value, inclusive, message) {
return new ZodNumber({
...this._def,
checks: [
...this._def.checks,
{
kind,
value,
inclusive,
message: errorUtil.toString(message)
}
]
});
}
_addCheck(check) {
return new ZodNumber({
...this._def,
checks: [...this._def.checks, check]
});
}
int(message) {
return this._addCheck({
kind: "int",
message: errorUtil.toString(message)
});
}
positive(message) {
return this._addCheck({
kind: "min",
value: 0,
inclusive: false,
message: errorUtil.toString(message)
});
}
negative(message) {
return this._addCheck({
kind: "max",
value: 0,
inclusive: false,
message: errorUtil.toString(message)
});
}
nonpositive(message) {
return this._addCheck({
kind: "max",
value: 0,
inclusive: true,
message: errorUtil.toString(message)
});
}
nonnegative(message) {
return this._addCheck({
kind: "min",
value: 0,
inclusive: true,
message: errorUtil.toString(message)
});
}
multipleOf(value, message) {
return this._addCheck({
kind: "multipleOf",
value,
message: errorUtil.toString(message)
});
}
finite(message) {
return this._addCheck({
kind: "finite",
message: errorUtil.toString(message)
});
}
safe(message) {
return this._addCheck({
kind: "min",
inclusive: true,
value: Number.MIN_SAFE_INTEGER,
message: errorUtil.toString(message)
})._addCheck({
kind: "max",
inclusive: true,
value: Number.MAX_SAFE_INTEGER,
message: errorUtil.toString(message)
});
}
get minValue() {
let min = null;
for (const ch of this._def.checks) {
if (ch.kind === "min") {
if (min === null || ch.value > min)
min = ch.value;
}
}
return min;
}
get maxValue() {
let max = null;
for (const ch of this._def.checks) {
if (ch.kind === "max") {
if (max === null || ch.value < max)
max = ch.value;
}
}
return max;
}
get isInt() {
return !!this._def.checks.find((ch) => ch.kind === "int" || ch.kind === "multipleOf" && util.isInteger(ch.value));
}
get isFinite() {
let max = null;
let min = null;
for (const ch of this._def.checks) {
if (ch.kind === "finite" || ch.kind === "int" || ch.kind === "multipleOf") {
return true;
} else if (ch.kind === "min") {
if (min === null || ch.value > min)
min = ch.value;
} else if (ch.kind === "max") {
if (max === null || ch.value < max)
max = ch.value;
}
}
return Number.isFinite(min) && Number.isFinite(max);
}
}
ZodNumber.create = (params) => {
return new ZodNumber({
checks: [],
typeName: ZodFirstPartyTypeKind.ZodNumber,
coerce: params?.coerce || false,
...processCreateParams(params)
});
};
class ZodBigInt extends ZodType {
constructor() {
super(...arguments);
this.min = this.gte;
this.max = this.lte;
}
_parse(input) {
if (this._def.coerce) {
try {
input.data = BigInt(input.data);
} catch {
return this._getInvalidInput(input);
}
}
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.bigint) {
return this._getInvalidInput(input);
}
let ctx = undefined;
const status = new ParseStatus;
for (const check of this._def.checks) {
if (check.kind === "min") {
const tooSmall = check.inclusive ? input.data < check.value : input.data <= check.value;
if (tooSmall) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.too_small,
type: "bigint",
minimum: check.value,
inclusive: check.inclusive,
message: check.message
});
status.dirty();
}
} else if (check.kind === "max") {
const tooBig = check.inclusive ? input.data > check.value : input.data >= check.value;
if (tooBig) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.too_big,
type: "bigint",
maximum: check.value,
inclusive: check.inclusive,
message: check.message
});
status.dirty();
}
} else if (check.kind === "multipleOf") {
if (input.data % check.value !== BigInt(0)) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.not_multiple_of,
multipleOf: check.value,
message: check.message
});
status.dirty();
}
} else {
util.assertNever(check);
}
}
return { status: status.value, value: input.data };
}
_getInvalidInput(input) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.bigint,
received: ctx.parsedType
});
return INVALID;
}
gte(value, message) {
return this.setLimit("min", value, true, errorUtil.toString(message));
}
gt(value, message) {
return this.setLimit("min", value, false, errorUtil.toString(message));
}
lte(value, message) {
return this.setLimit("max", value, true, errorUtil.toString(message));
}
lt(value, message) {
return this.setLimit("max", value, false, errorUtil.toString(message));
}
setLimit(kind, value, inclusive, message) {
return new ZodBigInt({
...this._def,
checks: [
...this._def.checks,
{
kind,
value,
inclusive,
message: errorUtil.toString(message)
}
]
});
}
_addCheck(check) {
return new ZodBigInt({
...this._def,
checks: [...this._def.checks, check]
});
}
positive(message) {
return this._addCheck({
kind: "min",
value: BigInt(0),
inclusive: false,
message: errorUtil.toString(message)
});
}
negative(message) {
return this._addCheck({
kind: "max",
value: BigInt(0),
inclusive: false,
message: errorUtil.toString(message)
});
}
nonpositive(message) {
return this._addCheck({
kind: "max",
value: BigInt(0),
inclusive: true,
message: errorUtil.toString(message)
});
}
nonnegative(message) {
return this._addCheck({
kind: "min",
value: BigInt(0),
inclusive: true,
message: errorUtil.toString(message)
});
}
multipleOf(value, message) {
return this._addCheck({
kind: "multipleOf",
value,
message: errorUtil.toString(message)
});
}
get minValue() {
let min = null;
for (const ch of this._def.checks) {
if (ch.kind === "min") {
if (min === null || ch.value > min)
min = ch.value;
}
}
return min;
}
get maxValue() {
let max = null;
for (const ch of this._def.checks) {
if (ch.kind === "max") {
if (max === null || ch.value < max)
max = ch.value;
}
}
return max;
}
}
ZodBigInt.create = (params) => {
return new ZodBigInt({
checks: [],
typeName: ZodFirstPartyTypeKind.ZodBigInt,
coerce: params?.coerce ?? false,
...processCreateParams(params)
});
};
class ZodBoolean extends ZodType {
_parse(input) {
if (this._def.coerce) {
input.data = Boolean(input.data);
}
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.boolean) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.boolean,
received: ctx.parsedType
});
return INVALID;
}
return OK(input.data);
}
}
ZodBoolean.create = (params) => {
return new ZodBoolean({
typeName: ZodFirstPartyTypeKind.ZodBoolean,
coerce: params?.coerce || false,
...processCreateParams(params)
});
};
class ZodDate extends ZodType {
_parse(input) {
if (this._def.coerce) {
input.data = new Date(input.data);
}
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.date) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.date,
received: ctx.parsedType
});
return INVALID;
}
if (Number.isNaN(input.data.getTime())) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_date
});
return INVALID;
}
const status = new ParseStatus;
let ctx = undefined;
for (const check of this._def.checks) {
if (check.kind === "min") {
if (input.data.getTime() < check.value) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.too_small,
message: check.message,
inclusive: true,
exact: false,
minimum: check.value,
type: "date"
});
status.dirty();
}
} else if (check.kind === "max") {
if (input.data.getTime() > check.value) {
ctx = this._getOrReturnCtx(input, ctx);
addIssueToContext(ctx, {
code: ZodIssueCode.too_big,
message: check.message,
inclusive: true,
exact: false,
maximum: check.value,
type: "date"
});
status.dirty();
}
} else {
util.assertNever(check);
}
}
return {
status: status.value,
value: new Date(input.data.getTime())
};
}
_addCheck(check) {
return new ZodDate({
...this._def,
checks: [...this._def.checks, check]
});
}
min(minDate, message) {
return this._addCheck({
kind: "min",
value: minDate.getTime(),
message: errorUtil.toString(message)
});
}
max(maxDate, message) {
return this._addCheck({
kind: "max",
value: maxDate.getTime(),
message: errorUtil.toString(message)
});
}
get minDate() {
let min = null;
for (const ch of this._def.checks) {
if (ch.kind === "min") {
if (min === null || ch.value > min)
min = ch.value;
}
}
return min != null ? new Date(min) : null;
}
get maxDate() {
let max = null;
for (const ch of this._def.checks) {
if (ch.kind === "max") {
if (max === null || ch.value < max)
max = ch.value;
}
}
return max != null ? new Date(max) : null;
}
}
ZodDate.create = (params) => {
return new ZodDate({
checks: [],
coerce: params?.coerce || false,
typeName: ZodFirstPartyTypeKind.ZodDate,
...processCreateParams(params)
});
};
class ZodSymbol extends ZodType {
_parse(input) {
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.symbol) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.symbol,
received: ctx.parsedType
});
return INVALID;
}
return OK(input.data);
}
}
ZodSymbol.create = (params) => {
return new ZodSymbol({
typeName: ZodFirstPartyTypeKind.ZodSymbol,
...processCreateParams(params)
});
};
class ZodUndefined extends ZodType {
_parse(input) {
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.undefined) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.undefined,
received: ctx.parsedType
});
return INVALID;
}
return OK(input.data);
}
}
ZodUndefined.create = (params) => {
return new ZodUndefined({
typeName: ZodFirstPartyTypeKind.ZodUndefined,
...processCreateParams(params)
});
};
class ZodNull extends ZodType {
_parse(input) {
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.null) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.null,
received: ctx.parsedType
});
return INVALID;
}
return OK(input.data);
}
}
ZodNull.create = (params) => {
return new ZodNull({
typeName: ZodFirstPartyTypeKind.ZodNull,
...processCreateParams(params)
});
};
class ZodAny extends ZodType {
constructor() {
super(...arguments);
this._any = true;
}
_parse(input) {
return OK(input.data);
}
}
ZodAny.create = (params) => {
return new ZodAny({
typeName: ZodFirstPartyTypeKind.ZodAny,
...processCreateParams(params)
});
};
class ZodUnknown extends ZodType {
constructor() {
super(...arguments);
this._unknown = true;
}
_parse(input) {
return OK(input.data);
}
}
ZodUnknown.create = (params) => {
return new ZodUnknown({
typeName: ZodFirstPartyTypeKind.ZodUnknown,
...processCreateParams(params)
});
};
class ZodNever extends ZodType {
_parse(input) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.never,
received: ctx.parsedType
});
return INVALID;
}
}
ZodNever.create = (params) => {
return new ZodNever({
typeName: ZodFirstPartyTypeKind.ZodNever,
...processCreateParams(params)
});
};
class ZodVoid extends ZodType {
_parse(input) {
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.undefined) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.void,
received: ctx.parsedType
});
return INVALID;
}
return OK(input.data);
}
}
ZodVoid.create = (params) => {
return new ZodVoid({
typeName: ZodFirstPartyTypeKind.ZodVoid,
...processCreateParams(params)
});
};
class ZodArray extends ZodType {
_parse(input) {
const { ctx, status } = this._processInputParams(input);
const def = this._def;
if (ctx.parsedType !== ZodParsedType.array) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.array,
received: ctx.parsedType
});
return INVALID;
}
if (def.exactLength !== null) {
const tooBig = ctx.data.length > def.exactLength.value;
const tooSmall = ctx.data.length < def.exactLength.value;
if (tooBig || tooSmall) {
addIssueToContext(ctx, {
code: tooBig ? ZodIssueCode.too_big : ZodIssueCode.too_small,
minimum: tooSmall ? def.exactLength.value : undefined,
maximum: tooBig ? def.exactLength.value : undefined,
type: "array",
inclusive: true,
exact: true,
message: def.exactLength.message
});
status.dirty();
}
}
if (def.minLength !== null) {
if (ctx.data.length < def.minLength.value) {
addIssueToContext(ctx, {
code: ZodIssueCode.too_small,
minimum: def.minLength.value,
type: "array",
inclusive: true,
exact: false,
message: def.minLength.message
});
status.dirty();
}
}
if (def.maxLength !== null) {
if (ctx.data.length > def.maxLength.value) {
addIssueToContext(ctx, {
code: ZodIssueCode.too_big,
maximum: def.maxLength.value,
type: "array",
inclusive: true,
exact: false,
message: def.maxLength.message
});
status.dirty();
}
}
if (ctx.common.async) {
return Promise.all([...ctx.data].map((item, i) => {
return def.type._parseAsync(new ParseInputLazyPath(ctx, item, ctx.path, i));
})).then((result) => {
return ParseStatus.mergeArray(status, result);
});
}
const result = [...ctx.data].map((item, i) => {
return def.type._parseSync(new ParseInputLazyPath(ctx, item, ctx.path, i));
});
return ParseStatus.mergeArray(status, result);
}
get element() {
return this._def.type;
}
min(minLength, message) {
return new ZodArray({
...this._def,
minLength: { value: minLength, message: errorUtil.toString(message) }
});
}
max(maxLength, message) {
return new ZodArray({
...this._def,
maxLength: { value: maxLength, message: errorUtil.toString(message) }
});
}
length(len, message) {
return new ZodArray({
...this._def,
exactLength: { value: len, message: errorUtil.toString(message) }
});
}
nonempty(message) {
return this.min(1, message);
}
}
ZodArray.create = (schema, params) => {
return new ZodArray({
type: schema,
minLength: null,
maxLength: null,
exactLength: null,
typeName: ZodFirstPartyTypeKind.ZodArray,
...processCreateParams(params)
});
};
function deepPartialify(schema) {
if (schema instanceof ZodObject) {
const newShape = {};
for (const key in schema.shape) {
const fieldSchema = schema.shape[key];
newShape[key] = ZodOptional.create(deepPartialify(fieldSchema));
}
return new ZodObject({
...schema._def,
shape: () => newShape
});
} else if (schema instanceof ZodArray) {
return new ZodArray({
...schema._def,
type: deepPartialify(schema.element)
});
} else if (schema instanceof ZodOptional) {
return ZodOptional.create(deepPartialify(schema.unwrap()));
} else if (schema instanceof ZodNullable) {
return ZodNullable.create(deepPartialify(schema.unwrap()));
} else if (schema instanceof ZodTuple) {
return ZodTuple.create(schema.items.map((item) => deepPartialify(item)));
} else {
return schema;
}
}
class ZodObject extends ZodType {
constructor() {
super(...arguments);
this._cached = null;
this.nonstrict = this.passthrough;
this.augment = this.extend;
}
_getCached() {
if (this._cached !== null)
return this._cached;
const shape = this._def.shape();
const keys = util.objectKeys(shape);
this._cached = { shape, keys };
return this._cached;
}
_parse(input) {
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.object) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.object,
received: ctx.parsedType
});
return INVALID;
}
const { status, ctx } = this._processInputParams(input);
const { shape, keys: shapeKeys } = this._getCached();
const extraKeys = [];
if (!(this._def.catchall instanceof ZodNever && this._def.unknownKeys === "strip")) {
for (const key in ctx.data) {
if (!shapeKeys.includes(key)) {
extraKeys.push(key);
}
}
}
const pairs = [];
for (const key of shapeKeys) {
const keyValidator = shape[key];
const value = ctx.data[key];
pairs.push({
key: { status: "valid", value: key },
value: keyValidator._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
alwaysSet: key in ctx.data
});
}
if (this._def.catchall instanceof ZodNever) {
const unknownKeys = this._def.unknownKeys;
if (unknownKeys === "passthrough") {
for (const key of extraKeys) {
pairs.push({
key: { status: "valid", value: key },
value: { status: "valid", value: ctx.data[key] }
});
}
} else if (unknownKeys === "strict") {
if (extraKeys.length > 0) {
addIssueToContext(ctx, {
code: ZodIssueCode.unrecognized_keys,
keys: extraKeys
});
status.dirty();
}
} else if (unknownKeys === "strip") {} else {
throw new Error(`Internal ZodObject error: invalid unknownKeys value.`);
}
} else {
const catchall = this._def.catchall;
for (const key of extraKeys) {
const value = ctx.data[key];
pairs.push({
key: { status: "valid", value: key },
value: catchall._parse(new ParseInputLazyPath(ctx, value, ctx.path, key)),
alwaysSet: key in ctx.data
});
}
}
if (ctx.common.async) {
return Promise.resolve().then(async () => {
const syncPairs = [];
for (const pair of pairs) {
const key = await pair.key;
const value = await pair.value;
syncPairs.push({
key,
value,
alwaysSet: pair.alwaysSet
});
}
return syncPairs;
}).then((syncPairs) => {
return ParseStatus.mergeObjectSync(status, syncPairs);
});
} else {
return ParseStatus.mergeObjectSync(status, pairs);
}
}
get shape() {
return this._def.shape();
}
strict(message) {
errorUtil.errToObj;
return new ZodObject({
...this._def,
unknownKeys: "strict",
...message !== undefined ? {
errorMap: (issue, ctx) => {
const defaultError = this._def.errorMap?.(issue, ctx).message ?? ctx.defaultError;
if (issue.code === "unrecognized_keys")
return {
message: errorUtil.errToObj(message).message ?? defaultError
};
return {
message: defaultError
};
}
} : {}
});
}
strip() {
return new ZodObject({
...this._def,
unknownKeys: "strip"
});
}
passthrough() {
return new ZodObject({
...this._def,
unknownKeys: "passthrough"
});
}
extend(augmentation) {
return new ZodObject({
...this._def,
shape: () => ({
...this._def.shape(),
...augmentation
})
});
}
merge(merging) {
const merged = new ZodObject({
unknownKeys: merging._def.unknownKeys,
catchall: merging._def.catchall,
shape: () => ({
...this._def.shape(),
...merging._def.shape()
}),
typeName: ZodFirstPartyTypeKind.ZodObject
});
return merged;
}
setKey(key, schema) {
return this.augment({ [key]: schema });
}
catchall(index) {
return new ZodObject({
...this._def,
catchall: index
});
}
pick(mask) {
const shape = {};
for (const key of util.objectKeys(mask)) {
if (mask[key] && this.shape[key]) {
shape[key] = this.shape[key];
}
}
return new ZodObject({
...this._def,
shape: () => shape
});
}
omit(mask) {
const shape = {};
for (const key of util.objectKeys(this.shape)) {
if (!mask[key]) {
shape[key] = this.shape[key];
}
}
return new ZodObject({
...this._def,
shape: () => shape
});
}
deepPartial() {
return deepPartialify(this);
}
partial(mask) {
const newShape = {};
for (const key of util.objectKeys(this.shape)) {
const fieldSchema = this.shape[key];
if (mask && !mask[key]) {
newShape[key] = fieldSchema;
} else {
newShape[key] = fieldSchema.optional();
}
}
return new ZodObject({
...this._def,
shape: () => newShape
});
}
required(mask) {
const newShape = {};
for (const key of util.objectKeys(this.shape)) {
if (mask && !mask[key]) {
newShape[key] = this.shape[key];
} else {
const fieldSchema = this.shape[key];
let newField = fieldSchema;
while (newField instanceof ZodOptional) {
newField = newField._def.innerType;
}
newShape[key] = newField;
}
}
return new ZodObject({
...this._def,
shape: () => newShape
});
}
keyof() {
return createZodEnum(util.objectKeys(this.shape));
}
}
ZodObject.create = (shape, params) => {
return new ZodObject({
shape: () => shape,
unknownKeys: "strip",
catchall: ZodNever.create(),
typeName: ZodFirstPartyTypeKind.ZodObject,
...processCreateParams(params)
});
};
ZodObject.strictCreate = (shape, params) => {
return new ZodObject({
shape: () => shape,
unknownKeys: "strict",
catchall: ZodNever.create(),
typeName: ZodFirstPartyTypeKind.ZodObject,
...processCreateParams(params)
});
};
ZodObject.lazycreate = (shape, params) => {
return new ZodObject({
shape,
unknownKeys: "strip",
catchall: ZodNever.create(),
typeName: ZodFirstPartyTypeKind.ZodObject,
...processCreateParams(params)
});
};
class ZodUnion extends ZodType {
_parse(input) {
const { ctx } = this._processInputParams(input);
const options = this._def.options;
function handleResults(results) {
for (const result of results) {
if (result.result.status === "valid") {
return result.result;
}
}
for (const result of results) {
if (result.result.status === "dirty") {
ctx.common.issues.push(...result.ctx.common.issues);
return result.result;
}
}
const unionErrors = results.map((result) => new ZodError(result.ctx.common.issues));
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_union,
unionErrors
});
return INVALID;
}
if (ctx.common.async) {
return Promise.all(options.map(async (option) => {
const childCtx = {
...ctx,
common: {
...ctx.common,
issues: []
},
parent: null
};
return {
result: await option._parseAsync({
data: ctx.data,
path: ctx.path,
parent: childCtx
}),
ctx: childCtx
};
})).then(handleResults);
} else {
let dirty = undefined;
const issues = [];
for (const option of options) {
const childCtx = {
...ctx,
common: {
...ctx.common,
issues: []
},
parent: null
};
const result = option._parseSync({
data: ctx.data,
path: ctx.path,
parent: childCtx
});
if (result.status === "valid") {
return result;
} else if (result.status === "dirty" && !dirty) {
dirty = { result, ctx: childCtx };
}
if (childCtx.common.issues.length) {
issues.push(childCtx.common.issues);
}
}
if (dirty) {
ctx.common.issues.push(...dirty.ctx.common.issues);
return dirty.result;
}
const unionErrors = issues.map((issues) => new ZodError(issues));
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_union,
unionErrors
});
return INVALID;
}
}
get options() {
return this._def.options;
}
}
ZodUnion.create = (types, params) => {
return new ZodUnion({
options: types,
typeName: ZodFirstPartyTypeKind.ZodUnion,
...processCreateParams(params)
});
};
var getDiscriminator = (type) => {
if (type instanceof ZodLazy) {
return getDiscriminator(type.schema);
} else if (type instanceof ZodEffects) {
return getDiscriminator(type.innerType());
} else if (type instanceof ZodLiteral) {
return [type.value];
} else if (type instanceof ZodEnum) {
return type.options;
} else if (type instanceof ZodNativeEnum) {
return util.objectValues(type.enum);
} else if (type instanceof ZodDefault) {
return getDiscriminator(type._def.innerType);
} else if (type instanceof ZodUndefined) {
return [undefined];
} else if (type instanceof ZodNull) {
return [null];
} else if (type instanceof ZodOptional) {
return [undefined, ...getDiscriminator(type.unwrap())];
} else if (type instanceof ZodNullable) {
return [null, ...getDiscriminator(type.unwrap())];
} else if (type instanceof ZodBranded) {
return getDiscriminator(type.unwrap());
} else if (type instanceof ZodReadonly) {
return getDiscriminator(type.unwrap());
} else if (type instanceof ZodCatch) {
return getDiscriminator(type._def.innerType);
} else {
return [];
}
};
class ZodDiscriminatedUnion extends ZodType {
_parse(input) {
const { ctx } = this._processInputParams(input);
if (ctx.parsedType !== ZodParsedType.object) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.object,
received: ctx.parsedType
});
return INVALID;
}
const discriminator = this.discriminator;
const discriminatorValue = ctx.data[discriminator];
const option = this.optionsMap.get(discriminatorValue);
if (!option) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_union_discriminator,
options: Array.from(this.optionsMap.keys()),
path: [discriminator]
});
return INVALID;
}
if (ctx.common.async) {
return option._parseAsync({
data: ctx.data,
path: ctx.path,
parent: ctx
});
} else {
return option._parseSync({
data: ctx.data,
path: ctx.path,
parent: ctx
});
}
}
get discriminator() {
return this._def.discriminator;
}
get options() {
return this._def.options;
}
get optionsMap() {
return this._def.optionsMap;
}
static create(discriminator, options, params) {
const optionsMap = new Map;
for (const type of options) {
const discriminatorValues = getDiscriminator(type.shape[discriminator]);
if (!discriminatorValues.length) {
throw new Error(`A discriminator value for key \`${discriminator}\` could not be extracted from all schema options`);
}
for (const value of discriminatorValues) {
if (optionsMap.has(value)) {
throw new Error(`Discriminator property ${String(discriminator)} has duplicate value ${String(value)}`);
}
optionsMap.set(value, type);
}
}
return new ZodDiscriminatedUnion({
typeName: ZodFirstPartyTypeKind.ZodDiscriminatedUnion,
discriminator,
options,
optionsMap,
...processCreateParams(params)
});
}
}
function mergeValues(a, b) {
const aType = getParsedType(a);
const bType = getParsedType(b);
if (a === b) {
return { valid: true, data: a };
} else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {
const bKeys = util.objectKeys(b);
const sharedKeys = util.objectKeys(a).filter((key) => bKeys.indexOf(key) !== -1);
const newObj = { ...a, ...b };
for (const key of sharedKeys) {
const sharedValue = mergeValues(a[key], b[key]);
if (!sharedValue.valid) {
return { valid: false };
}
newObj[key] = sharedValue.data;
}
return { valid: true, data: newObj };
} else if (aType === ZodParsedType.array && bType === ZodParsedType.array) {
if (a.length !== b.length) {
return { valid: false };
}
const newArray = [];
for (let index = 0;index < a.length; index++) {
const itemA = a[index];
const itemB = b[index];
const sharedValue = mergeValues(itemA, itemB);
if (!sharedValue.valid) {
return { valid: false };
}
newArray.push(sharedValue.data);
}
return { valid: true, data: newArray };
} else if (aType === ZodParsedType.date && bType === ZodParsedType.date && +a === +b) {
return { valid: true, data: a };
} else {
return { valid: false };
}
}
class ZodIntersection extends ZodType {
_parse(input) {
const { status, ctx } = this._processInputParams(input);
const handleParsed = (parsedLeft, parsedRight) => {
if (isAborted(parsedLeft) || isAborted(parsedRight)) {
return INVALID;
}
const merged = mergeValues(parsedLeft.value, parsedRight.value);
if (!merged.valid) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_intersection_types
});
return INVALID;
}
if (isDirty(parsedLeft) || isDirty(parsedRight)) {
status.dirty();
}
return { status: status.value, value: merged.data };
};
if (ctx.common.async) {
return Promise.all([
this._def.left._parseAsync({
data: ctx.data,
path: ctx.path,
parent: ctx
}),
this._def.right._parseAsync({
data: ctx.data,
path: ctx.path,
parent: ctx
})
]).then(([left, right]) => handleParsed(left, right));
} else {
return handleParsed(this._def.left._parseSync({
data: ctx.data,
path: ctx.path,
parent: ctx
}), this._def.right._parseSync({
data: ctx.data,
path: ctx.path,
parent: ctx
}));
}
}
}
ZodIntersection.create = (left, right, params) => {
return new ZodIntersection({
left,
right,
typeName: ZodFirstPartyTypeKind.ZodIntersection,
...processCreateParams(params)
});
};
class ZodTuple extends ZodType {
_parse(input) {
const { status, ctx } = this._processInputParams(input);
if (ctx.parsedType !== ZodParsedType.array) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.array,
received: ctx.parsedType
});
return INVALID;
}
if (ctx.data.length < this._def.items.length) {
addIssueToContext(ctx, {
code: ZodIssueCode.too_small,
minimum: this._def.items.length,
inclusive: true,
exact: false,
type: "array"
});
return INVALID;
}
const rest = this._def.rest;
if (!rest && ctx.data.length > this._def.items.length) {
addIssueToContext(ctx, {
code: ZodIssueCode.too_big,
maximum: this._def.items.length,
inclusive: true,
exact: false,
type: "array"
});
status.dirty();
}
const items = [...ctx.data].map((item, itemIndex) => {
const schema = this._def.items[itemIndex] || this._def.rest;
if (!schema)
return null;
return schema._parse(new ParseInputLazyPath(ctx, item, ctx.path, itemIndex));
}).filter((x) => !!x);
if (ctx.common.async) {
return Promise.all(items).then((results) => {
return ParseStatus.mergeArray(status, results);
});
} else {
return ParseStatus.mergeArray(status, items);
}
}
get items() {
return this._def.items;
}
rest(rest) {
return new ZodTuple({
...this._def,
rest
});
}
}
ZodTuple.create = (schemas, params) => {
if (!Array.isArray(schemas)) {
throw new Error("You must pass an array of schemas to z.tuple([ ... ])");
}
return new ZodTuple({
items: schemas,
typeName: ZodFirstPartyTypeKind.ZodTuple,
rest: null,
...processCreateParams(params)
});
};
class ZodRecord extends ZodType {
get keySchema() {
return this._def.keyType;
}
get valueSchema() {
return this._def.valueType;
}
_parse(input) {
const { status, ctx } = this._processInputParams(input);
if (ctx.parsedType !== ZodParsedType.object) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.object,
received: ctx.parsedType
});
return INVALID;
}
const pairs = [];
const keyType = this._def.keyType;
const valueType = this._def.valueType;
for (const key in ctx.data) {
pairs.push({
key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, key)),
value: valueType._parse(new ParseInputLazyPath(ctx, ctx.data[key], ctx.path, key)),
alwaysSet: key in ctx.data
});
}
if (ctx.common.async) {
return ParseStatus.mergeObjectAsync(status, pairs);
} else {
return ParseStatus.mergeObjectSync(status, pairs);
}
}
get element() {
return this._def.valueType;
}
static create(first, second, third) {
if (second instanceof ZodType) {
return new ZodRecord({
keyType: first,
valueType: second,
typeName: ZodFirstPartyTypeKind.ZodRecord,
...processCreateParams(third)
});
}
return new ZodRecord({
keyType: ZodString.create(),
valueType: first,
typeName: ZodFirstPartyTypeKind.ZodRecord,
...processCreateParams(second)
});
}
}
class ZodMap extends ZodType {
get keySchema() {
return this._def.keyType;
}
get valueSchema() {
return this._def.valueType;
}
_parse(input) {
const { status, ctx } = this._processInputParams(input);
if (ctx.parsedType !== ZodParsedType.map) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.map,
received: ctx.parsedType
});
return INVALID;
}
const keyType = this._def.keyType;
const valueType = this._def.valueType;
const pairs = [...ctx.data.entries()].map(([key, value], index) => {
return {
key: keyType._parse(new ParseInputLazyPath(ctx, key, ctx.path, [index, "key"])),
value: valueType._parse(new ParseInputLazyPath(ctx, value, ctx.path, [index, "value"]))
};
});
if (ctx.common.async) {
const finalMap = new Map;
return Promise.resolve().then(async () => {
for (const pair of pairs) {
const key = await pair.key;
const value = await pair.value;
if (key.status === "aborted" || value.status === "aborted") {
return INVALID;
}
if (key.status === "dirty" || value.status === "dirty") {
status.dirty();
}
finalMap.set(key.value, value.value);
}
return { status: status.value, value: finalMap };
});
} else {
const finalMap = new Map;
for (const pair of pairs) {
const key = pair.key;
const value = pair.value;
if (key.status === "aborted" || value.status === "aborted") {
return INVALID;
}
if (key.status === "dirty" || value.status === "dirty") {
status.dirty();
}
finalMap.set(key.value, value.value);
}
return { status: status.value, value: finalMap };
}
}
}
ZodMap.create = (keyType, valueType, params) => {
return new ZodMap({
valueType,
keyType,
typeName: ZodFirstPartyTypeKind.ZodMap,
...processCreateParams(params)
});
};
class ZodSet extends ZodType {
_parse(input) {
const { status, ctx } = this._processInputParams(input);
if (ctx.parsedType !== ZodParsedType.set) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.set,
received: ctx.parsedType
});
return INVALID;
}
const def = this._def;
if (def.minSize !== null) {
if (ctx.data.size < def.minSize.value) {
addIssueToContext(ctx, {
code: ZodIssueCode.too_small,
minimum: def.minSize.value,
type: "set",
inclusive: true,
exact: false,
message: def.minSize.message
});
status.dirty();
}
}
if (def.maxSize !== null) {
if (ctx.data.size > def.maxSize.value) {
addIssueToContext(ctx, {
code: ZodIssueCode.too_big,
maximum: def.maxSize.value,
type: "set",
inclusive: true,
exact: false,
message: def.maxSize.message
});
status.dirty();
}
}
const valueType = this._def.valueType;
function finalizeSet(elements) {
const parsedSet = new Set;
for (const element of elements) {
if (element.status === "aborted")
return INVALID;
if (element.status === "dirty")
status.dirty();
parsedSet.add(element.value);
}
return { status: status.value, value: parsedSet };
}
const elements = [...ctx.data.values()].map((item, i) => valueType._parse(new ParseInputLazyPath(ctx, item, ctx.path, i)));
if (ctx.common.async) {
return Promise.all(elements).then((elements) => finalizeSet(elements));
} else {
return finalizeSet(elements);
}
}
min(minSize, message) {
return new ZodSet({
...this._def,
minSize: { value: minSize, message: errorUtil.toString(message) }
});
}
max(maxSize, message) {
return new ZodSet({
...this._def,
maxSize: { value: maxSize, message: errorUtil.toString(message) }
});
}
size(size, message) {
return this.min(size, message).max(size, message);
}
nonempty(message) {
return this.min(1, message);
}
}
ZodSet.create = (valueType, params) => {
return new ZodSet({
valueType,
minSize: null,
maxSize: null,
typeName: ZodFirstPartyTypeKind.ZodSet,
...processCreateParams(params)
});
};
class ZodFunction extends ZodType {
constructor() {
super(...arguments);
this.validate = this.implement;
}
_parse(input) {
const { ctx } = this._processInputParams(input);
if (ctx.parsedType !== ZodParsedType.function) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.function,
received: ctx.parsedType
});
return INVALID;
}
function makeArgsIssue(args, error) {
return makeIssue({
data: args,
path: ctx.path,
errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), en_default].filter((x) => !!x),
issueData: {
code: ZodIssueCode.invalid_arguments,
argumentsError: error
}
});
}
function makeReturnsIssue(returns, error) {
return makeIssue({
data: returns,
path: ctx.path,
errorMaps: [ctx.common.contextualErrorMap, ctx.schemaErrorMap, getErrorMap(), en_default].filter((x) => !!x),
issueData: {
code: ZodIssueCode.invalid_return_type,
returnTypeError: error
}
});
}
const params = { errorMap: ctx.common.contextualErrorMap };
const fn = ctx.data;
if (this._def.returns instanceof ZodPromise) {
const me = this;
return OK(async function(...args) {
const error = new ZodError([]);
const parsedArgs = await me._def.args.parseAsync(args, params).catch((e) => {
error.addIssue(makeArgsIssue(args, e));
throw error;
});
const result = await Reflect.apply(fn, this, parsedArgs);
const parsedReturns = await me._def.returns._def.type.parseAsync(result, params).catch((e) => {
error.addIssue(makeReturnsIssue(result, e));
throw error;
});
return parsedReturns;
});
} else {
const me = this;
return OK(function(...args) {
const parsedArgs = me._def.args.safeParse(args, params);
if (!parsedArgs.success) {
throw new ZodError([makeArgsIssue(args, parsedArgs.error)]);
}
const result = Reflect.apply(fn, this, parsedArgs.data);
const parsedReturns = me._def.returns.safeParse(result, params);
if (!parsedReturns.success) {
throw new ZodError([makeReturnsIssue(result, parsedReturns.error)]);
}
return parsedReturns.data;
});
}
}
parameters() {
return this._def.args;
}
returnType() {
return this._def.returns;
}
args(...items) {
return new ZodFunction({
...this._def,
args: ZodTuple.create(items).rest(ZodUnknown.create())
});
}
returns(returnType) {
return new ZodFunction({
...this._def,
returns: returnType
});
}
implement(func) {
const validatedFunc = this.parse(func);
return validatedFunc;
}
strictImplement(func) {
const validatedFunc = this.parse(func);
return validatedFunc;
}
static create(args, returns, params) {
return new ZodFunction({
args: args ? args : ZodTuple.create([]).rest(ZodUnknown.create()),
returns: returns || ZodUnknown.create(),
typeName: ZodFirstPartyTypeKind.ZodFunction,
...processCreateParams(params)
});
}
}
class ZodLazy extends ZodType {
get schema() {
return this._def.getter();
}
_parse(input) {
const { ctx } = this._processInputParams(input);
const lazySchema = this._def.getter();
return lazySchema._parse({ data: ctx.data, path: ctx.path, parent: ctx });
}
}
ZodLazy.create = (getter, params) => {
return new ZodLazy({
getter,
typeName: ZodFirstPartyTypeKind.ZodLazy,
...processCreateParams(params)
});
};
class ZodLiteral extends ZodType {
_parse(input) {
if (input.data !== this._def.value) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
received: ctx.data,
code: ZodIssueCode.invalid_literal,
expected: this._def.value
});
return INVALID;
}
return { status: "valid", value: input.data };
}
get value() {
return this._def.value;
}
}
ZodLiteral.create = (value, params) => {
return new ZodLiteral({
value,
typeName: ZodFirstPartyTypeKind.ZodLiteral,
...processCreateParams(params)
});
};
function createZodEnum(values, params) {
return new ZodEnum({
values,
typeName: ZodFirstPartyTypeKind.ZodEnum,
...processCreateParams(params)
});
}
class ZodEnum extends ZodType {
_parse(input) {
if (typeof input.data !== "string") {
const ctx = this._getOrReturnCtx(input);
const expectedValues = this._def.values;
addIssueToContext(ctx, {
expected: util.joinValues(expectedValues),
received: ctx.parsedType,
code: ZodIssueCode.invalid_type
});
return INVALID;
}
if (!this._cache) {
this._cache = new Set(this._def.values);
}
if (!this._cache.has(input.data)) {
const ctx = this._getOrReturnCtx(input);
const expectedValues = this._def.values;
addIssueToContext(ctx, {
received: ctx.data,
code: ZodIssueCode.invalid_enum_value,
options: expectedValues
});
return INVALID;
}
return OK(input.data);
}
get options() {
return this._def.values;
}
get enum() {
const enumValues = {};
for (const val of this._def.values) {
enumValues[val] = val;
}
return enumValues;
}
get Values() {
const enumValues = {};
for (const val of this._def.values) {
enumValues[val] = val;
}
return enumValues;
}
get Enum() {
const enumValues = {};
for (const val of this._def.values) {
enumValues[val] = val;
}
return enumValues;
}
extract(values, newDef = this._def) {
return ZodEnum.create(values, {
...this._def,
...newDef
});
}
exclude(values, newDef = this._def) {
return ZodEnum.create(this.options.filter((opt) => !values.includes(opt)), {
...this._def,
...newDef
});
}
}
ZodEnum.create = createZodEnum;
class ZodNativeEnum extends ZodType {
_parse(input) {
const nativeEnumValues = util.getValidEnumValues(this._def.values);
const ctx = this._getOrReturnCtx(input);
if (ctx.parsedType !== ZodParsedType.string && ctx.parsedType !== ZodParsedType.number) {
const expectedValues = util.objectValues(nativeEnumValues);
addIssueToContext(ctx, {
expected: util.joinValues(expectedValues),
received: ctx.parsedType,
code: ZodIssueCode.invalid_type
});
return INVALID;
}
if (!this._cache) {
this._cache = new Set(util.getValidEnumValues(this._def.values));
}
if (!this._cache.has(input.data)) {
const expectedValues = util.objectValues(nativeEnumValues);
addIssueToContext(ctx, {
received: ctx.data,
code: ZodIssueCode.invalid_enum_value,
options: expectedValues
});
return INVALID;
}
return OK(input.data);
}
get enum() {
return this._def.values;
}
}
ZodNativeEnum.create = (values, params) => {
return new ZodNativeEnum({
values,
typeName: ZodFirstPartyTypeKind.ZodNativeEnum,
...processCreateParams(params)
});
};
class ZodPromise extends ZodType {
unwrap() {
return this._def.type;
}
_parse(input) {
const { ctx } = this._processInputParams(input);
if (ctx.parsedType !== ZodParsedType.promise && ctx.common.async === false) {
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.promise,
received: ctx.parsedType
});
return INVALID;
}
const promisified = ctx.parsedType === ZodParsedType.promise ? ctx.data : Promise.resolve(ctx.data);
return OK(promisified.then((data) => {
return this._def.type.parseAsync(data, {
path: ctx.path,
errorMap: ctx.common.contextualErrorMap
});
}));
}
}
ZodPromise.create = (schema, params) => {
return new ZodPromise({
type: schema,
typeName: ZodFirstPartyTypeKind.ZodPromise,
...processCreateParams(params)
});
};
class ZodEffects extends ZodType {
innerType() {
return this._def.schema;
}
sourceType() {
return this._def.schema._def.typeName === ZodFirstPartyTypeKind.ZodEffects ? this._def.schema.sourceType() : this._def.schema;
}
_parse(input) {
const { status, ctx } = this._processInputParams(input);
const effect = this._def.effect || null;
const checkCtx = {
addIssue: (arg) => {
addIssueToContext(ctx, arg);
if (arg.fatal) {
status.abort();
} else {
status.dirty();
}
},
get path() {
return ctx.path;
}
};
checkCtx.addIssue = checkCtx.addIssue.bind(checkCtx);
if (effect.type === "preprocess") {
const processed = effect.transform(ctx.data, checkCtx);
if (ctx.common.async) {
return Promise.resolve(processed).then(async (processed) => {
if (status.value === "aborted")
return INVALID;
const result = await this._def.schema._parseAsync({
data: processed,
path: ctx.path,
parent: ctx
});
if (result.status === "aborted")
return INVALID;
if (result.status === "dirty")
return DIRTY(result.value);
if (status.value === "dirty")
return DIRTY(result.value);
return result;
});
} else {
if (status.value === "aborted")
return INVALID;
const result = this._def.schema._parseSync({
data: processed,
path: ctx.path,
parent: ctx
});
if (result.status === "aborted")
return INVALID;
if (result.status === "dirty")
return DIRTY(result.value);
if (status.value === "dirty")
return DIRTY(result.value);
return result;
}
}
if (effect.type === "refinement") {
const executeRefinement = (acc) => {
const result = effect.refinement(acc, checkCtx);
if (ctx.common.async) {
return Promise.resolve(result);
}
if (result instanceof Promise) {
throw new Error("Async refinement encountered during synchronous parse operation. Use .parseAsync instead.");
}
return acc;
};
if (ctx.common.async === false) {
const inner = this._def.schema._parseSync({
data: ctx.data,
path: ctx.path,
parent: ctx
});
if (inner.status === "aborted")
return INVALID;
if (inner.status === "dirty")
status.dirty();
executeRefinement(inner.value);
return { status: status.value, value: inner.value };
} else {
return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((inner) => {
if (inner.status === "aborted")
return INVALID;
if (inner.status === "dirty")
status.dirty();
return executeRefinement(inner.value).then(() => {
return { status: status.value, value: inner.value };
});
});
}
}
if (effect.type === "transform") {
if (ctx.common.async === false) {
const base = this._def.schema._parseSync({
data: ctx.data,
path: ctx.path,
parent: ctx
});
if (!isValid(base))
return INVALID;
const result = effect.transform(base.value, checkCtx);
if (result instanceof Promise) {
throw new Error(`Asynchronous transform encountered during synchronous parse operation. Use .parseAsync instead.`);
}
return { status: status.value, value: result };
} else {
return this._def.schema._parseAsync({ data: ctx.data, path: ctx.path, parent: ctx }).then((base) => {
if (!isValid(base))
return INVALID;
return Promise.resolve(effect.transform(base.value, checkCtx)).then((result) => ({
status: status.value,
value: result
}));
});
}
}
util.assertNever(effect);
}
}
ZodEffects.create = (schema, effect, params) => {
return new ZodEffects({
schema,
typeName: ZodFirstPartyTypeKind.ZodEffects,
effect,
...processCreateParams(params)
});
};
ZodEffects.createWithPreprocess = (preprocess, schema, params) => {
return new ZodEffects({
schema,
effect: { type: "preprocess", transform: preprocess },
typeName: ZodFirstPartyTypeKind.ZodEffects,
...processCreateParams(params)
});
};
class ZodOptional extends ZodType {
_parse(input) {
const parsedType = this._getType(input);
if (parsedType === ZodParsedType.undefined) {
return OK(undefined);
}
return this._def.innerType._parse(input);
}
unwrap() {
return this._def.innerType;
}
}
ZodOptional.create = (type, params) => {
return new ZodOptional({
innerType: type,
typeName: ZodFirstPartyTypeKind.ZodOptional,
...processCreateParams(params)
});
};
class ZodNullable extends ZodType {
_parse(input) {
const parsedType = this._getType(input);
if (parsedType === ZodParsedType.null) {
return OK(null);
}
return this._def.innerType._parse(input);
}
unwrap() {
return this._def.innerType;
}
}
ZodNullable.create = (type, params) => {
return new ZodNullable({
innerType: type,
typeName: ZodFirstPartyTypeKind.ZodNullable,
...processCreateParams(params)
});
};
class ZodDefault extends ZodType {
_parse(input) {
const { ctx } = this._processInputParams(input);
let data = ctx.data;
if (ctx.parsedType === ZodParsedType.undefined) {
data = this._def.defaultValue();
}
return this._def.innerType._parse({
data,
path: ctx.path,
parent: ctx
});
}
removeDefault() {
return this._def.innerType;
}
}
ZodDefault.create = (type, params) => {
return new ZodDefault({
innerType: type,
typeName: ZodFirstPartyTypeKind.ZodDefault,
defaultValue: typeof params.default === "function" ? params.default : () => params.default,
...processCreateParams(params)
});
};
class ZodCatch extends ZodType {
_parse(input) {
const { ctx } = this._processInputParams(input);
const newCtx = {
...ctx,
common: {
...ctx.common,
issues: []
}
};
const result = this._def.innerType._parse({
data: newCtx.data,
path: newCtx.path,
parent: {
...newCtx
}
});
if (isAsync(result)) {
return result.then((result) => {
return {
status: "valid",
value: result.status === "valid" ? result.value : this._def.catchValue({
get error() {
return new ZodError(newCtx.common.issues);
},
input: newCtx.data
})
};
});
} else {
return {
status: "valid",
value: result.status === "valid" ? result.value : this._def.catchValue({
get error() {
return new ZodError(newCtx.common.issues);
},
input: newCtx.data
})
};
}
}
removeCatch() {
return this._def.innerType;
}
}
ZodCatch.create = (type, params) => {
return new ZodCatch({
innerType: type,
typeName: ZodFirstPartyTypeKind.ZodCatch,
catchValue: typeof params.catch === "function" ? params.catch : () => params.catch,
...processCreateParams(params)
});
};
class ZodNaN extends ZodType {
_parse(input) {
const parsedType = this._getType(input);
if (parsedType !== ZodParsedType.nan) {
const ctx = this._getOrReturnCtx(input);
addIssueToContext(ctx, {
code: ZodIssueCode.invalid_type,
expected: ZodParsedType.nan,
received: ctx.parsedType
});
return INVALID;
}
return { status: "valid", value: input.data };
}
}
ZodNaN.create = (params) => {
return new ZodNaN({
typeName: ZodFirstPartyTypeKind.ZodNaN,
...processCreateParams(params)
});
};
var BRAND = Symbol("zod_brand");
class ZodBranded extends ZodType {
_parse(input) {
const { ctx } = this._processInputParams(input);
const data = ctx.data;
return this._def.type._parse({
data,
path: ctx.path,
parent: ctx
});
}
unwrap() {
return this._def.type;
}
}
class ZodPipeline extends ZodType {
_parse(input) {
const { status, ctx } = this._processInputParams(input);
if (ctx.common.async) {
const handleAsync = async () => {
const inResult = await this._def.in._parseAsync({
data: ctx.data,
path: ctx.path,
parent: ctx
});
if (inResult.status === "aborted")
return INVALID;
if (inResult.status === "dirty") {
status.dirty();
return DIRTY(inResult.value);
} else {
return this._def.out._parseAsync({
data: inResult.value,
path: ctx.path,
parent: ctx
});
}
};
return handleAsync();
} else {
const inResult = this._def.in._parseSync({
data: ctx.data,
path: ctx.path,
parent: ctx
});
if (inResult.status === "aborted")
return INVALID;
if (inResult.status === "dirty") {
status.dirty();
return {
status: "dirty",
value: inResult.value
};
} else {
return this._def.out._parseSync({
data: inResult.value,
path: ctx.path,
parent: ctx
});
}
}
}
static create(a, b) {
return new ZodPipeline({
in: a,
out: b,
typeName: ZodFirstPartyTypeKind.ZodPipeline
});
}
}
class ZodReadonly extends ZodType {
_parse(input) {
const result = this._def.innerType._parse(input);
const freeze = (data) => {
if (isValid(data)) {
data.value = Object.freeze(data.value);
}
return data;
};
return isAsync(result) ? result.then((data) => freeze(data)) : freeze(result);
}
unwrap() {
return this._def.innerType;
}
}
ZodReadonly.create = (type, params) => {
return new ZodReadonly({
innerType: type,
typeName: ZodFirstPartyTypeKind.ZodReadonly,
...processCreateParams(params)
});
};
var late = {
object: ZodObject.lazycreate
};
var ZodFirstPartyTypeKind;
(function(ZodFirstPartyTypeKind) {
ZodFirstPartyTypeKind["ZodString"] = "ZodString";
ZodFirstPartyTypeKind["ZodNumber"] = "ZodNumber";
ZodFirstPartyTypeKind["ZodNaN"] = "ZodNaN";
ZodFirstPartyTypeKind["ZodBigInt"] = "ZodBigInt";
ZodFirstPartyTypeKind["ZodBoolean"] = "ZodBoolean";
ZodFirstPartyTypeKind["ZodDate"] = "ZodDate";
ZodFirstPartyTypeKind["ZodSymbol"] = "ZodSymbol";
ZodFirstPartyTypeKind["ZodUndefined"] = "ZodUndefined";
ZodFirstPartyTypeKind["ZodNull"] = "ZodNull";
ZodFirstPartyTypeKind["ZodAny"] = "ZodAny";
ZodFirstPartyTypeKind["ZodUnknown"] = "ZodUnknown";
ZodFirstPartyTypeKind["ZodNever"] = "ZodNever";
ZodFirstPartyTypeKind["ZodVoid"] = "ZodVoid";
ZodFirstPartyTypeKind["ZodArray"] = "ZodArray";
ZodFirstPartyTypeKind["ZodObject"] = "ZodObject";
ZodFirstPartyTypeKind["ZodUnion"] = "ZodUnion";
ZodFirstPartyTypeKind["ZodDiscriminatedUnion"] = "ZodDiscriminatedUnion";
ZodFirstPartyTypeKind["ZodIntersection"] = "ZodIntersection";
ZodFirstPartyTypeKind["ZodTuple"] = "ZodTuple";
ZodFirstPartyTypeKind["ZodRecord"] = "ZodRecord";
ZodFirstPartyTypeKind["ZodMap"] = "ZodMap";
ZodFirstPartyTypeKind["ZodSet"] = "ZodSet";
ZodFirstPartyTypeKind["ZodFunction"] = "ZodFunction";
ZodFirstPartyTypeKind["ZodLazy"] = "ZodLazy";
ZodFirstPartyTypeKind["ZodLiteral"] = "ZodLiteral";
ZodFirstPartyTypeKind["ZodEnum"] = "ZodEnum";
ZodFirstPartyTypeKind["ZodEffects"] = "ZodEffects";
ZodFirstPartyTypeKind["ZodNativeEnum"] = "ZodNativeEnum";
ZodFirstPartyTypeKind["ZodOptional"] = "ZodOptional";
ZodFirstPartyTypeKind["ZodNullable"] = "ZodNullable";
ZodFirstPartyTypeKind["ZodDefault"] = "ZodDefault";
ZodFirstPartyTypeKind["ZodCatch"] = "ZodCatch";
ZodFirstPartyTypeKind["ZodPromise"] = "ZodPromise";
ZodFirstPartyTypeKind["ZodBranded"] = "ZodBranded";
ZodFirstPartyTypeKind["ZodPipeline"] = "ZodPipeline";
ZodFirstPartyTypeKind["ZodReadonly"] = "ZodReadonly";
})(ZodFirstPartyTypeKind || (ZodFirstPartyTypeKind = {}));
var stringType = ZodString.create;
var numberType = ZodNumber.create;
var nanType = ZodNaN.create;
var bigIntType = ZodBigInt.create;
var booleanType = ZodBoolean.create;
var dateType = ZodDate.create;
var symbolType = ZodSymbol.create;
var undefinedType = ZodUndefined.create;
var nullType = ZodNull.create;
var anyType = ZodAny.create;
var unknownType = ZodUnknown.create;
var neverType = ZodNever.create;
var voidType = ZodVoid.create;
var arrayType = ZodArray.create;
var objectType = ZodObject.create;
var strictObjectType = ZodObject.strictCreate;
var unionType = ZodUnion.create;
var discriminatedUnionType = ZodDiscriminatedUnion.create;
var intersectionType = ZodIntersection.create;
var tupleType = ZodTuple.create;
var recordType = ZodRecord.create;
var mapType = ZodMap.create;
var setType = ZodSet.create;
var functionType = ZodFunction.create;
var lazyType = ZodLazy.create;
var literalType = ZodLiteral.create;
var enumType = ZodEnum.create;
var nativeEnumType = ZodNativeEnum.create;
var promiseType = ZodPromise.create;
var effectsType = ZodEffects.create;
var optionalType = ZodOptional.create;
var nullableType = ZodNullable.create;
var preprocessType = ZodEffects.createWithPreprocess;
var pipelineType = ZodPipeline.create;
// ../contracts/dist/client/transport.js
import { isIP } from "net";
import { spawnSync } from "child_process";
import { closeSync as closeSync2, fstatSync as fstatSync2, openSync as openSync2, readFileSync as readFileSync2 } from "fs";
import { O_NOFOLLOW as O_NOFOLLOW2, O_NONBLOCK as O_NONBLOCK2, O_RDONLY as O_RDONLY2 } from "constants";
import { hostname as osHostname } from "os";
import { isAbsolute, join as join2 } from "path";
import { createRequire } from "module";
import { fileURLToPath as fileURLToPath2 } from "url";
import { closeSync, fstatSync, lstatSync, openSync, readFileSync, realpathSync, statSync } from "fs";
import { O_NOFOLLOW, O_NONBLOCK, O_RDONLY } from "constants";
import { basename, dirname, join, relative, sep } from "path";
import { fileURLToPath, pathToFileURL } from "url";
function envToken(name) {
return name.toUpperCase().replace(/-/g, "_");
}
function clientTransportEnvKeys(name) {
const envSegment = envToken(name);
return {
apiUrlKeys: [`HASNA_${envSegment}_API_URL`, `${envSegment}_API_URL`],
apiKeyKeys: [`HASNA_${envSegment}_API_KEY`, `${envSegment}_API_KEY`]
};
}
function credentialOverrideEnvKey(name) {
return `HASNA_${envToken(name)}_API_KEY_OVERRIDE`;
}
var CREDENTIAL_PROFILE_ENV_KEY = "HASNA_PROFILE";
function credentialPointerEnvKey(name) {
return `HASNA_${envToken(name)}_API_KEY_REF`;
}
function e(e2, n, r) {
throw new Error(r ? `No known conditions for "${n}" specifier in "${e2}" package` : `Missing "${n}" specifier in "${e2}" package`);
}
function n(n2, i, o, f) {
let s, u, l = r(n2, o), c = function(e2) {
let n3 = new Set(["default", ...e2.conditions || []]);
return e2.unsafe || n3.add(e2.require ? "require" : "import"), e2.unsafe || n3.add(e2.browser ? "browser" : "node"), n3;
}(f || {}), a = i[l];
if (a === undefined) {
let e2, n3, r, t;
for (t in i)
n3 && t.length < n3.length || (t[t.length - 1] === "/" && l.startsWith(t) ? (u = l.substring(t.length), n3 = t) : t.length > 1 && (r = t.indexOf("*", 1), ~r && (e2 = RegExp("^" + t.substring(0, r) + "(.*)" + t.substring(1 + r) + "$").exec(l), e2 && e2[1] && (u = e2[1], n3 = t))));
a = i[n3];
}
return a || e(n2, l), s = t(a, c), s || e(n2, l, 1), u && function(e2, n3) {
let r, t = 0, i2 = e2.length, o2 = /[*]/g, f2 = /[/]$/;
for (;t < i2; t++)
e2[t] = o2.test(r = e2[t]) ? r.replace(o2, n3) : f2.test(r) ? r + n3 : r;
}(s, u), s;
}
function r(e2, n2, r2) {
if (e2 === n2 || n2 === ".")
return ".";
let t = e2 + "/", i = t.length, o = n2.slice(0, i) === t, f = o ? n2.slice(i) : n2;
return f[0] === "#" ? f : o || !r2 ? f.slice(0, 2) === "./" ? f : "./" + f : f;
}
function t(e2, n2, r2) {
if (e2) {
if (typeof e2 == "string")
return r2 && r2.add(e2), [e2];
let i, o;
if (Array.isArray(e2)) {
for (o = r2 || new Set, i = 0;i < e2.length; i++)
t(e2[i], n2, o);
if (!r2 && o.size)
return [...o];
} else
for (i in e2)
if (n2.has(i))
return t(e2[i], n2, r2);
}
}
function o(e2, r2, t2) {
let i, o2 = e2.exports;
if (o2) {
if (typeof o2 == "string")
o2 = { ".": o2 };
else
for (i in o2) {
i[0] !== "." && (o2 = { ".": o2 });
break;
}
return n(e2.name, o2, r2 || ".", t2);
}
}
var PACKAGE = "@hasna/secrets";
var MAX_PACKAGE_BYTES = 1024 * 1024;
function entryPoint(directory) {
const root = realpathSync(directory);
const fd = openSync(join(root, "package.json"), O_RDONLY | O_NOFOLLOW | O_NONBLOCK);
let pkg;
try {
const stat = fstatSync(fd);
if (!stat.isFile() || stat.size > MAX_PACKAGE_BYTES)
throw new Error("Invalid Secrets package metadata");
pkg = JSON.parse(readFileSync(fd, "utf8"));
} finally {
closeSync(fd);
}
if (!pkg || typeof pkg !== "object" || !("name" in pkg) || pkg.name !== PACKAGE) {
throw new Error("Invalid Secrets package identity");
}
const target = o(pkg, ".")?.[0];
if (typeof target !== "string" || !target.startsWith("./"))
throw new Error("Missing Secrets import export");
const parts = target.slice(2).split("/");
if (/[\\%?#\0]/.test(target) || parts.some((part) => !part || part === "." || part === ".." || part === "node_modules")) {
throw new Error("Invalid Secrets import export");
}
const file = realpathSync(join(root, ...parts));
const within = relative(root, file);
if (!within || within === ".." || within.startsWith(`..${sep}`) || !statSync(file).isFile()) {
throw new Error("Secrets import export escapes its package or is not a file");
}
return pathToFileURL(file).href;
}
function resolveInstalledSecrets(parentUrl) {
let directory = dirname(fileURLToPath(parentUrl));
for (;; ) {
if (basename(directory) !== "node_modules") {
const candidate = join(directory, "node_modules", PACKAGE);
let absent = false;
try {
lstatSync(candidate);
} catch (error) {
if (error.code !== "ENOENT")
throw error;
absent = true;
}
if (!absent)
return entryPoint(candidate);
}
const parent = dirname(directory);
if (parent === directory)
throw new Error("Secrets SDK is not installed for this consumer");
directory = parent;
}
}
class CredentialResolutionError extends Error {
appName;
attempted;
constructor(appName, message, attempted) {
super(message);
this.name = "CredentialResolutionError";
this.appName = appName;
this.attempted = attempted;
}
}
class CredentialFileUnsafeError extends Error {
path;
constructor(path, reason) {
super(`Refusing unsafe credential/config file ${path}: ${reason}.`);
this.name = "CredentialFileUnsafeError";
this.path = path;
}
}
var HASNA_HOME_ENV_KEY = "HASNA_HOME";
var HASNA_CONFIG_HOME_ENV_KEY = "HASNA_CONFIG_HOME";
var KEYCHAIN_STATION_ENV_KEY = "HASNA_STATION";
var HASNA_HOME_DIR = ".hasna";
var CONFIG_SUBDIR = "config";
var CREDENTIALS_FILE = "credentials";
var KEYCHAIN_SECURITY_BIN = "/usr/bin/security";
var KEYCHAIN_SERVICE_PREFIX = "hasna.credentials";
var KEYCHAIN_ITEM_NOT_FOUND_STATUS = 44;
var KEYCHAIN_SPAWN_TIMEOUT_MS = 1e4;
var MAX_CREDENTIAL_FILE_BYTES = 64 * 1024;
var SAFE_APP_SLUG = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
var SAFE_PROFILE = /^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/;
var ILLEGAL_IN_HEADER_VALUE = /[^\t\x20-\x7e]/;
var VAULT_POINTER_SHAPE = /^[a-z0-9][a-z0-9-]*(?:\/[a-z0-9][a-z0-9-_.]*){2,}$/;
function homeDir(env) {
const home = env.HOME?.trim();
return home ? home : null;
}
function absoluteOverride(env, key) {
const value = env[key]?.trim();
return value && isAbsolute(value) ? value : null;
}
function hasnaHomeDir(env) {
const override = absoluteOverride(env, HASNA_HOME_ENV_KEY);
if (override)
return override;
const home = homeDir(env);
return home ? join2(home, HASNA_HOME_DIR) : null;
}
function appConfigDir(name, env) {
const configRoot = absoluteOverride(env, HASNA_CONFIG_HOME_ENV_KEY);
if (configRoot)
return join2(configRoot, name);
const root = hasnaHomeDir(env);
return root ? join2(root, name, CONFIG_SUBDIR) : null;
}
function credentialDiskSourceList(name, env, profile = null) {
if (!SAFE_APP_SLUG.test(name))
return [];
const directory = appConfigDir(name, env);
if (!directory)
return [];
const file = profile ? `${CREDENTIALS_FILE}-${profile}` : CREDENTIALS_FILE;
return [{ path: join2(directory, file), tier: "disk" }];
}
function credentialDiskSources(name, env) {
return credentialDiskSourceList(name, env, null).map((s) => s.path);
}
function profileDiskSources(name, env, profile) {
return credentialDiskSourceList(name, env, profile).map((s) => s.path);
}
function parseEnvFile(text) {
const values = new Map;
const unusable = new Set;
for (const rawLine of text.split(/\r?\n/)) {
const line = rawLine.trim();
if (line.length === 0 || line.startsWith("#"))
continue;
const withoutExport = line.startsWith("export ") ? line.slice("export ".length).trim() : line;
const equals = withoutExport.indexOf("=");
if (equals <= 0)
continue;
const key = withoutExport.slice(0, equals).trim();
if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key))
continue;
let value = withoutExport.slice(equals + 1).trim();
const quote = value[0];
if (quote === '"' || quote === "'") {
if (value.length < 2 || !value.endsWith(quote)) {
unusable.add(key);
continue;
}
value = value.slice(1, -1);
}
if (value.trim().length === 0) {
unusable.add(key);
continue;
}
if (values.has(key) && values.get(key) !== value)
unusable.add(key);
values.set(key, value);
}
return { values, unusable };
}
function configFileModeAllowed(mode) {
const permissions = mode & 4095;
return permissions === 256 || permissions === 384;
}
function configFileReadsCoherent(before, after) {
return before.dev === after.dev && before.ino === after.ino && before.size === after.size && before.mtimeMs === after.mtimeMs && before.ctimeMs === after.ctimeMs;
}
function readAppConfigFile(path) {
const unsafe = (reason) => {
throw new CredentialFileUnsafeError(path, reason);
};
let fd = -1;
try {
fd = openSync2(path, O_RDONLY2 | O_NOFOLLOW2 | O_NONBLOCK2);
} catch (error) {
const code = error.code;
if (code === "ENOENT" || code === "ENOTDIR")
return null;
if (code === "ELOOP")
unsafe("the path is a symlink");
unsafe(`the path could not be opened (${code ?? "unknown error"})`);
}
try {
const before = fstatSync2(fd);
if (!before.isFile())
unsafe("the path is not a regular file");
if (!configFileModeAllowed(before.mode)) {
unsafe(`permission mode ${(before.mode & 4095).toString(8).padStart(4, "0")} is not owner-only 0400 or 0600`);
}
const uid = process.getuid?.() ?? process.geteuid?.();
if (uid !== undefined && before.uid !== uid)
unsafe("the file is not owned by the current user");
if (before.size > MAX_CREDENTIAL_FILE_BYTES)
unsafe("the file exceeds the size limit");
const bytes = readFileSync2(fd);
const after = fstatSync2(fd);
if (!configFileReadsCoherent(before, after)) {
unsafe("the file changed while being read");
}
return parseEnvFile(bytes.toString("utf8"));
} finally {
if (fd !== -1)
closeSync2(fd);
}
}
function readCredentialFile(path, apiKeyKeys, pointerKey) {
const parsed = readAppConfigFile(path);
if (!parsed)
return null;
for (const key of [...apiKeyKeys, pointerKey]) {
if (parsed.unusable.has(key)) {
throw new CredentialFileUnsafeError(path, `${key} is declared but blank or malformed`);
}
}
const values = apiKeyKeys.map((key) => parsed.values.get(key)?.trim()).filter((value) => Boolean(value));
const pointer = parsed.values.get(pointerKey)?.trim();
if (pointer !== undefined) {
if (!VAULT_POINTER_SHAPE.test(pointer))
throw new CredentialFileUnsafeError(path, `${pointerKey} must name a vault item`);
if (values.length)
throw new CredentialFileUnsafeError(path, "a credential file cannot select both a literal key and a vault reference");
return { apiKey: "", pointerVaultKey: pointer };
}
if (new Set(values).size > 1) {
throw new CredentialFileUnsafeError(path, "credential aliases disagree");
}
return values[0] === undefined ? null : { apiKey: values[0] };
}
var CREDENTIAL_SHAPED_KEY = /(?:^|_)(?:API_KEY|KEY|TOKEN|SECRET|PASSWORD|PASSWD|CREDENTIAL|AUTH)(?:_|$)/;
function appConfigDiskValue(name, env, keys, profile = null) {
if (profile !== null && !SAFE_PROFILE.test(profile)) {
throw new CredentialResolutionError(name, "The selected configuration profile is invalid.", ["profile"]);
}
const wanted = keys.filter((key) => !CREDENTIAL_SHAPED_KEY.test(key));
if (wanted.length === 0)
return null;
for (const path of profileDiskSources(name, env, profile)) {
const parsed = readAppConfigFile(path);
if (!parsed)
continue;
if (wanted.some((key) => parsed.unusable.has(key))) {
return { key: wanted.find((key) => parsed.unusable.has(key)), value: "", path, unusable: true };
}
const values = wanted.map((key) => parsed.values.get(key)?.trim()).filter((value) => Boolean(value));
if (new Set(values).size > 1)
throw new CredentialFileUnsafeError(path, "configuration aliases disagree");
for (const key of wanted) {
if (parsed.unusable.has(key))
return { key, value: "", path, unusable: true };
const value = parsed.values.get(key)?.trim();
if (value)
return { key, value, path };
}
}
return null;
}
function assertUsableCredential(appName, source, value) {
if (VAULT_POINTER_SHAPE.test(value)) {
throw new CredentialResolutionError(appName, `The credential from ${source} looks like a secrets-vault pointer (a path-shaped reference like ` + `'namespace/app/live/api_key'). A vault path is NEVER accepted as a literal API key. ` + `Use ${credentialPointerEnvKey(appName)} to resolve the key through the vault, or provide the actual key value.`, [source]);
}
if (!ILLEGAL_IN_HEADER_VALUE.test(value))
return;
throw new CredentialResolutionError(appName, `The credential from ${source} contains characters that cannot be sent in an HTTP header ` + `(a control character or non-ASCII byte). A file written with CR-only line endings is the usual ` + `cause. Rewrite that credential file with one LF-terminated KEY=value line. ` + `The value is not shown here, and is deliberately never logged.`, [source]);
}
var INSPECT_CUSTOM = Symbol.for("nodejs.util.inspect.custom");
var CREDENTIAL_SEAL = Symbol.for("hasna:contracts:sealedCredential");
var CALLER_SUPPLIED_CREDENTIAL_PROVIDER_SOURCE = "caller-supplied CredentialProvider";
function sealCredential(fields) {
const { apiKey } = fields;
const visible = {
tier: fields.tier,
source: fields.source,
deliberate: fields.deliberate,
diskCandidates: Object.freeze([...fields.diskCandidates]),
warning: fields.warning
};
const sealed = { ...visible };
Object.defineProperty(sealed, "apiKey", {
value: apiKey,
enumerable: false,
writable: false,
configurable: false
});
if (fields.pointerVaultKey !== undefined) {
Object.defineProperty(sealed, "pointerVaultKey", {
value: fields.pointerVaultKey,
enumerable: false,
writable: false,
configurable: false
});
}
Object.defineProperty(sealed, INSPECT_CUSTOM, {
value: () => ({ ...visible, apiKey: "[redacted]" }),
enumerable: false,
writable: false,
configurable: false
});
Object.defineProperty(sealed, CREDENTIAL_SEAL, {
value: true,
enumerable: false,
writable: false,
configurable: false
});
return Object.freeze(sealed);
}
function isSealedCredential(credential) {
return credential[CREDENTIAL_SEAL] === true;
}
function explicitCredential(appName, apiKey) {
const source = "explicit apiKey option";
assertUsableCredential(appName, source, apiKey);
return sealCredential({
apiKey,
tier: "argument",
source,
deliberate: true,
diskCandidates: [],
warning: null
});
}
function validateAndSealResolvedCredential(appName, credential) {
const apiKey = credential.apiKey;
assertUsableCredential(appName, CALLER_SUPPLIED_CREDENTIAL_PROVIDER_SOURCE, apiKey);
if (!isSealedCredential(credential)) {
return sealCredential({
apiKey,
tier: "argument",
source: CALLER_SUPPLIED_CREDENTIAL_PROVIDER_SOURCE,
deliberate: true,
diskCandidates: [],
warning: null
});
}
return sealCredential({
apiKey,
tier: credential.tier,
source: credential.source,
deliberate: credential.deliberate,
diskCandidates: credential.diskCandidates,
warning: credential.warning,
...credential.pointerVaultKey !== undefined ? { pointerVaultKey: credential.pointerVaultKey } : {}
});
}
function firstEnvValue(env, keys) {
for (const key of keys) {
if (!Object.prototype.hasOwnProperty.call(env, key))
continue;
const value = env[key]?.trim();
if (value)
return { key, value };
}
return null;
}
var AMBIENT_ENVIRONMENT = Symbol.for("hasna:contracts:ambientClientEnvironment");
function isAmbientEnvironment(env) {
return env === process.env || env[AMBIENT_ENVIRONMENT] === true;
}
function defaultKeychainRunner(argv) {
const result = spawnSync(KEYCHAIN_SECURITY_BIN, [...argv], {
encoding: "utf8",
stdio: ["ignore", "pipe", "pipe"],
timeout: KEYCHAIN_SPAWN_TIMEOUT_MS
});
return {
status: result.status,
stdout: result.stdout ?? "",
stderr: result.error ? result.error.message : result.stderr ?? ""
};
}
function keychainTierEnabled(env, options) {
if ((options.platform ?? process.platform) !== "darwin")
return false;
if (options.enabled !== undefined)
return options.enabled;
return options.run !== undefined || isAmbientEnvironment(env);
}
function keychainAccount(env, options) {
const station = env[KEYCHAIN_STATION_ENV_KEY]?.trim();
if (station)
return station;
const host = (options.hostname ?? osHostname)().split(".")[0]?.trim() ?? "";
if (host)
return host;
const user = env.USER?.trim();
return user || null;
}
function keychainFailureHint(text) {
const line = text.split(/\r?\n/).find((entry) => entry.trim().length > 0)?.trim() ?? "";
const clean = line.replace(/[\u0000-\u001f\u007f]/g, "").slice(0, 200);
return clean ? `: ${clean}` : "";
}
function readKeychainItem(name, env, kind, options) {
if (!SAFE_APP_SLUG.test(name) || !keychainTierEnabled(env, options))
return null;
const account = keychainAccount(env, options);
if (!account)
return null;
const service = `${KEYCHAIN_SERVICE_PREFIX}.${name}.${kind}`;
const source = `keychain:${service}@${account}`;
const run = options.run ?? defaultKeychainRunner;
let result;
try {
result = run(["find-generic-password", "-a", account, "-s", service, "-w"]);
} catch (error) {
const reason = keychainFailureHint(error instanceof Error ? error.message : String(error));
throw new CredentialResolutionError(name, `The Keychain lookup for ${source} could not run${reason}. A Keychain failure is never resolved ` + `around: fix the keychain, or delete the item to fall through to the credential on disk.`, [source]);
}
if (result.status === KEYCHAIN_ITEM_NOT_FOUND_STATUS)
return null;
if (result.status !== 0) {
throw new CredentialResolutionError(name, `The Keychain lookup for ${source} failed (security exited ` + `${result.status ?? "without a status"}${keychainFailureHint(result.stderr)}). A Keychain item that ` + `exists but cannot be read is never resolved around: unlock the keychain, run from a session that ` + `may use it, or delete the item to fall through to the credential on disk.`, [source]);
}
const value = result.stdout.trim();
if (!value) {
throw new CredentialResolutionError(name, `${source} exists but holds an empty value; a declared item never falls through to another ` + `identity. Store a value in it or delete the item.`, [source]);
}
return { value, source };
}
function keychainConfigValue(name, env, options = {}) {
return readKeychainItem(name, env, "api-url", options);
}
function snapshotClientEnvironment(name, env) {
const keys = clientTransportEnvKeys(name);
const ambient = isAmbientEnvironment(env);
const snapshot = Object.create(null);
for (const key of [
...keys.apiUrlKeys,
...keys.apiKeyKeys,
credentialOverrideEnvKey(name),
credentialPointerEnvKey(name),
CREDENTIAL_PROFILE_ENV_KEY,
"HOME",
HASNA_HOME_ENV_KEY,
HASNA_CONFIG_HOME_ENV_KEY,
KEYCHAIN_STATION_ENV_KEY,
"USER"
]) {
const descriptor = Object.getOwnPropertyDescriptor(env, key);
if (!descriptor)
continue;
if (!("value" in descriptor)) {
throw new CredentialResolutionError(name, `${key} is accessor-backed; client configuration requires own data properties.`, [key]);
}
if (descriptor.value !== undefined && typeof descriptor.value !== "string") {
throw new CredentialResolutionError(name, `${key} must be a string data property.`, [key]);
}
snapshot[key] = descriptor.value;
}
if (ambient) {
Object.defineProperty(snapshot, AMBIENT_ENVIRONMENT, {
value: true,
enumerable: false,
writable: false,
configurable: false
});
}
return Object.freeze(snapshot);
}
function resolveCredential(name, env, options = {}) {
env = snapshotClientEnvironment(name, env);
const { apiKeyKeys } = clientTransportEnvKeys(name);
const diskPaths = credentialDiskSources(name, env);
if (options.apiKey !== undefined) {
const explicitKey = options.apiKey.trim();
if (!explicitKey) {
throw new CredentialResolutionError(name, "The explicit apiKey argument is blank; an explicit credential never falls through to another identity.", ["explicit apiKey argument"]);
}
assertUsableCredential(name, "the explicit apiKey argument", explicitKey);
return sealCredential({
apiKey: explicitKey,
tier: "argument",
source: "explicit apiKey argument",
deliberate: true,
diskCandidates: diskPaths,
warning: null
});
}
const overrideKeyName = credentialOverrideEnvKey(name);
const overrideRaw = Object.prototype.hasOwnProperty.call(env, overrideKeyName) ? env[overrideKeyName] : undefined;
if (overrideRaw !== undefined) {
const override = overrideRaw.trim();
if (!override) {
throw new CredentialResolutionError(name, `${overrideKeyName} is set but empty. It is a deliberate override, so it is not resolved around: ` + `either give it a real key or unset it to fall back to the credential on disk.`, [overrideKeyName]);
}
assertUsableCredential(name, overrideKeyName, override);
return sealCredential({
apiKey: override,
tier: "override",
source: overrideKeyName,
deliberate: true,
diskCandidates: diskPaths,
warning: null
});
}
const pointerKeyName = credentialPointerEnvKey(name);
const pointerRaw = Object.prototype.hasOwnProperty.call(env, pointerKeyName) ? env[pointerKeyName] : undefined;
if (pointerRaw !== undefined) {
const pointer = pointerRaw.trim();
if (!pointer) {
throw new CredentialResolutionError(name, `${pointerKeyName} is set but empty. It is a deliberate vault pointer, so it is not resolved around: ` + `either give it a vault item key or unset it to fall back to the credential on disk.`, [pointerKeyName]);
}
if (!VAULT_POINTER_SHAPE.test(pointer)) {
throw new CredentialResolutionError(name, `${pointerKeyName} must name a vault ITEM KEY (a path-shaped reference like ` + `'namespace/app/live/api_key'), not a credential value. A pointer that carries a literal is refused.`, [pointerKeyName]);
}
return sealCredential({
apiKey: "",
pointerVaultKey: pointer,
tier: "pointer",
source: pointerKeyName,
deliberate: true,
diskCandidates: diskPaths,
warning: null
});
}
if (options.profile !== undefined && !options.profile.trim()) {
throw new CredentialResolutionError(name, "The explicit profile argument is blank; an explicit identity selection never falls through.", ["explicit profile argument"]);
}
const profileRaw = Object.prototype.hasOwnProperty.call(env, CREDENTIAL_PROFILE_ENV_KEY) ? env[CREDENTIAL_PROFILE_ENV_KEY] : undefined;
if (profileRaw !== undefined && !profileRaw.trim()) {
throw new CredentialResolutionError(name, `${CREDENTIAL_PROFILE_ENV_KEY} is set but blank.`, [CREDENTIAL_PROFILE_ENV_KEY]);
}
const profile = options.profile?.trim() || profileRaw?.trim();
if (profile) {
const profileSource = options.profile?.trim() ? "explicit profile argument" : CREDENTIAL_PROFILE_ENV_KEY;
if (!SAFE_PROFILE.test(profile)) {
throw new CredentialResolutionError(name, `Profile name from ${profileSource} is not usable in a path. ` + `Use letters, digits, dot, dash, or underscore.`, [profileSource]);
}
const paths = profileDiskSources(name, env, profile);
for (const path of paths) {
const value = readCredentialFile(path, apiKeyKeys, pointerKeyName);
if (value) {
if (!value.pointerVaultKey)
assertUsableCredential(name, path, value.apiKey);
return sealCredential({
...value,
tier: value.pointerVaultKey ? "pointer" : "profile",
source: path,
deliberate: true,
diskCandidates: paths,
warning: null
});
}
}
throw new CredentialResolutionError(name, `Profile '${profile}' (from ${profileSource}) has no ${apiKeyKeys[0]} or ${pointerKeyName} for '${name}'. ` + `Looked in: ${paths.join(", ") || "<no HOME in this environment>"}. ` + `A profile names WHICH identity to use, so it is never resolved around \u2014 ` + `create the profile's credential file or unset ${CREDENTIAL_PROFILE_ENV_KEY}.`, paths);
}
const definedEnvEntries = apiKeyKeys.filter((key) => Object.prototype.hasOwnProperty.call(env, key) && env[key] !== undefined).map((key) => ({ key, value: String(env[key]).trim() }));
const blankEnv = definedEnvEntries.find((entry) => entry.value.length === 0);
if (blankEnv) {
throw new CredentialResolutionError(name, `${blankEnv.key} is set but blank; a declared credential never falls through to another alias or identity.`, [blankEnv.key]);
}
if (definedEnvEntries.length > 1 && new Set(definedEnvEntries.map((entry) => entry.value)).size > 1) {
throw new CredentialResolutionError(name, `${definedEnvEntries.map((entry) => entry.key).join(" and ")} disagree; credential aliases must be identical or only one may be set.`, definedEnvEntries.map((entry) => entry.key));
}
const envHit = firstEnvValue(env, apiKeyKeys);
const keychainHit = readKeychainItem(name, env, "api-key", options.keychain ?? {});
if (keychainHit) {
assertUsableCredential(name, keychainHit.source, keychainHit.value);
const warning = envHit && envHit.value !== keychainHit.value ? `Credential sources disagree for '${name}': ${keychainHit.source} and ${envHit.key} hold ` + `different keys. ${keychainHit.source} wins, because the Keychain is re-read on every call while ` + `an environment variable is a snapshot. Reconcile them \u2014 a rotation that updated only one leaves ` + `the other to fail 401 wherever it is loaded first.` : null;
return sealCredential({
apiKey: keychainHit.value,
tier: "keychain",
source: keychainHit.source,
deliberate: false,
diskCandidates: diskPaths,
warning
});
}
const diskSourceList = credentialDiskSourceList(name, env, null);
const diskHits = diskSourceList.map((src) => ({ src, value: readCredentialFile(src.path, apiKeyKeys, pointerKeyName) })).filter((hit) => hit.value !== null);
if (diskHits.length > 0) {
const winner = diskHits[0];
if (winner.value.pointerVaultKey) {
return sealCredential({
...winner.value,
tier: "pointer",
source: winner.src.path,
deliberate: false,
diskCandidates: diskPaths,
warning: null
});
}
assertUsableCredential(name, winner.src.path, winner.value.apiKey);
const divergentSources = [
...diskHits.slice(1).filter((hit) => hit.value.apiKey !== winner.value.apiKey || hit.value.pointerVaultKey !== winner.value.pointerVaultKey).map((hit) => hit.src.path),
...envHit && envHit.value !== winner.value.apiKey ? [envHit.key] : []
];
const warning = divergentSources.length > 0 ? `Credential sources disagree for '${name}': ${winner.src.path} and ` + `${divergentSources.join(", ")} hold different keys. ${winner.src.path} wins, because a file on ` + `disk is re-read on every call while an environment variable is a snapshot. Reconcile them \u2014 ` + `a rotation that updated only one leaves the other to fail 401 wherever it is loaded first.` : null;
return sealCredential({
apiKey: winner.value.apiKey,
tier: winner.src.tier,
source: winner.src.path,
deliberate: false,
diskCandidates: diskPaths,
warning
});
}
if (envHit) {
assertUsableCredential(name, envHit.key, envHit.value);
return sealCredential({
apiKey: envHit.value,
tier: "env",
source: envHit.key,
deliberate: false,
diskCandidates: diskPaths,
warning: null
});
}
return null;
}
var requireSecretsSdk = createRequire(import.meta.url);
async function completePointerCredential(name, pointerResolution, env = process.env) {
const secretsEnv = snapshotClientEnvironment("secrets", env);
const vaultKey = pointerResolution.pointerVaultKey;
const pointerEnvKey = pointerResolution.source;
if (!vaultKey) {
throw new CredentialResolutionError(name, `Pointer resolution from ${pointerEnvKey} carries no vault item key; this is a defect in the resolver.`, [pointerEnvKey]);
}
if (name === "secrets") {
throw new CredentialResolutionError(name, "The Secrets bootstrap credential cannot reference the same hosted vault; configure an independent bootstrap provider.", [pointerEnvKey]);
}
let secretsSdk;
try {
const sdkUrl = resolveInstalledSecrets(import.meta.url);
secretsSdk = requireSecretsSdk(fileURLToPath2(sdkUrl));
} catch {
throw new CredentialResolutionError(name, `${pointerEnvKey} names vault item '${vaultKey}', but the secrets SDK (@hasna/secrets) is not installed ` + `in this process. A vault pointer is TERMINAL: install @hasna/secrets to resolve it, or unset ${pointerEnvKey}.`, [pointerEnvKey]);
}
let client;
try {
const bootstrap = resolveCredential("secrets", secretsEnv);
if (!bootstrap || bootstrap.tier === "pointer") {
throw new CredentialResolutionError("secrets", "The Secrets vault requires an independent, non-reference bootstrap credential.", bootstrap ? [bootstrap.source] : []);
}
client = secretsSdk.createSecretsClientFromEnv(secretsEnv);
} catch {
throw new CredentialResolutionError(name, `${pointerEnvKey} names vault item '${vaultKey}', but the secrets client could not be configured from this ` + `environment (the secrets service URL and key env are missing or invalid). A vault pointer is TERMINAL and ` + `never falls through to a literal or disk credential.`, [pointerEnvKey]);
}
let secret;
try {
secret = await client.getSecret({ key: vaultKey });
} catch {
throw new CredentialResolutionError(name, `${pointerEnvKey} names vault item '${vaultKey}', but the vault could not be reached or the item is ` + `unavailable. A vault pointer is TERMINAL and never falls through to a literal or disk credential.`, [pointerEnvKey]);
}
const value = secret.value;
if (!value) {
throw new CredentialResolutionError(name, `${pointerEnvKey} resolved vault item '${vaultKey}', but it holds no value. A vault pointer is TERMINAL.`, [pointerEnvKey]);
}
assertUsableCredential(name, `${pointerEnvKey} -> vault:${vaultKey}`, value);
return sealCredential({
apiKey: value,
tier: "pointer",
source: `${pointerEnvKey} -> vault:${vaultKey}`,
deliberate: pointerResolution.deliberate,
diskCandidates: pointerResolution.diskCandidates,
warning: null
});
}
var DEFAULT_FLEET_GATEWAY_ORIGIN = "https://api.hasna.com";
var DEFAULT_AUTHORITY_SOURCE = "default";
function defaultFleetGatewayBaseUrl(name) {
return `${DEFAULT_FLEET_GATEWAY_ORIGIN}/${validateAppSlug(name)}`;
}
var ASCII_CONTROL_PATTERN = /[\u0000-\u001f\u007f]/;
var DNS_LABEL_PATTERN = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
function isValidDnsDomain(value) {
if (value.length === 0 || value.length > 253 || ASCII_CONTROL_PATTERN.test(value) || /[^\x00-\x7f]/.test(value)) {
return false;
}
return value.split(".").every((label) => label.length <= 63 && !label.startsWith("xn--") && DNS_LABEL_PATTERN.test(label));
}
function validateAppSlug(name) {
if (name.length > 63 || !DNS_LABEL_PATTERN.test(name)) {
throw new Error("App name must be one lowercase DNS label.");
}
return name;
}
function rawAuthority(value) {
const match = /^[a-z][a-z0-9+.-]*:\/\//i.exec(value);
if (!match)
throw new Error("API URL must be absolute.");
const afterScheme = value.slice(match[0].length);
const boundary = afterScheme.search(/[/?#]/);
const authority = boundary === -1 ? afterScheme : afterScheme.slice(0, boundary);
if (!authority)
throw new Error("API URL must include a hostname.");
return authority;
}
function assertCanonicalPort(port) {
if (!/^[0-9]+$/.test(port) || port.length > 1 && port.startsWith("0")) {
throw new Error("API URL authority must contain a canonical port between 1 and 65535.");
}
const numericPort = Number(port);
if (!Number.isSafeInteger(numericPort) || numericPort < 1 || numericPort > 65535) {
throw new Error("API URL authority must contain a canonical port between 1 and 65535.");
}
}
function canonicalAuthorityHostname(authority) {
let rawHostname;
if (authority.startsWith("[")) {
const closingBracket = authority.indexOf("]");
if (closingBracket === -1) {
throw new Error("API URL authority must contain a canonical hostname.");
}
rawHostname = authority.slice(0, closingBracket + 1);
const portSuffix = authority.slice(closingBracket + 1);
if (portSuffix) {
if (!portSuffix.startsWith(":")) {
throw new Error("API URL authority must contain a canonical hostname and port.");
}
assertCanonicalPort(portSuffix.slice(1));
}
if (isIP(rawHostname.slice(1, -1)) !== 6) {
throw new Error("API URL authority must contain a canonical IPv6 literal.");
}
} else {
const firstColon = authority.indexOf(":");
const lastColon = authority.lastIndexOf(":");
if (firstColon !== lastColon) {
throw new Error("IPv6 API URL authorities must use brackets.");
}
if (lastColon !== -1) {
const port = authority.slice(lastColon + 1);
assertCanonicalPort(port);
rawHostname = authority.slice(0, lastColon);
} else {
rawHostname = authority;
}
const ipVersion = isIP(rawHostname);
const numericAddressParts = rawHostname.split(".");
const looksLikeNonCanonicalIpv4 = numericAddressParts.every((part) => /^(?:0x[0-9a-f]+|[0-9]+)$/i.test(part));
if (ipVersion !== 4 && looksLikeNonCanonicalIpv4 || ipVersion !== 4 && !isValidDnsDomain(rawHostname.toLowerCase())) {
throw new Error("API URL authority must contain a canonical ASCII hostname.");
}
}
return rawHostname.toLowerCase();
}
function isDeliberateLoopbackHttpAuthority(authority) {
return /^(?:localhost|127\.0\.0\.1|\[::1\])(?::[0-9]+)?$/i.test(authority);
}
function toV1BaseUrl(apiUrl) {
if (ASCII_CONTROL_PATTERN.test(apiUrl)) {
throw new Error("API URL must not contain ASCII control characters.");
}
const input = apiUrl.trim();
const authority = rawAuthority(input);
if (authority.includes("@") || authority.includes("\\") || authority.includes("%") || /[^\x00-\x7f]/.test(authority)) {
throw new Error("API URL authority must be canonical ASCII without credentials.");
}
const canonicalHostname = canonicalAuthorityHostname(authority);
const url = new URL(input);
if (url.protocol !== "http:" && url.protocol !== "https:") {
throw new Error("API URL must use http or https.");
}
if (url.username || url.password) {
throw new Error("API URL must not include credentials.");
}
if (!url.hostname || url.hostname.endsWith(".")) {
throw new Error("API URL must include a canonical hostname.");
}
if (url.hostname.toLowerCase() !== canonicalHostname) {
throw new Error("API URL authority must not rely on parser hostname normalization.");
}
if (url.hostname.split(".").some((label) => label.toLowerCase().startsWith("xn--"))) {
throw new Error("API URL must not use IDN or punycode hostnames.");
}
if (url.protocol === "http:" && !isDeliberateLoopbackHttpAuthority(authority)) {
throw new Error("API URL may use http only for an exact loopback authority.");
}
if (url.search || url.hash) {
throw new Error("API URL must not include a query string or fragment.");
}
let path = url.pathname.replace(/\/+$/, "");
if (path.endsWith("/v1"))
path = path.slice(0, -"/v1".length);
url.pathname = `${path}/v1`;
return url.toString().replace(/\/+$/, "");
}
class ClientTransportConfigurationError extends Error {
appName;
sources;
constructor(appName, message, sources = []) {
super(message);
this.name = "ClientTransportConfigurationError";
this.appName = appName;
this.sources = Object.freeze([...sources]);
}
}
class ClientCredentialMissingError extends ClientTransportConfigurationError {
authorityConfigured;
constructor(name, message, sources, authorityConfigured) {
super(name, message, sources);
this.authorityConfigured = authorityConfigured;
this.name = "ClientCredentialMissingError";
}
}
function resolveClientAuthoritySnapshot(name, env = process.env, options = {}) {
env = snapshotClientEnvironment(name, env);
const keys = clientTransportEnvKeys(name);
const definedUrlEntries = keys.apiUrlKeys.filter((key) => Object.prototype.hasOwnProperty.call(env, key) && env[key] !== undefined).map((key) => ({ key, raw: String(env[key]) }));
const blankUrl = definedUrlEntries.find((entry) => entry.raw.trim().length === 0);
if (blankUrl) {
throw new ClientTransportConfigurationError(name, `${blankUrl.key} is set but blank; public clients require an explicit HTTPS API URL and never select local storage.`, [blankUrl.key]);
}
const controlledUrl = definedUrlEntries.find((entry) => ASCII_CONTROL_PATTERN.test(entry.raw));
if (controlledUrl) {
throw new ClientTransportConfigurationError(name, `${controlledUrl.key} contains ASCII control characters.`, [controlledUrl.key]);
}
const usableUrlEntries = definedUrlEntries.map((entry) => ({ key: entry.key, value: entry.raw.trim() }));
const normalizedAuthority = (entry) => {
try {
return toV1BaseUrl(entry.value);
} catch {
throw new ClientTransportConfigurationError(name, `Invalid API URL from ${entry.key}; use an absolute HTTPS URL or exact loopback HTTP authority without credentials, query or fragment.`, [entry.key]);
}
};
if (usableUrlEntries.length > 1 && new Set(usableUrlEntries.map(normalizedAuthority)).size > 1) {
throw new ClientTransportConfigurationError(name, `${usableUrlEntries.map((entry) => entry.key).join(" and ")} disagree; client authority aliases must select the same versioned API authority or only one may be set.`, usableUrlEntries.map((entry) => entry.key));
}
const envUrlHit = usableUrlEntries[0] ?? null;
const keychainUrlHit = keychainConfigValue(name, env, options.credentials?.keychain);
const profile = options.bindUnpairedCredentialsToFleet ? options.credentials?.profile?.trim() || env.HASNA_PROFILE?.trim() || null : null;
const diskConfigUrlHit = appConfigDiskValue(name, env, keys.apiUrlKeys, profile);
if (diskConfigUrlHit?.unusable) {
throw new ClientTransportConfigurationError(name, `${diskConfigUrlHit.key} in ${diskConfigUrlHit.path} is declared but blank or malformed; public clients require a valid HTTPS service authority.`, [diskConfigUrlHit.path]);
}
const urlCandidates = [
...envUrlHit ? [envUrlHit] : [],
...keychainUrlHit ? [{ key: keychainUrlHit.source, value: keychainUrlHit.value }] : [],
...diskConfigUrlHit ? [{ key: diskConfigUrlHit.path, value: diskConfigUrlHit.value.trim() }] : []
];
const configuredUrl = urlCandidates[0] ?? null;
const normalizedUrls = urlCandidates.map(normalizedAuthority);
const divergentUrls = urlCandidates.filter((_, index) => normalizedUrls[index] !== normalizedUrls[0]);
if (configuredUrl && divergentUrls.length > 0) {
throw new ClientTransportConfigurationError(name, `${configuredUrl.key} and ${divergentUrls.map((candidate) => candidate.key).join(" and ")} select different service authorities; refusing to send a credential written for one authority to the other.`, urlCandidates.map((candidate) => candidate.key));
}
if (configuredUrl && options.bindUnpairedCredentialsToFleet) {
try {
toV1BaseUrl(configuredUrl.value);
} catch (error) {
throw new ClientTransportConfigurationError(name, `Invalid API URL from ${configuredUrl.key}: ${error instanceof Error ? error.message : String(error)}`, [configuredUrl.key]);
}
}
return { keys, configuredUrl, envUrlHit, keychainUrlHit, diskConfigUrlHit };
}
function resolveClientTransportSnapshot(name, env = process.env, options = {}) {
env = snapshotClientEnvironment(name, env);
const { keys, configuredUrl, envUrlHit, keychainUrlHit, diskConfigUrlHit } = resolveClientAuthoritySnapshot(name, env, options);
const warnings = [];
if (configuredUrl && !envUrlHit) {
warnings.push(`No ${keys.apiUrlKeys[0]} in the environment; the server URL in ${configuredUrl.key} was used, so this client connects to the server. ` + `Keep that entry aligned with the intended service authority.`);
}
const credential = resolveCredential(name, env, options.credentials);
if (!credential) {
const diskHint = credentialDiskSourcesForMessage(name, env);
const lead = configuredUrl ? `${configuredUrl.key} selects the HTTP server for '${name}', but no API key could be resolved` : `${keys.apiUrlKeys[0]} is not set and no API key could be resolved for '${name}'; a credential is required before the default fleet gateway authority applies`;
warnings.push(`${lead}; refusing to create an unauthenticated client \u2014 public clients never fall back to SQLite or another local store. ` + `Looked in the Keychain (macOS only), then for a credential file at ${diskHint}, then for ${keys.apiKeyKeys[0]} in the environment.`);
const sources = [configuredUrl?.key ?? keys.apiUrlKeys[0]];
if (options.bindUnpairedCredentialsToFleet)
throw new ClientCredentialMissingError(name, warnings.join(" "), sources, configuredUrl !== null);
throw new ClientTransportConfigurationError(name, warnings.join(" "), sources);
}
if (credential.warning)
warnings.push(credential.warning);
let urlHit;
if (configuredUrl) {
urlHit = configuredUrl;
} else {
try {
urlHit = { key: DEFAULT_AUTHORITY_SOURCE, value: defaultFleetGatewayBaseUrl(name) };
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
throw new ClientTransportConfigurationError(name, `No ${keys.apiUrlKeys[0]} is configured and the default fleet gateway authority cannot be composed for '${name}': ${message}`, [keys.apiUrlKeys[0]]);
}
}
const apiUrlSource = urlHit.key;
let baseUrl;
try {
baseUrl = toV1BaseUrl(urlHit.value);
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
throw new ClientTransportConfigurationError(name, `Invalid API URL from ${apiUrlSource}: ${message}`, [apiUrlSource]);
}
if (options.bindUnpairedCredentialsToFleet && baseUrl !== toV1BaseUrl(defaultFleetGatewayBaseUrl(name))) {
const pairedDisk = diskConfigUrlHit?.path === credential.source && (credential.tier === "disk" || credential.tier === "profile" || credential.tier === "pointer");
const pairedKeychain = credential.tier === "keychain" && keychainUrlHit?.source === credential.source.replace(".api-key@", ".api-url@");
const deliberatePair = envUrlHit !== null && (credential.tier === "argument" || credential.tier === "override");
if (!pairedDisk && !pairedKeychain && !deliberatePair) {
throw new ClientTransportConfigurationError(name, "An unpaired legacy credential is bound to the fleet gateway. Configure a stored authority/credential pair or an explicit API key override for the intended authority; no credential was sent.");
}
}
return {
resolution: {
transport: "http",
transportSource: urlHit.key,
baseUrl,
apiUrlSource,
apiKeyPresent: true,
apiKeySource: credential.source,
apiKeyTier: credential.tier,
misconfigured: false,
warning: warnings.length > 0 ? warnings.join(" ") : null
},
credential
};
}
function resolveClientTransport(name, env = process.env, options = {}) {
return resolveClientTransportSnapshot(name, env, options).resolution;
}
function credentialDiskSourcesForMessage(name, env) {
const paths = credentialDiskSources(name, env);
return paths.length > 0 ? paths.join(" or ") : "<no HOME or HASNA_HOME set in this environment, so no credential file was consulted>";
}
class HasnaHttpError extends Error {
status;
method;
path;
credentialSource;
credentialTier;
constructor(method, path, status, body, credential) {
const guidance = credential ? `. ${credential.guidance}` : "";
super(`Hasna cloud request failed: ${method} ${path} -> ${status}${guidance}`);
this.name = "HasnaHttpError";
this.status = status;
this.method = method;
this.path = path;
Object.defineProperty(this, "body", {
value: body,
enumerable: status !== 401 && status !== 403,
writable: false,
configurable: false
});
this.credentialSource = credential?.source ?? null;
this.credentialTier = credential?.tier ?? null;
}
}
function currentCredential(name, apiKey) {
if (typeof apiKey === "function") {
return validateAndSealResolvedCredential(name, apiKey());
}
return explicitCredential(name, apiKey);
}
async function resolveRequestCredential(name, apiKey, env = process.env) {
const resolved = currentCredential(name, apiKey);
if (resolved.tier === "pointer") {
return completePointerCredential(name, resolved, env);
}
return resolved;
}
function authFailureGuidance(credential) {
const origin = `The API key for this request came from ${credential.source}`;
if (credential.deliberate) {
const remedy = credential.source === CALLER_SUPPLIED_CREDENTIAL_PROVIDER_SOURCE ? `Fix that provider so it returns the current key, or replace it with resolveCredential() ` + `so diagnostics can name the original source.` : `Rotate that key, or unset the override to use the credential on disk.`;
return `${origin} \u2014 a credential you selected deliberately. It was NOT substituted with any other key: ` + `falling back here would authenticate as a different principal than the one you named, which is ` + `exactly the failure an override exists to prevent. ${remedy}`;
}
if (credential.tier === "env") {
const target = credential.diskCandidates[0];
const remedy = target ? `Store the CURRENT key in the Keychain or write it to ${target} \u2014 both are re-read on every call, so ` + `rotations take effect immediately and in every shell. Do not simply unset ${credential.source}: ` + `nothing was found in the Keychain or on disk, so that would leave this client with no credential at all.` : `This environment has no HOME or HASNA_HOME, so no credential file could be consulted; the disk tier is ` + `unavailable here and there is nothing to fall back to. Set HOME, or supply the key explicitly.`;
return `${origin}, a variable in this process's environment. If a wrapper injected it for this one process, the ` + `wrapper re-reads its store on every invocation and the stored key itself is being rejected \u2014 rotate it. ` + `If this SHELL exported it, the export is a snapshot taken when the shell started: a STALE SHELL that ` + `exported the key before it was rotated keeps sending the old one until it exits. ${remedy}`;
}
if (credential.tier === "keychain") {
return `${origin}, which was re-read from the Keychain on this very call \u2014 so a stale shell is NOT the cause ` + `here. The stored item is genuinely being rejected: update it with the current key, or re-run the fleet ` + `key distribution so this machine gets the current key.`;
}
return `${origin}, which was re-read from disk on this very call \u2014 so a stale shell is NOT the cause here. ` + `The stored credential is genuinely being rejected: rotate it, or re-run the fleet key distribution ` + `so this machine gets the current key.`;
}
var DEFAULT_RETRY_STATUSES = [408, 425, 429, 500, 502, 503, 504];
var IDEMPOTENT_METHODS = new Set(["GET", "HEAD", "PUT", "DELETE", "OPTIONS"]);
var AUTHORITY_OVERRIDE_HEADERS = new Set([
"host",
":authority",
"forwarded",
"x-forwarded-host",
"x-original-host"
]);
function assertNoAuthorityOverrideHeaders(headers, source) {
if (!headers)
return;
const forbidden = Object.keys(headers).find((name) => AUTHORITY_OVERRIDE_HEADERS.has(name.trim().toLowerCase()));
if (forbidden) {
throw new Error(`Authenticated ${source} headers must not set authority header '${forbidden}'.`);
}
}
function appendQuery(path, query) {
if (!query)
return path;
const params = query instanceof URLSearchParams ? query : new URLSearchParams;
if (!(query instanceof URLSearchParams)) {
for (const [key, value] of Object.entries(query)) {
if (value === null || value === undefined)
continue;
if (Array.isArray(value)) {
for (const v of value)
params.append(key, String(v));
} else {
params.append(key, String(value));
}
}
}
const qs = params.toString();
if (!qs)
return path;
return `${path}${path.includes("?") ? "&" : "?"}${qs}`;
}
var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
function createHasnaHttpTransportInternal(options, requestBindingProvider) {
const fetchImpl = options.fetchImpl ?? ((input, init) => fetch(input, init));
const base = toV1BaseUrl(options.baseUrl);
const timeoutMs = options.timeoutMs ?? 30000;
const sleep = options.sleepImpl ?? defaultSleep;
const defaultRetry = options.retry;
function resolveRetry(callRetry) {
const chosen = callRetry !== undefined ? callRetry : defaultRetry;
if (chosen === false)
return null;
const r2 = chosen ?? {};
return {
retries: r2.retries ?? 2,
baseDelayMs: r2.baseDelayMs ?? 200,
maxDelayMs: r2.maxDelayMs ?? 2000,
retryStatuses: r2.retryStatuses ?? [...DEFAULT_RETRY_STATUSES]
};
}
async function once(method, rel, body, opts, bind) {
const materializeHeaders = (input) => Object.fromEntries(Object.entries(input ?? {}).map(([key, value]) => [key, String(value)]));
const transportHeaders = materializeHeaders(options.headers);
const requestHeaders = materializeHeaders(opts.headers);
assertNoAuthorityOverrideHeaders(transportHeaders, "transport");
assertNoAuthorityOverrideHeaders(requestHeaders, "request");
const headers = {
Accept: "application/json",
...transportHeaders,
...requestHeaders
};
const idempotencyKey = opts.idempotencyKey;
if (idempotencyKey)
headers["Idempotency-Key"] = String(idempotencyKey);
const init = {
method,
headers,
redirect: "manual"
};
if (body !== undefined) {
headers["Content-Type"] = "application/json";
init.body = JSON.stringify(body);
}
const controller = new AbortController;
const onAbort = () => controller.abort();
const callerSignal = opts.signal;
if (callerSignal) {
if (callerSignal.aborted)
controller.abort();
else
callerSignal.addEventListener("abort", onAbort, { once: true });
}
const timer = setTimeout(() => controller.abort(), opts.timeoutMs ?? timeoutMs);
init.signal = controller.signal;
let response;
let credential;
try {
const binding = bind();
credential = binding.credential;
init.headers = {
"x-api-key": credential.apiKey,
Authorization: `Bearer ${credential.apiKey}`,
...headers
};
try {
response = await fetchImpl(`${binding.baseUrl}${rel}`, init);
} catch (error) {
const err = error instanceof Error ? error : new Error(String(error));
if (callerSignal?.aborted)
return { ok: false, retryable: false, error: err };
return { ok: false, retryable: true, error: err };
}
} finally {
clearTimeout(timer);
if (callerSignal)
callerSignal.removeEventListener("abort", onAbort);
}
const authenticationFailure = response.status === 401 || response.status === 403;
let parsed = undefined;
if (authenticationFailure) {
try {
await response.body?.cancel();
} catch {}
} else {
const text = await response.text();
if (text.length > 0) {
try {
parsed = JSON.parse(text);
} catch {
parsed = text;
}
}
}
if (!response.ok) {
if (response.status >= 300 && response.status < 400) {
return {
ok: false,
retryable: false,
error: new HasnaHttpError(method, rel, response.status, parsed)
};
}
if (authenticationFailure) {
return {
ok: false,
retryable: false,
error: new HasnaHttpError(method, rel, response.status, undefined, {
source: credential.source,
tier: credential.tier,
guidance: authFailureGuidance(credential)
})
};
}
const retry = resolveRetry(opts.retry);
const retryable = retry ? retry.retryStatuses.includes(response.status) : false;
return { ok: false, retryable, error: new HasnaHttpError(method, rel, response.status, parsed) };
}
return { ok: true, value: parsed };
}
async function request(method, path, body, opts = {}) {
const upper = method.toUpperCase();
const rel = appendQuery(path.startsWith("/") ? path : `/${path}`, opts.query);
const retry = resolveRetry(opts.retry);
const methodRetryable = IDEMPOTENT_METHODS.has(upper) || Boolean(opts.idempotencyKey);
const maxAttempts = retry && methodRetryable ? retry.retries + 1 : 1;
let finalize;
if (requestBindingProvider) {
const prepared = requestBindingProvider();
finalize = typeof prepared === "function" ? prepared : await prepared;
} else {
const credential = await resolveRequestCredential(options.name, options.apiKey);
finalize = () => ({ baseUrl: base, credential });
}
let binding;
const bind = () => binding ??= finalize();
let last = null;
for (let attempt = 1;attempt <= maxAttempts; attempt++) {
const result = await once(upper, rel, body, opts, bind);
if (result.ok)
return result.value;
last = result;
const canRetry = retry !== null && methodRetryable && result.retryable && attempt < maxAttempts;
if (!canRetry)
break;
const backoff = Math.min(retry.maxDelayMs, retry.baseDelayMs * 2 ** (attempt - 1));
const jitter = Math.floor(Math.random() * (backoff / 2 + 1));
await sleep(backoff + jitter);
}
throw last.error;
}
return {
baseUrl: base,
request,
get: (path, opts) => request("GET", path, undefined, opts),
post: (path, body, opts) => request("POST", path, body, opts),
put: (path, body, opts) => request("PUT", path, body, opts),
patch: (path, body, opts) => request("PATCH", path, body, opts),
del: (path, body, opts) => request("DELETE", path, body, opts)
};
}
function createClientTransport(name, env = process.env, overrides) {
const credentialOptions = overrides?.credentials;
const snapshotOptions = {
...credentialOptions ? { credentials: credentialOptions } : {},
...overrides?.bindUnpairedCredentialsToFleet === undefined ? {} : { bindUnpairedCredentialsToFleet: overrides.bindUnpairedCredentialsToFleet }
};
const resolution = resolveClientTransportSnapshot(name, env, snapshotOptions).resolution;
const sameBinding = (left, right) => left.resolution.baseUrl === right.resolution.baseUrl && left.credential.apiKey === right.credential.apiKey && left.credential.pointerVaultKey === right.credential.pointerVaultKey && left.credential.source === right.credential.source && left.credential.tier === right.credential.tier;
const unstableConfiguration = () => new ClientTransportConfigurationError(name, "The configured service authority or credential changed while a request was being prepared; no authenticated request was sent.");
const assertPinnedAuthority = (snapshot) => {
if (snapshot.resolution.baseUrl !== resolution.baseUrl) {
throw new ClientTransportConfigurationError(name, "The configured service authority changed; rebuild the client before sending credentials.");
}
};
const requestBindingProvider = () => {
const first = resolveClientTransportSnapshot(name, env, snapshotOptions);
assertPinnedAuthority(first);
const finalize = (reviewed2, completed) => () => {
const final = resolveClientTransportSnapshot(name, env, snapshotOptions);
if (!sameBinding(reviewed2, final))
throw unstableConfiguration();
assertPinnedAuthority(final);
return {
baseUrl: final.resolution.baseUrl,
credential: completed ?? currentCredential(name, () => final.credential)
};
};
if (first.credential.tier !== "pointer")
return finalize(first);
const reviewed = resolveClientTransportSnapshot(name, env, snapshotOptions);
if (!sameBinding(first, reviewed))
throw unstableConfiguration();
assertPinnedAuthority(reviewed);
return resolveRequestCredential(name, () => reviewed.credential, env).then((credential) => finalize(reviewed, credential));
};
return {
transport: "http",
client: createHasnaHttpTransportInternal({
name,
baseUrl: resolution.baseUrl,
apiKey: () => {
throw new Error("The authenticated request binding provider was not invoked.");
},
...overrides?.fetchImpl ? { fetchImpl: overrides.fetchImpl } : {},
...overrides?.headers ? { headers: overrides.headers } : {},
...overrides?.timeoutMs ? { timeoutMs: overrides.timeoutMs } : {},
...overrides?.retry !== undefined ? { retry: overrides.retry } : {},
...overrides?.sleepImpl ? { sleepImpl: overrides.sleepImpl } : {}
}, requestBindingProvider),
resolution
};
}
// ../contracts/dist/client/storage.js
import { createRequire as createRequire2 } from "module";
var MAX_PACKAGE_BYTES2 = 1024 * 1024;
var MAX_CREDENTIAL_FILE_BYTES2 = 64 * 1024;
var INSPECT_CUSTOM2 = Symbol.for("nodejs.util.inspect.custom");
var CREDENTIAL_SEAL2 = Symbol.for("hasna:contracts:sealedCredential");
var AMBIENT_ENVIRONMENT2 = Symbol.for("hasna:contracts:ambientClientEnvironment");
var requireSecretsSdk2 = createRequire2(import.meta.url);
var IDEMPOTENT_METHODS2 = new Set(["GET", "HEAD", "PUT", "DELETE", "OPTIONS"]);
var AUTHORITY_OVERRIDE_HEADERS2 = new Set([
"host",
":authority",
"forwarded",
"x-forwarded-host",
"x-original-host"
]);
function resourcePath(resource) {
const trimmed = resource.replace(/^\/+|\/+$/g, "");
if (!trimmed)
throw new Error("resource must be a non-empty path segment");
return `/${trimmed}`;
}
function entityPath(resource, id) {
if (id === undefined || id === null || `${id}`.length === 0) {
throw new Error("id must be a non-empty string");
}
return `${resourcePath(resource)}/${encodeURIComponent(String(id))}`;
}
function newIdempotencyKey() {
const g = globalThis;
if (g.crypto?.randomUUID)
return g.crypto.randomUUID();
return `idmp_${Date.now().toString(36)}_${Math.random().toString(36).slice(2, 12)}`;
}
function extractItems(raw) {
if (Array.isArray(raw))
return raw;
if (raw && typeof raw === "object") {
const obj = raw;
for (const key of ["items", "data", "results", "rows", "records"]) {
if (Array.isArray(obj[key]))
return obj[key];
}
}
return [];
}
function extractTotal(raw) {
if (raw && typeof raw === "object") {
const obj = raw;
for (const key of ["total", "count", "totalCount", "total_count"]) {
if (typeof obj[key] === "number")
return obj[key];
}
}
return null;
}
function extractCursor(raw) {
if (raw && typeof raw === "object") {
const obj = raw;
for (const key of ["cursor", "nextCursor", "next_cursor", "next"]) {
if (typeof obj[key] === "string")
return obj[key];
}
}
return null;
}
function isNotFoundHttpError(error) {
return typeof error === "object" && error !== null && error.name === "HasnaHttpError" && error.status === 404;
}
function createHasnaStorageClient(name, transport) {
return {
name,
baseUrl: transport.baseUrl,
transport,
async list(resource, options = {}) {
const raw = await transport.get(resourcePath(resource), options);
return {
items: extractItems(raw),
total: extractTotal(raw),
cursor: extractCursor(raw),
raw
};
},
async get(resource, id, options = {}) {
try {
return await transport.get(entityPath(resource, id), options);
} catch (error) {
if (isNotFoundHttpError(error))
return null;
throw error;
}
},
async create(resource, body, options = {}) {
const { idempotencyKey, ...rest } = options;
return transport.post(resourcePath(resource), body, {
...rest,
idempotencyKey: idempotencyKey ?? newIdempotencyKey()
});
},
async update(resource, id, patch, options = {}) {
const { method = "PATCH", idempotencyKey, ...rest } = options;
const call = method === "PUT" ? transport.put : transport.patch;
return call(entityPath(resource, id), patch, { ...rest, ...idempotencyKey ? { idempotencyKey } : {} });
},
async delete(resource, id, options = {}) {
try {
await transport.del(entityPath(resource, id), undefined, options);
} catch (error) {
if (isNotFoundHttpError(error))
return;
throw error;
}
}
};
}
// src/lib/client-storage-policy.ts
var LOCAL_PATH_VARS = [
"HASNA_DOMAINS_DB_PATH",
"DOMAINS_DB_PATH",
"HASNA_DOMAINS_DIR",
"DOMAINS_DIR"
];
function explicitLocalPathVar(env = process.env) {
return LOCAL_PATH_VARS.find((key) => (env[key] ?? "").trim() !== "");
}
function domainsAuthorityEnvKeys() {
const keys = clientTransportEnvKeys("domains");
return [
...keys.apiUrlKeys,
...keys.apiKeyKeys,
credentialOverrideEnvKey("domains"),
credentialPointerEnvKey("domains"),
CREDENTIAL_PROFILE_ENV_KEY
];
}
function assertDomainsClientStorage(env = process.env) {
const pathVar = explicitLocalPathVar(env);
if (pathVar)
throw new Error(`domains: ${pathVar} is no longer supported by clients. Unset local database path variables and configure the shared API with HASNA_DOMAINS_API_KEY or saved credentials. Preserve any existing database until its records have been migrated and verified.`);
}
// src/lib/domains-resolver.ts
var DOMAINS_APP_NAME = "domains";
var CONTRACTS_AMBIENT_ENVIRONMENT = Symbol.for("hasna:contracts:ambientClientEnvironment");
function isAmbientEnv(env) {
if (typeof process !== "undefined" && env === process.env)
return true;
return env[CONTRACTS_AMBIENT_ENVIRONMENT] === true;
}
function domainsResolverEnv(env) {
const blanks = domainsAuthorityEnvKeys().filter((key) => (key in env) && (env[key] ?? "").trim() === "");
if (blanks.length === 0)
return env;
const next = { ...env };
for (const key of blanks)
delete next[key];
return next;
}
function domainsResolverInputs(env, credentials = {}) {
assertDomainsClientStorage(env);
const normalised = domainsResolverEnv(env);
if (normalised === env)
return { env: normalised, credentials };
const keychain = { ...credentials.keychain };
if (keychain.enabled === undefined && keychain.run === undefined) {
keychain.enabled = isAmbientEnv(env);
}
return { env: normalised, credentials: { ...credentials, keychain } };
}
function resolveDomainsTransport(env = process.env, options = {}) {
const inputs = domainsResolverInputs(env, options.credentials ?? {});
return resolveDomainsTransportWithInputs(inputs.env, inputs.credentials);
}
function resolveDomainsTransportWithInputs(env, credentials) {
try {
const resolution = resolveClientTransport(DOMAINS_APP_NAME, env, { credentials });
const credential = resolveCredential(DOMAINS_APP_NAME, env, credentials);
if (!credential) {
throw new Error(`domains: no API key resolved from any credential tier; refusing to build an unauthenticated client.`);
}
return {
report: {
transport: "http",
baseUrl: resolution.baseUrl,
apiUrlSource: resolution.apiUrlSource ?? "default",
apiKeySource: credential.source,
apiKeyTier: credential.tier
},
credential
};
} catch (error) {
if (error instanceof ClientTransportConfigurationError) {
throw new Error(`domains fails closed: ${error.message}`);
}
throw error;
}
}
function resolveDomainsHttpClient(env = process.env, options = {}) {
const inputs = domainsResolverInputs(env, options.credentials ?? {});
try {
const wired = createClientTransport(DOMAINS_APP_NAME, inputs.env, {
...Object.keys(inputs.credentials).length > 0 ? { credentials: inputs.credentials } : {}
});
return {
transport: "http",
client: createHasnaStorageClient(DOMAINS_APP_NAME, wired.client),
resolution: wired.resolution
};
} catch (error) {
if (error instanceof ClientTransportConfigurationError) {
throw new Error(`domains fails closed: ${error.message}`);
}
throw error;
}
}
// src/db/store.ts
var DOMAINS_PAGE_SIZE = 1000;
function q(params) {
const out = {};
for (const [k, v] of Object.entries(params))
if (v !== undefined && v !== null && v !== "")
out[k] = v;
return out;
}
function enc(id) {
return encodeURIComponent(id);
}
class ApiStore {
client;
transport = "http";
constructor(client) {
this.client = client;
}
get http() {
return this.client.transport;
}
async createDomain(input) {
return this.client.create("domains", input);
}
async getDomain(id) {
return this.client.get("domains", id);
}
async getDomainByName(name) {
const matches = await this.listDomains({ search: name });
return matches.find((d) => d.name === name) ?? null;
}
async getDomainByIdentifier(identifier) {
const byId = await this.client.get("domains", identifier);
if (byId)
return byId;
return this.getDomainByName(identifier);
}
async getDomainDetails(identifier) {
const domain = await this.getDomainByIdentifier(identifier);
if (!domain)
return null;
const [offers, emails] = await Promise.all([
this.listDomainOffers(domain.id),
this.listDomainEmailLinks(domain.id)
]);
return { domain, offers, emails };
}
async listDomains(options = {}) {
const needsClientFilter = options.registrar !== undefined || options.is_premium !== undefined;
if (!needsClientFilter && typeof options.limit === "number" && options.limit <= DOMAINS_PAGE_SIZE) {
const result = await this.client.list("domains", {
query: q({
search: options.search,
status: options.status,
limit: options.limit,
offset: options.offset
})
});
const raw = result.raw;
return raw?.domains ?? result.items;
}
let items = await this.listAllDomains(q({ search: options.search, status: options.status }));
if (options.registrar !== undefined)
items = items.filter((d) => d.registrar === options.registrar);
if (options.is_premium !== undefined)
items = items.filter((d) => d.is_premium === options.is_premium);
const offset = options.offset ?? 0;
if (offset > 0)
items = items.slice(offset);
if (typeof options.limit === "number")
items = items.slice(0, options.limit);
return items;
}
async listAllDomains(serverQuery) {
const acc = [];
let offset = 0;
for (;; ) {
const result = await this.client.list("domains", {
query: { ...serverQuery, limit: DOMAINS_PAGE_SIZE, offset }
});
const raw = result.raw;
const page = raw?.domains ?? result.items;
acc.push(...page);
if (page.length < DOMAINS_PAGE_SIZE)
break;
offset += DOMAINS_PAGE_SIZE;
}
return acc;
}
async updateDomain(id, input) {
const existing = await this.client.get("domains", id);
if (!existing)
return null;
return this.client.update("domains", id, input);
}
async deleteDomain(id) {
const existing = await this.client.get("domains", id);
if (!existing)
return false;
await this.client.delete("domains", id);
return true;
}
async countDomains() {
return (await this.getDomainStats()).total;
}
async searchDomains(query) {
return this.listDomains({ search: query });
}
async getByRegistrar(registrar) {
return this.listDomains({ registrar });
}
async listExpiring(days, options = {}) {
const includeLapsed = options.includeLapsed ?? true;
const now = Date.now();
const horizon = now + days * 24 * 60 * 60 * 1000;
const domains = await this.listDomains({ status: "active" });
return domains.filter((d) => {
if (!d.expires_at)
return false;
const exp = Date.parse(d.expires_at);
if (!Number.isFinite(exp))
return false;
if (exp > horizon)
return false;
return includeLapsed ? true : exp >= now;
}).sort((a, b) => Date.parse(a.expires_at ?? "") - Date.parse(b.expires_at ?? ""));
}
async listSslExpiring(days, options = {}) {
const includeLapsed = options.includeLapsed ?? true;
const now = Date.now();
const horizon = now + days * 24 * 60 * 60 * 1000;
const domains = await this.listDomains({});
return domains.filter((d) => {
if (!d.ssl_expires_at)
return false;
const exp = Date.parse(d.ssl_expires_at);
if (!Number.isFinite(exp))
return false;
if (exp > horizon)
return false;
return includeLapsed ? true : exp >= now;
}).sort((a, b) => Date.parse(a.ssl_expires_at ?? "") - Date.parse(b.ssl_expires_at ?? ""));
}
async listPastExpiry() {
const now = Date.now();
const domains = await this.listDomains({ status: "active" });
return domains.filter((d) => {
if (!d.expires_at)
return false;
const exp = Date.parse(d.expires_at);
return Number.isFinite(exp) && exp < now;
}).sort((a, b) => Date.parse(a.expires_at ?? "") - Date.parse(b.expires_at ?? ""));
}
async listSslPastExpiry() {
const now = Date.now();
const domains = await this.listDomains({});
return domains.filter((d) => {
if (!d.ssl_expires_at)
return false;
const exp = Date.parse(d.ssl_expires_at);
return Number.isFinite(exp) && exp < now;
}).sort((a, b) => Date.parse(a.ssl_expires_at ?? "") - Date.parse(b.ssl_expires_at ?? ""));
}
async getDomainStats() {
const result = await this.client.list("stats");
return result.raw;
}
async markDomainPremium(identifier, premiumPrice, standardPrice) {
const domain = await this.getDomainByIdentifier(identifier);
if (!domain)
return null;
return this.updateDomain(domain.id, {
is_premium: true,
premium_price: premiumPrice,
standard_price: standardPrice ?? domain.standard_price,
status: domain.status === "discovered" ? "premium_only" : domain.status
});
}
async updateDomainLifecycleStatus(identifier, status, notes) {
const domain = await this.getDomainByIdentifier(identifier);
if (!domain)
return null;
return this.updateDomain(domain.id, { status, notes: notes ?? domain.notes ?? undefined });
}
async recordDomainPurchase(identifier, input) {
const domain = await this.getDomainByIdentifier(identifier);
if (!domain)
return null;
return this.updateDomain(domain.id, {
registrar: input.registrar,
status: "purchased",
purchase_price: input.price,
purchase_date: input.purchase_date ?? new Date().toISOString(),
expires_at: input.expires_at ?? domain.expires_at ?? undefined,
auto_renew: input.auto_renew ?? domain.auto_renew,
standard_price: input.standard_price ?? domain.standard_price,
notes: input.notes ?? domain.notes ?? undefined
});
}
async createDomainOffer(input) {
const { domain_id, ...body } = input;
return this.http.post(`/domains/${enc(domain_id)}/offers`, body);
}
async getDomainOffer(id) {
return this.http.get(`/offers/${enc(id)}`).catch(() => null);
}
async listDomainOffers(domainId) {
const res = await this.http.get(`/domains/${enc(domainId)}/offers`);
return res.offers ?? [];
}
async linkDomainEmail(input) {
const { domain_id, ...body } = input;
return this.http.post(`/domains/${enc(domain_id)}/emails`, body);
}
async getDomainEmailLink(id) {
return this.http.get(`/emails/${enc(id)}`).catch(() => null);
}
async listDomainEmailLinks(domainId) {
const res = await this.http.get(`/domains/${enc(domainId)}/emails`);
return res.emails ?? [];
}
async createDnsRecord(input) {
const { domain_id, ...body } = input;
return this.http.post(`/domains/${enc(domain_id)}/dns`, body);
}
async getDnsRecord(id) {
return this.client.get("dns", id);
}
async listDnsRecords(domainId, type) {
const res = await this.http.get(`/domains/${enc(domainId)}/dns`, { query: q({ type }) });
return res.records ?? [];
}
async updateDnsRecord(id, input) {
const existing = await this.getDnsRecord(id);
if (!existing)
return null;
return this.client.update("dns", id, input);
}
async deleteDnsRecord(id) {
const existing = await this.getDnsRecord(id);
if (!existing)
return false;
await this.client.delete("dns", id);
return true;
}
async createAlert(input) {
const { domain_id, ...body } = input;
return this.http.post(`/domains/${enc(domain_id)}/alerts`, body);
}
async getAlert(id) {
return this.client.get("alerts", id);
}
async listAlerts(domainId) {
const res = await this.http.get(`/domains/${enc(domainId)}/alerts`);
return res.alerts ?? [];
}
async deleteAlert(id) {
const existing = await this.getAlert(id);
if (!existing)
return false;
await this.client.delete("alerts", id);
return true;
}
async createDomainOwner(input) {
const { domain_id, ...body } = input;
return this.http.post(`/domains/${enc(domain_id)}/owners`, body);
}
async getDomainOwner(id) {
return this.client.get("owners", id);
}
async getDomainOwnerByDomain(domainId) {
const res = await this.http.get(`/domains/${enc(domainId)}/owners`);
return res.owners?.[0] ?? null;
}
async getDomainOwnerByDomainName(domainName) {
const domain = await this.getDomainByName(domainName);
if (!domain)
return null;
return this.getDomainOwnerByDomain(domain.id);
}
async listDomainOwners(options = {}) {
const res = await this.client.list("owners", {
query: q({ search: options.search, source: options.source, verified: options.verified })
});
const raw = res.raw;
return raw?.owners ?? res.items;
}
async updateDomainOwner(id, input) {
const existing = await this.getDomainOwner(id);
if (!existing)
return null;
return this.client.update("owners", id, input);
}
async deleteDomainOwner(id) {
const existing = await this.getDomainOwner(id);
if (!existing)
return false;
await this.client.delete("owners", id);
return true;
}
async listDomainsWithOwners() {
const res = await this.http.get(`/owners-portfolio`);
return res.domains ?? [];
}
async createHistoryEntry(input) {
const { domain_id, ...body } = input;
return this.http.post(`/domains/${enc(domain_id)}/history`, body);
}
async getHistoryEntry(id) {
return this.client.get("history", id);
}
async getHistoryByDomain(domainId, options) {
const res = await this.http.get(`/domains/${enc(domainId)}/history`, {
query: q({ type: options?.type, limit: options?.limit })
});
return res.history ?? [];
}
async getLatestSnapshot(domainId, type) {
const list = await this.getHistoryByDomain(domainId, { type, limit: 1 });
return list[0] ?? null;
}
async getHistoryByDateRange(startDate, endDate, domainId) {
const res = await this.http.get(`/history`, {
query: q({ start: startDate, end: endDate, domain: domainId })
});
return res.history ?? [];
}
async listDomainsWithHistoryChanges() {
const res = await this.http.get(`/history-changes`);
return res.domains ?? [];
}
async deleteHistoryEntry(id) {
const existing = await this.getHistoryEntry(id);
if (!existing)
return false;
await this.client.delete("history", id);
return true;
}
async deleteHistoryByDomain(domainId) {
const res = await this.http.del(`/domains/${enc(domainId)}/history`);
return Boolean(res.deleted);
}
async upsertDomainReputation(input) {
const { domain_id, ...body } = input;
return this.http.put(`/domains/${enc(domain_id)}/reputation`, body);
}
async getDomainReputation(domainId) {
return this.http.get(`/domains/${enc(domainId)}/reputation`).catch(() => null);
}
async getDomainReputationByName(domainName) {
const domain = await this.getDomainByName(domainName);
if (!domain)
return null;
return this.getDomainReputation(domain.id);
}
async updateDomainReputation(id, input) {
return this.client.update("reputation", id, input);
}
async listBlacklistedDomains() {
const res = await this.client.list("reputation", { query: { blacklisted: true } });
const raw = res.raw;
return raw?.reputation ?? res.items;
}
async listHighThreatDomains(threshold = 70) {
const res = await this.client.list("reputation", { query: { threshold } });
const raw = res.raw;
return raw?.reputation ?? res.items;
}
async deleteDomainReputation(id) {
await this.client.delete("reputation", id);
return true;
}
}
function getStore(env = process.env, options = {}) {
assertDomainsClientStorage(env);
const wired = resolveDomainsHttpClient(env, {
...options.credentials ? { credentials: options.credentials } : {}
});
return new ApiStore(wired.client);
}
function getStoreResolution(env = process.env, options = {}) {
assertDomainsClientStorage(env);
const { report } = resolveDomainsTransport(env, {
...options.credentials ? { credentials: options.credentials } : {}
});
return {
transport: "http",
localPathVar: null,
baseUrl: report.baseUrl,
apiUrlSource: report.apiUrlSource,
apiKeySource: report.apiKeySource,
apiKeyTier: report.apiKeyTier
};
}
// src/lib/app-home.ts
import { homedir } from "os";
import { join as join3, resolve } from "path";
var APP = "domains";
function effectiveHome(env = process.env) {
return env["HOME"] || env["USERPROFILE"] || homedir();
}
function exactAppOverride(env = process.env) {
const override = env["HASNA_DOMAINS_HOME"] ?? env["HASNA_DOMAINS_DIR"] ?? env["DOMAINS_HOME"] ?? env["DOMAINS_DIR"];
return override && override.trim() ? override.trim() : undefined;
}
function appDataHome(env = process.env) {
const override = exactAppOverride(env);
if (override)
return resolve(override);
const hasnaHome = env["HASNA_HOME"]?.trim();
if (hasnaHome)
return resolve(join3(hasnaHome, APP));
return resolve(join3(effectiveHome(env), ".hasna", APP));
}
function getDefaultConfigPath(env = process.env) {
return join3(appDataHome(env), "config.json");
}
// src/db/domain-records.ts
var DOMAIN_STATUSES = [
"discovered",
"researching",
"offered",
"negotiating",
"purchased",
"active",
"not_available",
"premium_only",
"declined",
"expired",
"transferring",
"redemption"
];
var DOMAIN_OFFER_STATUSES = ["pending", "accepted", "rejected", "countered"];
var DOMAIN_EMAIL_TYPES = [
"inquiry",
"offer",
"counter_offer",
"confirmation",
"renewal_notice",
"transfer"
];
// src/db/dns-tools.ts
import { execFileSync } from "child_process";
import { domainToASCII } from "url";
// src/lib/version.ts
import { readFileSync as readFileSync3 } from "fs";
import { dirname as dirname2, resolve as resolve2 } from "path";
import { fileURLToPath as fileURLToPath3 } from "url";
var cachedVersion = null;
function getPackageVersion() {
if (cachedVersion)
return cachedVersion;
try {
const moduleDir = dirname2(fileURLToPath3(import.meta.url));
const packageJsonPath = resolve2(moduleDir, "../../package.json");
const pkg = JSON.parse(readFileSync3(packageJsonPath, "utf8"));
cachedVersion = pkg.version ?? "0.0.0";
} catch {
cachedVersion = "0.0.0";
}
return cachedVersion;
}
var USER_AGENT = `open-domains/${getPackageVersion()}`;
// src/db/dns-tools.ts
class DnsToolValidationError extends Error {
constructor(message) {
super(message);
this.name = "DnsToolValidationError";
}
}
var HOSTNAME_LABEL_RE = /^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/;
var DNS_QUERY_LABEL_RE = /^(?:\*|[a-z0-9_](?:[a-z0-9_-]{0,61}[a-z0-9_])?)$/;
var DNS_RECORD_TYPES = new Set([
"A",
"AAAA",
"CAA",
"CNAME",
"DNSKEY",
"DS",
"HTTPS",
"MX",
"NAPTR",
"NS",
"PTR",
"SOA",
"SPF",
"SRV",
"SSHFP",
"SVCB",
"TLSA",
"TXT"
]);
function normalizeDnsName(value, options) {
if (typeof value !== "string") {
throw new DnsToolValidationError("Invalid domain name. Use a hostname such as example.com.");
}
const ascii = domainToASCII(value.trim().replace(/\.$/, ""));
const labelRe = options.allowUnderscore ? DNS_QUERY_LABEL_RE : HOSTNAME_LABEL_RE;
if (!ascii || ascii.length > 253) {
throw new DnsToolValidationError("Invalid domain name. Use a hostname such as example.com.");
}
const normalized = ascii.toLowerCase();
const labels = normalized.split(".");
if (labels.length < 2) {
throw new DnsToolValidationError("Invalid domain name. Use a hostname such as example.com.");
}
for (const [index, label] of labels.entries()) {
if (!labelRe.test(label)) {
throw new DnsToolValidationError("Invalid domain name. Use a hostname such as example.com.");
}
if (label === "*" && (!options.allowWildcard || index !== 0)) {
throw new DnsToolValidationError("Invalid domain name. Use a hostname such as example.com.");
}
}
return normalized;
}
function normalizeDomainName(value) {
return normalizeDnsName(value, { allowUnderscore: false, allowWildcard: false });
}
function normalizeDnsQueryName(value) {
return normalizeDnsName(value, { allowUnderscore: true, allowWildcard: true });
}
function normalizeDnsRecordType(value) {
if (typeof value !== "string") {
throw new DnsToolValidationError("Invalid DNS record type.");
}
const recordType = value.trim().toUpperCase();
if (!DNS_RECORD_TYPES.has(recordType)) {
throw new DnsToolValidationError("Invalid DNS record type.");
}
return recordType;
}
function getVcardPropertyValue(entry) {
return entry.length >= 4 ? entry[3] : entry[2];
}
async function rdapLookup(domainName) {
const domain = normalizeDomainName(domainName);
const url = `https://rdap.org/domain/${encodeURIComponent(domain)}`;
const response = await fetch(url, {
signal: AbortSignal.timeout(15000),
headers: {
Accept: "application/rdap+json, application/json",
"User-Agent": USER_AGENT
}
});
if (!response.ok) {
if (response.status === 404) {
throw new Error(`RDAP: domain "${domain}" not found`);
}
throw new Error(`RDAP request failed with status ${response.status} for ${domain}`);
}
return response.json();
}
function extractRegistrantFromRdap(rdap) {
const result = {
name: null,
email: null,
phone: null,
organization: null
};
if (!rdap.entities)
return result;
const findRegistrant = (entities) => {
for (const entity of entities) {
if (entity.roles?.some((r) => r === "registrant"))
return entity;
if (entity.entities) {
const found = findRegistrant(entity.entities);
if (found)
return found;
}
}
return null;
};
const registrant = findRegistrant(rdap.entities);
if (!registrant?.vcardArray)
return result;
const vcard = registrant.vcardArray[1];
if (!vcard || !Array.isArray(vcard))
return result;
for (const entry of vcard) {
if (!Array.isArray(entry) || entry.length < 3)
continue;
const [prop] = entry;
const value = getVcardPropertyValue(entry);
if (prop === "fn")
result.name = typeof value === "string" ? value : null;
else if (prop === "email")
result.email = typeof value === "string" ? value : null;
else if (prop === "tel")
result.phone = typeof value === "string" ? value : null;
else if (prop === "org") {
const organization = Array.isArray(value) ? value[0] : value;
result.organization = typeof organization === "string" ? organization : null;
} else if (prop === "n" && !result.name) {
const parts = Array.isArray(value) ? value.filter((part) => typeof part === "string" && part.length > 0) : typeof value === "string" ? [value] : [];
result.name = parts.reverse().join(" ").trim() || null;
}
}
if (!result.name && registrant.handle) {
result.name = registrant.handle;
}
return result;
}
function extractRegistrarFromRdap(rdap) {
if (!rdap.entities)
return null;
for (const entity of rdap.entities) {
if (entity.roles?.some((r) => r === "registrar" || r === "sponsor")) {
if (entity.vcardArray?.[1]) {
const vcard = entity.vcardArray[1];
for (const entry of vcard) {
if (Array.isArray(entry) && entry[0] === "fn") {
const value = getVcardPropertyValue(entry);
return typeof value === "string" ? value : null;
}
}
}
if (entity.remarks) {
for (const remark of entity.remarks) {
if (remark.title?.toLowerCase().includes("registrar")) {
const desc = Array.isArray(remark.description) ? remark.description[0] : remark.description;
if (desc)
return desc;
}
}
}
return entity.handle ?? null;
}
}
return null;
}
function extractExpiryFromRdap(rdap) {
if (!rdap.events)
return null;
const expiryEvent = rdap.events.find((e) => e.eventAction === "expiration" || e.eventAction === "expiry");
return expiryEvent?.eventDate ?? null;
}
function extractNameserversFromRdap(rdap) {
if (!rdap.nameservers)
return [];
return rdap.nameservers.map((ns) => (ns.ldhName ?? ns.unicodeName ?? "").toLowerCase()).filter(Boolean);
}
async function whoisLookup(domainName) {
const domain = normalizeDomainName(domainName);
try {
return await rdapWhoisLookup(domain);
} catch {}
return whoisCliLookup(domain);
}
async function rdapWhoisLookup(domainName) {
const domain = normalizeDomainName(domainName);
const rdap = await rdapLookup(domain);
const registrar = extractRegistrarFromRdap(rdap);
const expires_at = extractExpiryFromRdap(rdap);
const nameservers = extractNameserversFromRdap(rdap);
const registrant = extractRegistrantFromRdap(rdap);
const store = getStore();
const existing = await store.getDomainByName(domain);
if (existing) {
const updates = { whois: rdap };
if (registrar)
updates.registrar = registrar;
if (expires_at)
updates.expires_at = expires_at;
if (nameservers.length > 0)
updates.nameservers = nameservers;
await store.updateDomain(existing.id, updates);
}
return {
domain,
registrar,
expires_at,
nameservers,
raw: JSON.stringify(rdap),
source: "rdap",
registrant
};
}
async function whoisCliLookup(domainName) {
const domain = normalizeDomainName(domainName);
let raw;
try {
raw = execFileSync("whois", [domain], { timeout: 15000, encoding: "utf-8" });
} catch (error) {
const err = error;
raw = err.stdout || err.stderr || "";
if (!raw)
throw new Error(`whois command failed for ${domain}`);
}
const registrarMatch = raw.match(/Registrar:\s*(.+)/i) || raw.match(/registrar:\s*(.+)/i);
const registrar = registrarMatch ? registrarMatch[1].trim() : null;
const expiresMatch = raw.match(/Registry Expiry Date:\s*(.+)/i) || raw.match(/Expir(?:y|ation) Date:\s*(.+)/i) || raw.match(/paid-till:\s*(.+)/i);
let expires_at = null;
if (expiresMatch) {
try {
expires_at = new Date(expiresMatch[1].trim()).toISOString();
} catch {
expires_at = expiresMatch[1].trim();
}
}
const nsMatches = raw.matchAll(/Name Server:\s*(.+)/gi);
const nameservers = [];
for (const m of nsMatches) {
const ns = m[1].trim().toLowerCase();
if (ns && !nameservers.includes(ns))
nameservers.push(ns);
}
const store = getStore();
const existing = await store.getDomainByName(domain);
if (existing) {
const updates = { whois: { raw } };
if (registrar)
updates.registrar = registrar;
if (expires_at)
updates.expires_at = expires_at;
if (nameservers.length > 0)
updates.nameservers = nameservers;
await store.updateDomain(existing.id, updates);
}
return {
domain,
registrar,
expires_at,
nameservers,
raw,
source: "cli",
registrant: { name: null, email: null, phone: null, organization: null }
};
}
var DNS_SERVERS = ["8.8.8.8", "1.1.1.1", "9.9.9.9", "208.67.222.222"];
var DNS_SERVER_NAMES = {
"8.8.8.8": "Google",
"1.1.1.1": "Cloudflare",
"9.9.9.9": "Quad9",
"208.67.222.222": "OpenDNS"
};
function checkDnsPropagation(domain, recordType = "A") {
const queryName = normalizeDnsQueryName(domain);
const normalizedRecordType = normalizeDnsRecordType(recordType);
const servers = [];
for (const server of DNS_SERVERS) {
try {
const output = execFileSync("dig", [`@${server}`, queryName, normalizedRecordType, "+short", "+time=5", "+tries=1"], { timeout: 1e4, encoding: "utf-8" });
const values = output.trim().split(`
`).filter((l) => l.length > 0);
servers.push({
server,
name: DNS_SERVER_NAMES[server] || server,
values,
status: "ok"
});
} catch (error) {
servers.push({
server,
name: DNS_SERVER_NAMES[server] || server,
values: [],
status: "error",
error: error instanceof Error ? error.message : String(error)
});
}
}
const okServers = servers.filter((s) => s.status === "ok");
const consistent = okServers.length > 0 && okServers.every((s) => JSON.stringify(s.values.sort()) === JSON.stringify(okServers[0].values.sort()));
return { domain: queryName, record_type: normalizedRecordType, servers, consistent };
}
async function checkSsl(domainName) {
const domain = normalizeDomainName(domainName);
try {
const certificate = execFileSync("openssl", ["s_client", "-servername", domain, "-connect", `${domain}:443`], { timeout: 15000, encoding: "utf-8", input: `
`, stdio: ["pipe", "pipe", "ignore"] });
const output = execFileSync("openssl", ["x509", "-noout", "-issuer", "-dates", "-subject"], { timeout: 15000, encoding: "utf-8", input: certificate, stdio: ["pipe", "pipe", "ignore"] });
const issuerMatch = output.match(/issuer\s*=\s*(.+)/i);
const notAfterMatch = output.match(/notAfter\s*=\s*(.+)/i);
const subjectMatch = output.match(/subject\s*=\s*(.+)/i);
const issuer = issuerMatch ? issuerMatch[1].trim() : null;
const subject = subjectMatch ? subjectMatch[1].trim() : null;
let expires_at = null;
if (notAfterMatch) {
try {
expires_at = new Date(notAfterMatch[1].trim()).toISOString();
} catch {
expires_at = notAfterMatch[1].trim();
}
}
const store = getStore();
const existing = await store.getDomainByName(domain);
if (existing) {
const updates = {};
if (expires_at)
updates.ssl_expires_at = expires_at;
if (issuer)
updates.ssl_issuer = issuer;
await store.updateDomain(existing.id, updates);
}
return { domain, issuer, expires_at, subject };
} catch (error) {
return {
domain,
issuer: null,
expires_at: null,
subject: null,
error: error instanceof Error ? error.message : String(error)
};
}
}
async function exportZoneFile(domainId) {
const store = getStore();
const domain = await store.getDomain(domainId);
if (!domain)
return null;
const records = await store.listDnsRecords(domainId);
const lines = [];
lines.push(`; Zone file for ${domain.name}`);
lines.push(`; Exported at ${new Date().toISOString()}`);
lines.push(`$ORIGIN ${domain.name}.`);
lines.push(`$TTL 3600`);
lines.push("");
for (const r of records) {
const name = r.name === "@" ? domain.name + "." : r.name;
if (r.type === "MX" || r.type === "SRV") {
const priority = r.priority ?? 10;
lines.push(`${name} ${r.ttl} IN ${r.type} ${priority} ${r.value}`);
} else {
lines.push(`${name} ${r.ttl} IN ${r.type} ${r.value}`);
}
}
return lines.join(`
`) + `
`;
}
async function importZoneFile(domainId, content) {
const store = getStore();
const domain = await store.getDomain(domainId);
if (!domain)
return null;
const result = { imported: 0, skipped: 0, errors: [], records: [] };
const lines = content.split(`
`);
const validTypes = new Set(["A", "AAAA", "CNAME", "MX", "TXT", "NS", "SRV"]);
for (const rawLine of lines) {
const line = rawLine.trim();
if (!line || line.startsWith(";") || line.startsWith("$")) {
continue;
}
const parts = line.split(/\s+/);
if (parts.length < 4) {
result.errors.push(`Could not parse line: ${line}`);
result.skipped++;
continue;
}
let name = parts[0];
let idx = 1;
let ttl = 3600;
if (/^\d+$/.test(parts[idx])) {
ttl = parseInt(parts[idx]);
idx++;
}
if (parts[idx] && parts[idx].toUpperCase() === "IN") {
idx++;
}
const type = parts[idx]?.toUpperCase();
idx++;
if (!type || !validTypes.has(type)) {
result.errors.push(`Unknown record type '${type}' in: ${line}`);
result.skipped++;
continue;
}
let priority;
if (type === "MX" || type === "SRV") {
if (parts[idx] && /^\d+$/.test(parts[idx])) {
priority = parseInt(parts[idx]);
idx++;
}
}
const value = parts.slice(idx).join(" ");
if (!value) {
result.errors.push(`Missing value in: ${line}`);
result.skipped++;
continue;
}
if (name.endsWith("."))
name = name.slice(0, -1);
if (name === domain.name || name === "")
name = "@";
try {
const record = await store.createDnsRecord({
domain_id: domainId,
type,
name,
value,
ttl,
priority
});
result.records.push(record);
result.imported++;
} catch (error) {
result.errors.push(`Failed to create record: ${error instanceof Error ? error.message : String(error)}`);
result.skipped++;
}
}
return result;
}
async function discoverSubdomains(domain) {
try {
const url = `https://crt.sh/?q=%25.${encodeURIComponent(domain)}&output=json`;
const response = await fetch(url, {
signal: AbortSignal.timeout(15000),
headers: { "User-Agent": USER_AGENT }
});
if (!response.ok) {
return {
domain,
subdomains: [],
source: "crt.sh",
error: `crt.sh returned ${response.status}`
};
}
const data = await response.json();
const subdomainSet = new Set;
for (const entry of data) {
for (const field of [entry.common_name, entry.name_value]) {
if (!field)
continue;
for (const name of field.split(`
`)) {
const cleaned = name.trim().toLowerCase().replace(/^\*\./, "");
if (cleaned.endsWith(domain.toLowerCase()) && cleaned !== domain.toLowerCase()) {
subdomainSet.add(cleaned);
}
}
}
}
const subdomains = [...subdomainSet].sort();
return { domain, subdomains, source: "crt.sh" };
} catch (error) {
return {
domain,
subdomains: [],
source: "crt.sh",
error: error instanceof Error ? error.message : String(error)
};
}
}
async function validateDns(domainId) {
const store = getStore();
const domain = await store.getDomain(domainId);
if (!domain)
return null;
const records = await store.listDnsRecords(domainId);
const issues = [];
const byName = new Map;
for (const r of records) {
const key = r.name.toLowerCase();
if (!byName.has(key))
byName.set(key, []);
byName.get(key).push(r);
}
for (const [name, recs] of byName) {
const hasCname = recs.some((r) => r.type === "CNAME");
const hasA = recs.some((r) => r.type === "A" || r.type === "AAAA");
const hasMx = recs.some((r) => r.type === "MX");
const hasNs = recs.some((r) => r.type === "NS");
if (hasCname && hasA) {
issues.push({
type: "error",
message: `CNAME record at '${name}' conflicts with A/AAAA record \u2014 CNAME cannot coexist with other record types`
});
}
if (hasCname && hasMx) {
issues.push({
type: "error",
message: `CNAME record at '${name}' conflicts with MX record \u2014 CNAME cannot coexist with other record types`
});
}
if (hasCname && hasNs) {
issues.push({
type: "error",
message: `CNAME record at '${name}' conflicts with NS record \u2014 CNAME cannot coexist with other record types`
});
}
if (hasCname && recs.filter((r) => r.type === "CNAME").length > 1) {
issues.push({
type: "error",
message: `Multiple CNAME records at '${name}' \u2014 only one CNAME is allowed per name`
});
}
}
const rootRecords = byName.get("@") || [];
const hasMxAtRoot = rootRecords.some((r) => r.type === "MX");
if (!hasMxAtRoot && records.length > 0) {
issues.push({
type: "warning",
message: `No MX record found at root (@) \u2014 email delivery may not work for ${domain.name}`
});
}
for (const r of records) {
if (r.type === "CNAME") {
const target = r.value.toLowerCase().replace(/\.$/, "");
if (target.endsWith(domain.name.toLowerCase())) {
const targetName = target === domain.name.toLowerCase() ? "@" : target.replace(`.${domain.name.toLowerCase()}`, "");
const targetRecords = byName.get(targetName.toLowerCase());
if (!targetRecords || targetRecords.length === 0) {
issues.push({
type: "warning",
record_id: r.id,
message: `CNAME '${r.name}' points to '${r.value}' which has no records in this zone`
});
}
}
}
}
for (const r of records) {
if (r.type === "MX" && r.priority === null) {
issues.push({
type: "warning",
record_id: r.id,
message: `MX record '${r.name}' -> '${r.value}' has no priority set`
});
}
}
return {
domain_id: domainId,
domain_name: domain.name,
issues,
valid: issues.filter((i) => i.type === "error").length === 0
};
}
// src/db/monitoring.ts
async function exportPortfolio(format = "json") {
const domains = await getStore().listDomains();
if (format === "json") {
return JSON.stringify(domains.map((d) => ({
name: d.name,
registrar: d.registrar,
status: d.status,
registered_at: d.registered_at,
expires_at: d.expires_at,
auto_renew: d.auto_renew,
is_premium: d.is_premium,
premium_price: d.premium_price,
standard_price: d.standard_price,
purchase_price: d.purchase_price,
purchase_date: d.purchase_date,
nameservers: d.nameservers,
ssl_expires_at: d.ssl_expires_at,
ssl_issuer: d.ssl_issuer,
notes: d.notes
})), null, 2);
}
const headers = [
"name",
"registrar",
"status",
"registered_at",
"expires_at",
"auto_renew",
"is_premium",
"premium_price",
"standard_price",
"purchase_price",
"purchase_date",
"nameservers",
"ssl_expires_at",
"ssl_issuer",
"notes"
];
const rows = domains.map((d) => [
csvEscape(d.name),
csvEscape(d.registrar || ""),
csvEscape(d.status),
csvEscape(d.registered_at || ""),
csvEscape(d.expires_at || ""),
d.auto_renew ? "true" : "false",
d.is_premium ? "true" : "false",
csvEscape(d.premium_price?.toString() || ""),
csvEscape(d.standard_price?.toString() || ""),
csvEscape(d.purchase_price?.toString() || ""),
csvEscape(d.purchase_date || ""),
csvEscape(d.nameservers.join("; ")),
csvEscape(d.ssl_expires_at || ""),
csvEscape(d.ssl_issuer || ""),
csvEscape(d.notes || "")
].join(","));
return [headers.join(","), ...rows].join(`
`) + `
`;
}
function csvEscape(value) {
if (value.includes(",") || value.includes('"') || value.includes(`
`)) {
return `"${value.replace(/"/g, '""')}"`;
}
return value;
}
var liveBulkCheckDependencies = {
whoisLookup,
checkSsl,
validateDns
};
async function checkAllDomains(dependencies = liveBulkCheckDependencies) {
const domains = await getStore().listDomains();
const results = [];
for (const domain of domains) {
const result = {
domain: domain.name,
domain_id: domain.id
};
try {
const whois = await dependencies.whoisLookup(domain.name);
result.whois = {
registrar: whois.registrar,
expires_at: whois.expires_at
};
} catch (error) {
result.whois = {
registrar: null,
expires_at: null,
error: error instanceof Error ? error.message : String(error)
};
}
try {
const ssl = await dependencies.checkSsl(domain.name);
result.ssl = {
issuer: ssl.issuer,
expires_at: ssl.expires_at,
error: ssl.error
};
} catch (error) {
result.ssl = {
issuer: null,
expires_at: null,
error: error instanceof Error ? error.message : String(error)
};
}
const validation = await dependencies.validateDns(domain.id);
if (validation) {
result.dns_validation = {
valid: validation.valid,
issue_count: validation.issues.length,
errors: validation.issues.map((i) => `[${i.type}] ${i.message}`)
};
}
results.push(result);
}
return results;
}
// src/db/domains.ts
function createDomain(input) {
return getStore().createDomain(input);
}
function getDomainByName(name) {
return getStore().getDomainByName(name);
}
function getDomainByIdentifier(identifier) {
return getStore().getDomainByIdentifier(identifier);
}
function getDomainDetails(identifier) {
return getStore().getDomainDetails(identifier);
}
function listDomains(options = {}) {
return getStore().listDomains(options);
}
function updateDomain(id, input) {
return getStore().updateDomain(id, input);
}
function deleteDomain(id) {
return getStore().deleteDomain(id);
}
function countDomains() {
return getStore().countDomains();
}
function searchDomains(query) {
return getStore().searchDomains(query);
}
function getByRegistrar(registrar) {
return getStore().getByRegistrar(registrar);
}
function listExpiring(days, options) {
return getStore().listExpiring(days, options);
}
function listSslExpiring(days, options) {
return getStore().listSslExpiring(days, options);
}
function getDomainStats() {
return getStore().getDomainStats();
}
function markDomainPremium(identifier, premiumPrice, standardPrice) {
return getStore().markDomainPremium(identifier, premiumPrice, standardPrice);
}
function updateDomainLifecycleStatus(identifier, status, notes) {
return getStore().updateDomainLifecycleStatus(identifier, status, notes);
}
function recordDomainPurchase(identifier, input) {
return getStore().recordDomainPurchase(identifier, input);
}
function createDomainOffer(input) {
return getStore().createDomainOffer(input);
}
function listDomainOffers(domainId) {
return getStore().listDomainOffers(domainId);
}
function linkDomainEmail(input) {
return getStore().linkDomainEmail(input);
}
function listDomainEmailLinks(domainId) {
return getStore().listDomainEmailLinks(domainId);
}
function createDnsRecord(input) {
return getStore().createDnsRecord(input);
}
function listDnsRecords(domainId, type) {
return getStore().listDnsRecords(domainId, type);
}
function updateDnsRecord(id, input) {
return getStore().updateDnsRecord(id, input);
}
function deleteDnsRecord(id) {
return getStore().deleteDnsRecord(id);
}
function createAlert(input) {
return getStore().createAlert(input);
}
function listAlerts(domainId) {
return getStore().listAlerts(domainId);
}
function deleteAlert(id) {
return getStore().deleteAlert(id);
}
// src/lib/namecheap.ts
function getConfig() {
const apiKey = process.env["NAMECHEAP_API_KEY"];
const username = process.env["NAMECHEAP_USERNAME"];
const clientIp = process.env["NAMECHEAP_CLIENT_IP"];
if (!apiKey)
throw new Error("NAMECHEAP_API_KEY environment variable is not set");
if (!username)
throw new Error("NAMECHEAP_USERNAME environment variable is not set");
if (!clientIp)
throw new Error("NAMECHEAP_CLIENT_IP environment variable is not set");
return {
apiKey,
username,
clientIp,
sandbox: process.env["NAMECHEAP_SANDBOX"] === "true"
};
}
async function apiRequest(config, command, params = {}) {
const base = config.sandbox ? "https://api.sandbox.namecheap.com/xml.response" : "https://api.namecheap.com/xml.response";
const url = new URL(base);
url.searchParams.set("ApiUser", config.username);
url.searchParams.set("ApiKey", config.apiKey);
url.searchParams.set("UserName", config.username);
url.searchParams.set("ClientIp", config.clientIp);
url.searchParams.set("Command", command);
for (const [k, v] of Object.entries(params)) {
url.searchParams.set(k, v);
}
const response = await fetch(url.toString(), {
signal: AbortSignal.timeout(30000)
});
if (!response.ok) {
throw new Error(`Namecheap API request failed with status ${response.status}`);
}
return response.text();
}
function parseXmlValue(xml, tag) {
const match = xml.match(new RegExp(`<${tag}[^>]*>([^<]*)</${tag}>`, "i"));
return match ? match[1].trim() : null;
}
function parseXmlAttributes(xml, tag) {
const results = [];
const tagRegex = new RegExp(`<${tag}([^>]*)>`, "gi");
let match;
while ((match = tagRegex.exec(xml)) !== null) {
const attrs = {};
const attrStr = match[1];
const attrRegex = /(\w+)="([^"]*)"/g;
let attrMatch;
while ((attrMatch = attrRegex.exec(attrStr)) !== null) {
attrs[attrMatch[1]] = attrMatch[2];
}
results.push(attrs);
}
return results;
}
async function listNamecheapDomains(config) {
const cfg = config || getConfig();
const xml = await apiRequest(cfg, "namecheap.domains.getList", { PageSize: "100" });
const domainAttrs = parseXmlAttributes(xml, "Domain");
return domainAttrs.map((attrs) => ({
domain: attrs["Name"] || "",
expiry: attrs["Expires"] || "",
autoRenew: attrs["AutoRenew"] === "true",
isExpired: attrs["IsExpired"] === "true",
isLocked: attrs["IsLocked"] === "true"
}));
}
async function getDomainInfo(domain, config) {
const cfg = config || getConfig();
const xml = await apiRequest(cfg, "namecheap.domains.getInfo", { DomainName: domain });
const created = parseXmlValue(xml, "CreatedDate") || "";
const expires = parseXmlValue(xml, "ExpiredDate") || "";
const nsAttrs = parseXmlAttributes(xml, "Nameserver");
const nameservers = nsAttrs.map((a) => a["NAME"] || "").filter(Boolean);
return {
domain,
registrar: "Namecheap",
created,
expires,
nameservers
};
}
async function renewDomain(domain, years = 1, config) {
const cfg = config || getConfig();
const xml = await apiRequest(cfg, "namecheap.domains.renew", {
DomainName: domain,
Years: String(years)
});
const orderId = parseXmlValue(xml, "OrderId");
const chargedAmount = parseXmlValue(xml, "ChargedAmount");
return {
domain,
success: xml.includes('Status="OK"'),
orderId: orderId || undefined,
chargedAmount: chargedAmount || undefined
};
}
function namecheapContactParams(contact) {
const organization = contact.organization_name || "NA";
const base = {
FirstName: contact.first_name,
LastName: contact.last_name,
OrganizationName: organization,
Address1: contact.address_line_1,
City: contact.city,
StateProvince: contact.state,
PostalCode: contact.zip_code,
Country: contact.country_code,
Phone: contact.phone,
EmailAddress: contact.email
};
const params = {};
for (const prefix of ["Registrant", "Tech", "Admin", "AuxBilling"]) {
for (const [key, value] of Object.entries(base)) {
params[prefix + key] = value;
}
}
return params;
}
async function registerDomain(domain, contact, options = {}, config) {
const cfg = config || getConfig();
const params = {
DomainName: domain,
Years: String(options.years ?? 1),
AddFreeWhoisguard: options.whoisGuard === false ? "no" : "yes",
WGEnabled: options.whoisGuard === false ? "no" : "yes",
...namecheapContactParams(contact)
};
if (options.premiumPrice !== undefined) {
params.IsPremiumDomain = "true";
params.PremiumPrice = String(options.premiumPrice);
}
const xml = await apiRequest(cfg, "namecheap.domains.create", params);
return {
domain,
success: xml.includes('Status="OK"') || xml.includes('Registered="true"'),
orderId: parseXmlValue(xml, "OrderId") || undefined,
chargedAmount: parseXmlValue(xml, "ChargedAmount") || undefined
};
}
async function updateNameservers(domain, nameservers, config) {
if (nameservers.length === 0)
throw new Error("updateNameservers requires at least one nameserver");
const cfg = config || getConfig();
const { sld, tld } = splitDomain(domain);
const xml = await apiRequest(cfg, "namecheap.domains.dns.setCustom", {
SLD: sld,
TLD: tld,
Nameservers: nameservers.join(",")
});
return xml.includes('Status="OK"') || xml.includes('Updated="true"');
}
async function getDnsRecords(_domain, sld, tld, config) {
const cfg = config || getConfig();
const xml = await apiRequest(cfg, "namecheap.domains.dns.getHosts", {
SLD: sld,
TLD: tld
});
const hostAttrs = parseXmlAttributes(xml, "host");
return hostAttrs.map((attrs) => ({
type: attrs["Type"] || "A",
name: attrs["Name"] || "@",
address: attrs["Address"] || "",
ttl: parseInt(attrs["TTL"] || "3600"),
mxPref: attrs["MXPref"] ? parseInt(attrs["MXPref"]) : undefined
}));
}
async function setDnsRecords(_domain, sld, tld, records, config) {
const cfg = config || getConfig();
const params = {
SLD: sld,
TLD: tld
};
records.forEach((r, i) => {
params[`HostName${i + 1}`] = r.name;
params[`RecordType${i + 1}`] = r.type;
params[`Address${i + 1}`] = r.address;
params[`TTL${i + 1}`] = String(r.ttl);
if (r.mxPref !== undefined) {
params[`MXPref${i + 1}`] = String(r.mxPref);
}
});
const xml = await apiRequest(cfg, "namecheap.domains.dns.setHosts", params);
return xml.includes('IsSuccess="true"');
}
async function checkAvailability(domain, config) {
const cfg = config || getConfig();
const xml = await apiRequest(cfg, "namecheap.domains.check", { DomainList: domain });
const domainAttrs = parseXmlAttributes(xml, "DomainCheckResult");
const result = domainAttrs[0] || {};
return {
domain,
available: result["Available"] === "true",
premium: result["IsPremiumName"] === "true",
price: result["PremiumRegistrationPrice"] ? parseFloat(result["PremiumRegistrationPrice"]) : undefined
};
}
function splitDomain(domain) {
const parts = domain.split(".");
if (parts.length < 2) {
throw new Error(`Invalid domain: ${domain}`);
}
if (parts.length >= 3 && ["co", "com", "org", "net", "ac", "gov"].includes(parts[parts.length - 2])) {
return {
sld: parts.slice(0, -2).join("."),
tld: parts.slice(-2).join(".")
};
}
return {
sld: parts.slice(0, -1).join("."),
tld: parts[parts.length - 1]
};
}
async function syncToLocalDb(dbFunctions, config) {
const cfg = config || getConfig();
const result = { synced: 0, errors: [], domains: [] };
const syncedAt = new Date().toISOString();
let ncDomains;
try {
ncDomains = await listNamecheapDomains(cfg);
} catch (error) {
throw new Error(`Failed to list Namecheap domains: ${error instanceof Error ? error.message : String(error)}`);
}
for (const ncDomain of ncDomains) {
try {
let info;
try {
info = await getDomainInfo(ncDomain.domain, cfg);
} catch {
info = {
domain: ncDomain.domain,
registrar: "Namecheap",
created: "",
expires: ncDomain.expiry,
nameservers: []
};
}
const expiresAt = normalizeDate(info.expires || ncDomain.expiry);
const createdAt = normalizeDate(info.created);
const existing = await dbFunctions.getDomainByName(ncDomain.domain);
if (existing) {
await dbFunctions.updateDomain(existing.id, {
registrar: "Namecheap",
status: "active",
registered_at: createdAt || undefined,
expires_at: expiresAt || undefined,
auto_renew: ncDomain.autoRenew,
nameservers: info.nameservers.length > 0 ? info.nameservers : undefined,
expiry_synced_at: syncedAt
});
} else {
await dbFunctions.createDomain({
name: ncDomain.domain,
registrar: "Namecheap",
status: "active",
registered_at: createdAt || undefined,
expires_at: expiresAt || undefined,
auto_renew: ncDomain.autoRenew,
nameservers: info.nameservers,
expiry_synced_at: syncedAt
});
}
result.synced++;
result.domains.push(ncDomain.domain);
} catch (error) {
result.errors.push(`${ncDomain.domain}: ${error instanceof Error ? error.message : String(error)}`);
}
}
return result;
}
function normalizeDate(dateStr) {
if (!dateStr)
return null;
try {
const d = new Date(dateStr);
if (isNaN(d.getTime()))
return null;
return d.toISOString();
} catch {
return null;
}
}
// src/lib/godaddy.ts
class GoDaddyApiError extends Error {
statusCode;
details;
constructor(message, statusCode, details) {
super(message);
this.statusCode = statusCode;
this.details = details;
this.name = "GoDaddyApiError";
}
}
var _overriddenFetch = null;
function getCredentials() {
const apiKey = process.env["GODADDY_API_KEY"];
const apiSecret = process.env["GODADDY_API_SECRET"];
if (!apiKey || !apiSecret) {
throw new Error("GoDaddy API credentials not configured. Set GODADDY_API_KEY and GODADDY_API_SECRET environment variables.");
}
return { apiKey, apiSecret };
}
function getHeaders() {
const { apiKey, apiSecret } = getCredentials();
return {
Authorization: `sso-key ${apiKey}:${apiSecret}`,
"Content-Type": "application/json",
Accept: "application/json"
};
}
var GODADDY_API_BASE = "https://api.godaddy.com";
async function apiRequest2(method, path, body) {
const fetchFn = _overriddenFetch || globalThis.fetch;
const url = `${GODADDY_API_BASE}${path}`;
const headers = getHeaders();
const options = { method, headers };
if (body !== undefined) {
options.body = JSON.stringify(body);
}
const response = await fetchFn(url, options);
if (!response.ok) {
const text = await response.text();
throw new GoDaddyApiError(`GoDaddy API ${method} ${path} failed with status ${response.status}: ${text}`, response.status, { responseBody: text });
}
if (response.status === 204) {
return;
}
return await response.json();
}
async function listGoDaddyDomains() {
return apiRequest2("GET", "/v1/domains");
}
async function getDomainInfo2(domain) {
return apiRequest2("GET", `/v1/domains/${encodeURIComponent(domain)}`);
}
async function renewDomain2(domain) {
return apiRequest2("POST", `/v1/domains/${encodeURIComponent(domain)}/renew`, { period: 1 });
}
async function getDnsRecords2(domain, type) {
const path = type ? `/v1/domains/${encodeURIComponent(domain)}/records/${encodeURIComponent(type)}` : `/v1/domains/${encodeURIComponent(domain)}/records`;
return apiRequest2("GET", path);
}
async function setDnsRecords2(domain, records) {
await apiRequest2("PUT", `/v1/domains/${encodeURIComponent(domain)}/records`, records);
}
async function checkAvailability2(domain) {
return apiRequest2("GET", `/v1/domains/available?domain=${encodeURIComponent(domain)}`);
}
function mapGoDaddyStatus(gdStatus) {
const s = gdStatus.toUpperCase();
if (s === "ACTIVE")
return "active";
if (s === "EXPIRED")
return "expired";
if (s === "TRANSFERRED_OUT" || s === "TRANSFERRING" || s === "PENDING_TRANSFER")
return "transferring";
if (s === "REDEMPTION" || s === "PENDING_REDEMPTION")
return "redemption";
return "active";
}
async function syncToLocalDb2(dbFns) {
const result = {
synced: 0,
created: 0,
updated: 0,
errors: []
};
let gdDomains;
try {
gdDomains = await listGoDaddyDomains();
} catch (err) {
result.errors.push(`Failed to list domains: ${err instanceof Error ? err.message : String(err)}`);
return result;
}
const syncedAt = new Date().toISOString();
for (const gd of gdDomains) {
try {
let detail;
try {
detail = await getDomainInfo2(gd.domain);
} catch {
detail = gd;
}
const existing = await dbFns.getDomainByName(gd.domain);
const domainData = {
name: gd.domain,
registrar: "GoDaddy",
status: mapGoDaddyStatus(gd.status),
expires_at: gd.expires ? new Date(gd.expires).toISOString() : undefined,
auto_renew: gd.renewAuto,
nameservers: gd.nameServers || [],
registered_at: detail.createdAt ? new Date(detail.createdAt).toISOString() : undefined,
expiry_synced_at: syncedAt,
metadata: {
godaddy_domain_id: detail.domainId,
provider: "godaddy",
locked: detail.locked,
privacy: detail.privacy
}
};
if (existing) {
await dbFns.updateDomain(existing.id, domainData);
result.updated++;
} else {
await dbFns.createDomain(domainData);
result.created++;
}
result.synced++;
} catch (err) {
result.errors.push(`Failed to sync ${gd.domain}: ${err instanceof Error ? err.message : String(err)}`);
}
}
return result;
}
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/Route53Client.js
var import_client24 = __toESM(require_client2());
var import_core = __toESM(require_dist_cjs2());
var import_client25 = __toESM(require_client());
var import_config29 = __toESM(require_config());
var import_endpoints3 = __toESM(require_endpoints());
var import_protocols7 = __toESM(require_protocols());
var import_retry4 = __toESM(require_retry());
var import_schema2 = __toESM(require_schema());
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/auth/httpAuthSchemeProvider.js
var import_httpAuthSchemes = __toESM(require_httpAuthSchemes());
var import_client3 = __toESM(require_client());
var defaultRoute53HttpAuthSchemeParametersProvider = async (config, context, input) => {
return {
operation: import_client3.getSmithyContext(context).operation,
region: await import_client3.normalizeProvider(config.region)() || (() => {
throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
})()
};
};
function createAwsAuthSigv4HttpAuthOption(authParameters) {
return {
schemeId: "aws.auth#sigv4",
signingProperties: {
name: "route53",
region: authParameters.region
},
propertiesExtractor: (config, context) => ({
signingProperties: {
config,
context
}
})
};
}
var defaultRoute53HttpAuthSchemeProvider = (authParameters) => {
const options = [];
switch (authParameters.operation) {
default: {
options.push(createAwsAuthSigv4HttpAuthOption(authParameters));
}
}
return options;
};
var resolveHttpAuthSchemeConfig = (config) => {
const config_0 = import_httpAuthSchemes.resolveAwsSdkSigV4Config(config);
return Object.assign(config_0, {
authSchemePreference: import_client3.normalizeProvider(config.authSchemePreference ?? [])
});
};
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/endpoint/EndpointParameters.js
var resolveClientEndpointParameters = (options) => {
return Object.assign(options, {
useDualstackEndpoint: options.useDualstackEndpoint ?? false,
useFipsEndpoint: options.useFipsEndpoint ?? false,
defaultSigningName: "route53"
});
};
var commonParams = {
UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
Endpoint: { type: "builtInParams", name: "endpoint" },
Region: { type: "builtInParams", name: "region" },
UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
};
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/package.json
var package_default = {
name: "@aws-sdk/client-route-53",
version: "3.1127.0",
description: "AWS SDK for JavaScript Route 53 Client for Node.js, Browser and React Native",
homepage: "https://github.com/aws/aws-sdk-js-v3/tree/main/clients/client-route-53",
license: "Apache-2.0",
author: {
name: "AWS SDK for JavaScript Team",
url: "https://aws.amazon.com/sdk-for-javascript/"
},
repository: {
type: "git",
url: "https://github.com/aws/aws-sdk-js-v3.git",
directory: "clients/client-route-53"
},
files: [
"dist-*/**"
],
sideEffects: false,
main: "./dist-cjs/index.js",
module: "./dist-es/index.js",
browser: {
"./dist-es/runtimeConfig": "./dist-es/runtimeConfig.browser"
},
types: "./dist-types/index.d.ts",
typesVersions: {
"<4.5": {
"dist-types/*": [
"dist-types/ts3.4/*"
]
}
},
"react-native": {
"./dist-es/runtimeConfig": "./dist-es/runtimeConfig.native"
},
scripts: {
build: "concurrently 'yarn:build:types' 'yarn:build:es' && yarn build:cjs",
"build:cjs": "node ../../scripts/compilation/inline",
"build:es": "premove dist-es && tsc -p tsconfig.es.json",
"build:include:deps": 'yarn g:turbo run build -F="$npm_package_name"',
"build:types": "premove dist-types && tsc -p tsconfig.types.json",
"build:types:downlevel": "downlevel-dts dist-types dist-types/ts3.4",
clean: "premove dist-cjs dist-es dist-types",
"extract:docs": "api-extractor run --local",
"generate:client": "node ../../scripts/generate-clients/single-service",
test: "yarn g:vitest run --passWithNoTests",
"test:watch": "yarn g:vitest watch --passWithNoTests",
"test:integration": "yarn g:vitest run --passWithNoTests -c vitest.config.integ.mts",
"test:integration:watch": "yarn g:vitest watch --passWithNoTests -c vitest.config.integ.mts",
"test:e2e": "yarn g:vitest run -c vitest.config.e2e.mts",
"test:e2e:watch": "yarn g:vitest watch -c vitest.config.e2e.mts",
"test:index": "tsc -p tsconfig.test.json && node ./test/index-objects.spec.mjs"
},
dependencies: {
"@aws-sdk/core": "^3.977.9",
"@aws-sdk/credential-provider-node": "^3.972.82",
"@aws-sdk/middleware-sdk-route53": "^3.972.26",
"@aws-sdk/types": "^3.974.5",
"@smithy/core": "^3.33.3",
"@smithy/fetch-http-handler": "^5.7.2",
"@smithy/node-http-handler": "^4.11.3",
"@smithy/types": "^4.17.2",
tslib: "^2.6.2"
},
devDependencies: {
"@smithy/snapshot-testing": "^2.3.2",
"@tsconfig/node20": "20.1.8",
"@types/node": "^20.14.8",
concurrently: "7.0.0",
"downlevel-dts": "0.10.1",
premove: "4.0.0",
typescript: "~7.0.2",
vitest: "^4.0.17"
},
engines: {
node: ">=20.0.0"
}
};
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/runtimeConfig.js
var import_client20 = __toESM(require_client2());
var import_httpAuthSchemes3 = __toESM(require_httpAuthSchemes());
// ../../node_modules/.bun/@aws-sdk+credential-provider-node@3.972.82/node_modules/@aws-sdk/credential-provider-node/dist-es/defaultProvider.js
init_dist_es();
var import_config27 = __toESM(require_config());
// ../../node_modules/.bun/@aws-sdk+credential-provider-node@3.972.82/node_modules/@aws-sdk/credential-provider-node/dist-es/remoteProvider.js
var import_config10 = __toESM(require_config());
var ENV_IMDS_DISABLED = "AWS_EC2_METADATA_DISABLED";
var remoteProvider = async (init) => {
await Promise.resolve().then(() => init_dist_es2());
if (process.env[ENV_CMDS_RELATIVE_URI] || process.env[ENV_CMDS_FULL_URI]) {
init.logger?.debug("@aws-sdk/credential-provider-node - remoteProvider::fromHttp/fromContainerMetadata");
await Promise.resolve().then(() => init_dist_es3());
return import_config10.chain(fromHttp(init), fromContainerMetadata(init));
}
if (process.env[ENV_IMDS_DISABLED] && process.env[ENV_IMDS_DISABLED] !== "false") {
return async () => {
throw new import_config10.CredentialsProviderError("EC2 Instance Metadata Service access disabled", { logger: init.logger });
};
}
init.logger?.debug("@aws-sdk/credential-provider-node - remoteProvider::fromInstanceMetadata");
return fromInstanceMetadata(init);
};
// ../../node_modules/.bun/@aws-sdk+credential-provider-node@3.972.82/node_modules/@aws-sdk/credential-provider-node/dist-es/runtime/memoize-chain.js
function memoizeChain(providers, treatAsExpired) {
const chain = internalCreateChain(providers);
let activeLock;
let passiveLock;
let credentials;
let forceRefreshLock;
const provider = async (options) => {
if (options?.forceRefresh) {
if (!forceRefreshLock) {
forceRefreshLock = chain(options).then((c) => {
credentials = c;
}).finally(() => {
forceRefreshLock = undefined;
});
}
await forceRefreshLock;
return credentials;
}
if (credentials?.expiration) {
if (credentials?.expiration?.getTime() < Date.now()) {
credentials = undefined;
}
}
if (activeLock) {
await activeLock;
} else if (!credentials || treatAsExpired?.(credentials)) {
if (credentials) {
if (!passiveLock) {
passiveLock = chain(options).then((c) => {
credentials = c;
}).catch(() => {}).finally(() => {
passiveLock = undefined;
});
}
} else {
activeLock = chain(options).then((c) => {
credentials = c;
}).finally(() => {
activeLock = undefined;
});
return provider(options);
}
}
return credentials;
};
return provider;
}
var internalCreateChain = (providers) => async (awsIdentityProperties) => {
let lastProviderError;
for (const provider of providers) {
try {
return await provider(awsIdentityProperties);
} catch (err) {
lastProviderError = err;
if (err?.tryNextLink) {
continue;
}
throw err;
}
}
throw lastProviderError;
};
// ../../node_modules/.bun/@aws-sdk+credential-provider-node@3.972.82/node_modules/@aws-sdk/credential-provider-node/dist-es/defaultProvider.js
var multipleCredentialSourceWarningEmitted = false;
var defaultProvider = (init = {}) => memoizeChain([
async () => {
const profile = init.profile ?? process.env[import_config27.ENV_PROFILE];
if (profile) {
const envStaticCredentialsAreSet = process.env[ENV_KEY] && process.env[ENV_SECRET];
if (envStaticCredentialsAreSet) {
if (!multipleCredentialSourceWarningEmitted) {
const warnFn = init.logger?.warn && init.logger?.constructor?.name !== "NoOpLogger" ? init.logger.warn.bind(init.logger) : console.warn;
warnFn(`@aws-sdk/credential-provider-node - defaultProvider::fromEnv WARNING:
Multiple credential sources detected:
Both AWS_PROFILE and the pair AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY static credentials are set.
This SDK will proceed with the AWS_PROFILE value.
However, a future version may change this behavior to prefer the ENV static credentials.
Please ensure that your environment only sets either the AWS_PROFILE or the
AWS_ACCESS_KEY_ID/AWS_SECRET_ACCESS_KEY pair.
`);
multipleCredentialSourceWarningEmitted = true;
}
}
throw new import_config27.CredentialsProviderError("AWS_PROFILE is set, skipping fromEnv provider.", {
logger: init.logger,
tryNextLink: true
});
}
init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromEnv");
return fromEnv(init)();
},
async (awsIdentityProperties) => {
init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromSSO");
const { ssoStartUrl, ssoAccountId, ssoRegion, ssoRoleName, ssoSession } = init;
if (!ssoStartUrl && !ssoAccountId && !ssoRegion && !ssoRoleName && !ssoSession) {
throw new import_config27.CredentialsProviderError("Skipping SSO provider in default chain (inputs do not include SSO fields).", { logger: init.logger });
}
await Promise.resolve().then(() => init_dist_es5());
return fromSSO(init)(awsIdentityProperties);
},
async (awsIdentityProperties) => {
init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromIni");
await Promise.resolve().then(() => init_dist_es9());
return fromIni(init)(awsIdentityProperties);
},
async (awsIdentityProperties) => {
init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromProcess");
await Promise.resolve().then(() => init_dist_es7());
return fromProcess(init)(awsIdentityProperties);
},
async (awsIdentityProperties) => {
init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::fromTokenFile");
await Promise.resolve().then(() => init_dist_es8());
return fromTokenFile(init)(awsIdentityProperties);
},
async () => {
init.logger?.debug("@aws-sdk/credential-provider-node - defaultProvider::remoteProvider");
return (await remoteProvider(init))();
},
async () => {
throw new import_config27.CredentialsProviderError("Could not load credentials from any providers", {
tryNextLink: false,
logger: init.logger
});
}
], credentialsTreatedAsExpired);
var credentialsTreatedAsExpired = (credentials) => credentials?.expiration !== undefined && credentials.expiration.getTime() - Date.now() < 300000;
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/runtimeConfig.js
var import_client21 = __toESM(require_client());
var import_config28 = __toESM(require_config());
var import_retry3 = __toESM(require_retry());
var import_serde4 = __toESM(require_serde());
var import_node_http_handler2 = __toESM(require_dist_cjs4());
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/runtimeConfig.shared.js
var import_httpAuthSchemes2 = __toESM(require_httpAuthSchemes());
var import_protocols4 = __toESM(require_protocols2());
var import_checksum = __toESM(require_checksum());
var import_client19 = __toESM(require_client());
var import_protocols5 = __toESM(require_protocols());
var import_serde3 = __toESM(require_serde());
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/endpoint/endpointResolver.js
var import_client17 = __toESM(require_client2());
var import_endpoints2 = __toESM(require_endpoints());
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/endpoint/bdd.js
var import_endpoints = __toESM(require_endpoints());
var s = "ref";
var t2 = "authSchemes";
var u = "name";
var v = "signingRegion";
var a2 = -1;
var b2 = true;
var c2 = "isSet";
var d2 = "PartitionResult";
var e3 = "booleanEquals";
var f2 = "stringEquals";
var g2 = "getAttr";
var h2 = "sigv4";
var i2 = { [s]: "Endpoint" };
var j2 = { fn: g2, argv: [{ [s]: d2 }, "name"] };
var k2 = { [s]: d2 };
var l = { [t2]: [{ [u]: h2, [v]: "us-east-1" }] };
var m = { [t2]: [{ [u]: h2, [v]: "cn-northwest-1" }] };
var n2 = { [t2]: [{ [u]: h2, [v]: "us-gov-west-1" }] };
var o2 = { [t2]: [{ [u]: h2, [v]: "eusc-de-east-1" }] };
var p = { [t2]: [{ [u]: h2, [v]: "{PartitionResult#implicitGlobalRegion}" }] };
var q2 = [{ [s]: "Region" }];
var _data2 = {
conditions: [
[c2, [i2]],
[c2, q2],
["aws.partition", q2, d2],
[e3, [{ [s]: "UseFIPS" }, b2]],
[f2, [j2, "aws"]],
[f2, [j2, "aws-cn"]],
[f2, [j2, "aws-us-gov"]],
[e3, [{ [s]: "UseDualStack" }, b2]],
[e3, [{ fn: g2, argv: [k2, "supportsFIPS"] }, b2]],
[f2, [j2, "aws-iso"]],
[f2, [j2, "aws-iso-b"]],
[f2, [j2, "aws-iso-e"]],
[f2, [j2, "aws-iso-f"]],
[f2, [j2, "aws-eusc"]],
[e3, [{ fn: g2, argv: [k2, "supportsDualStack"] }, b2]]
],
results: [
[a2],
[a2, "Invalid Configuration: FIPS and custom endpoint are not supported"],
[a2, "Invalid Configuration: Dualstack and custom endpoint are not supported"],
[i2, {}],
["https://route53.amazonaws.com", l],
["https://route53-fips.amazonaws.com", l],
["https://route53.global.api.aws", l],
["https://route53-fips.global.api.aws", l],
["https://route53.amazonaws.com.cn", m],
["https://route53.global.api.amazonwebservices.com.cn", m],
["https://route53.us-gov.amazonaws.com", n2],
["https://route53.us-gov.api.aws", n2],
["https://route53.c2s.ic.gov", { [t2]: [{ [u]: h2, [v]: "us-iso-east-1" }] }],
["https://route53.sc2s.sgov.gov", { [t2]: [{ [u]: h2, [v]: "us-isob-east-1" }] }],
["https://route53.cloud.adc-e.uk", { [t2]: [{ [u]: h2, [v]: "eu-isoe-west-1" }] }],
["https://route53.csp.hci.ic.gov", { [t2]: [{ [u]: h2, [v]: "us-isof-south-1" }] }],
["https://route53.amazonaws.eu", o2],
["https://route53.global.api.amazonwebservices.eu", o2],
["https://route53-fips.{PartitionResult#dualStackDnsSuffix}", p],
[a2, "FIPS and DualStack are enabled, but this partition does not support one or both"],
["https://route53-fips.{PartitionResult#dnsSuffix}", p],
[a2, "FIPS is enabled but this partition does not support FIPS"],
["https://route53.{PartitionResult#dualStackDnsSuffix}", p],
[a2, "DualStack is enabled but this partition does not support DualStack"],
["https://route53.{PartitionResult#dnsSuffix}", p],
[a2, "Invalid Configuration: Missing Region"]
]
};
var root2 = 2;
var r3 = 1e8;
var nodes2 = new Int32Array([
-1,
1,
-1,
0,
27,
3,
1,
4,
r3 + 25,
2,
5,
r3 + 25,
3,
19,
6,
4,
18,
7,
5,
17,
8,
6,
25,
9,
7,
15,
10,
9,
r3 + 12,
11,
10,
r3 + 13,
12,
11,
r3 + 14,
13,
12,
r3 + 15,
14,
13,
r3 + 16,
r3 + 24,
13,
r3 + 17,
16,
14,
r3 + 22,
r3 + 23,
7,
r3 + 9,
r3 + 8,
7,
r3 + 6,
r3 + 4,
4,
26,
20,
6,
25,
21,
7,
23,
22,
8,
r3 + 20,
r3 + 21,
8,
24,
r3 + 19,
14,
r3 + 18,
r3 + 19,
7,
r3 + 11,
r3 + 10,
7,
r3 + 7,
r3 + 5,
3,
r3 + 1,
28,
7,
r3 + 2,
r3 + 3
]);
var bdd2 = import_endpoints.BinaryDecisionDiagram.from(nodes2, root2, _data2.conditions, _data2.results);
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/endpoint/endpointResolver.js
var cache2 = new import_endpoints2.EndpointCache({
size: 50,
params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"]
});
var defaultEndpointResolver2 = (endpointParams, context = {}) => {
return cache2.get(endpointParams, () => import_endpoints2.decideEndpoint(bdd2, {
endpointParams,
logger: context.logger
}));
};
import_endpoints2.customEndpointFunctions.aws = import_client17.awsEndpointFunctions;
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/schemas/schemas_0.js
var import_schema = __toESM(require_schema());
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/models/Route53ServiceException.js
var import_client18 = __toESM(require_client());
class Route53ServiceException extends import_client18.ServiceException {
constructor(options) {
super(options);
Object.setPrototypeOf(this, Route53ServiceException.prototype);
}
}
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/models/errors.js
class ConcurrentModification extends Route53ServiceException {
name = "ConcurrentModification";
$fault = "client";
constructor(opts) {
super({
name: "ConcurrentModification",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, ConcurrentModification.prototype);
}
}
class InvalidInput extends Route53ServiceException {
name = "InvalidInput";
$fault = "client";
constructor(opts) {
super({
name: "InvalidInput",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidInput.prototype);
}
}
class InvalidKeySigningKeyStatus extends Route53ServiceException {
name = "InvalidKeySigningKeyStatus";
$fault = "client";
constructor(opts) {
super({
name: "InvalidKeySigningKeyStatus",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidKeySigningKeyStatus.prototype);
}
}
class InvalidKMSArn extends Route53ServiceException {
name = "InvalidKMSArn";
$fault = "client";
constructor(opts) {
super({
name: "InvalidKMSArn",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidKMSArn.prototype);
}
}
class InvalidSigningStatus extends Route53ServiceException {
name = "InvalidSigningStatus";
$fault = "client";
constructor(opts) {
super({
name: "InvalidSigningStatus",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidSigningStatus.prototype);
}
}
class NoSuchKeySigningKey extends Route53ServiceException {
name = "NoSuchKeySigningKey";
$fault = "client";
constructor(opts) {
super({
name: "NoSuchKeySigningKey",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, NoSuchKeySigningKey.prototype);
}
}
class ConflictingDomainExists extends Route53ServiceException {
name = "ConflictingDomainExists";
$fault = "client";
constructor(opts) {
super({
name: "ConflictingDomainExists",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, ConflictingDomainExists.prototype);
}
}
class InvalidVPCId extends Route53ServiceException {
name = "InvalidVPCId";
$fault = "client";
constructor(opts) {
super({
name: "InvalidVPCId",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidVPCId.prototype);
}
}
class LimitsExceeded extends Route53ServiceException {
name = "LimitsExceeded";
$fault = "client";
constructor(opts) {
super({
name: "LimitsExceeded",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, LimitsExceeded.prototype);
}
}
class NoSuchHostedZone extends Route53ServiceException {
name = "NoSuchHostedZone";
$fault = "client";
constructor(opts) {
super({
name: "NoSuchHostedZone",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, NoSuchHostedZone.prototype);
}
}
class NotAuthorizedException extends Route53ServiceException {
name = "NotAuthorizedException";
$fault = "client";
constructor(opts) {
super({
name: "NotAuthorizedException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, NotAuthorizedException.prototype);
}
}
class PriorRequestNotComplete extends Route53ServiceException {
name = "PriorRequestNotComplete";
$fault = "client";
constructor(opts) {
super({
name: "PriorRequestNotComplete",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, PriorRequestNotComplete.prototype);
}
}
class PublicZoneVPCAssociation extends Route53ServiceException {
name = "PublicZoneVPCAssociation";
$fault = "client";
constructor(opts) {
super({
name: "PublicZoneVPCAssociation",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, PublicZoneVPCAssociation.prototype);
}
}
class CidrBlockInUseException extends Route53ServiceException {
name = "CidrBlockInUseException";
$fault = "client";
Message;
constructor(opts) {
super({
name: "CidrBlockInUseException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, CidrBlockInUseException.prototype);
this.Message = opts.Message;
}
}
class CidrCollectionVersionMismatchException extends Route53ServiceException {
name = "CidrCollectionVersionMismatchException";
$fault = "client";
Message;
constructor(opts) {
super({
name: "CidrCollectionVersionMismatchException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, CidrCollectionVersionMismatchException.prototype);
this.Message = opts.Message;
}
}
class NoSuchCidrCollectionException extends Route53ServiceException {
name = "NoSuchCidrCollectionException";
$fault = "client";
Message;
constructor(opts) {
super({
name: "NoSuchCidrCollectionException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, NoSuchCidrCollectionException.prototype);
this.Message = opts.Message;
}
}
class InvalidChangeBatch extends Route53ServiceException {
name = "InvalidChangeBatch";
$fault = "client";
messages;
constructor(opts) {
super({
name: "InvalidChangeBatch",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidChangeBatch.prototype);
this.messages = opts.messages;
}
}
class NoSuchHealthCheck extends Route53ServiceException {
name = "NoSuchHealthCheck";
$fault = "client";
constructor(opts) {
super({
name: "NoSuchHealthCheck",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, NoSuchHealthCheck.prototype);
}
}
class ThrottlingException extends Route53ServiceException {
name = "ThrottlingException";
$fault = "client";
constructor(opts) {
super({
name: "ThrottlingException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, ThrottlingException.prototype);
}
}
class CidrCollectionAlreadyExistsException extends Route53ServiceException {
name = "CidrCollectionAlreadyExistsException";
$fault = "client";
Message;
constructor(opts) {
super({
name: "CidrCollectionAlreadyExistsException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, CidrCollectionAlreadyExistsException.prototype);
this.Message = opts.Message;
}
}
class HealthCheckAlreadyExists extends Route53ServiceException {
name = "HealthCheckAlreadyExists";
$fault = "client";
constructor(opts) {
super({
name: "HealthCheckAlreadyExists",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, HealthCheckAlreadyExists.prototype);
}
}
class TooManyHealthChecks extends Route53ServiceException {
name = "TooManyHealthChecks";
$fault = "client";
constructor(opts) {
super({
name: "TooManyHealthChecks",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TooManyHealthChecks.prototype);
}
}
class DelegationSetNotAvailable extends Route53ServiceException {
name = "DelegationSetNotAvailable";
$fault = "client";
constructor(opts) {
super({
name: "DelegationSetNotAvailable",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, DelegationSetNotAvailable.prototype);
}
}
class DelegationSetNotReusable extends Route53ServiceException {
name = "DelegationSetNotReusable";
$fault = "client";
constructor(opts) {
super({
name: "DelegationSetNotReusable",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, DelegationSetNotReusable.prototype);
}
}
class HostedZoneAlreadyExists extends Route53ServiceException {
name = "HostedZoneAlreadyExists";
$fault = "client";
constructor(opts) {
super({
name: "HostedZoneAlreadyExists",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, HostedZoneAlreadyExists.prototype);
}
}
class InvalidDomainName extends Route53ServiceException {
name = "InvalidDomainName";
$fault = "client";
constructor(opts) {
super({
name: "InvalidDomainName",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidDomainName.prototype);
}
}
class NoSuchDelegationSet extends Route53ServiceException {
name = "NoSuchDelegationSet";
$fault = "client";
constructor(opts) {
super({
name: "NoSuchDelegationSet",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, NoSuchDelegationSet.prototype);
}
}
class TooManyHostedZones extends Route53ServiceException {
name = "TooManyHostedZones";
$fault = "client";
constructor(opts) {
super({
name: "TooManyHostedZones",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TooManyHostedZones.prototype);
}
}
class InvalidArgument extends Route53ServiceException {
name = "InvalidArgument";
$fault = "client";
constructor(opts) {
super({
name: "InvalidArgument",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidArgument.prototype);
}
}
class InvalidKeySigningKeyName extends Route53ServiceException {
name = "InvalidKeySigningKeyName";
$fault = "client";
constructor(opts) {
super({
name: "InvalidKeySigningKeyName",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidKeySigningKeyName.prototype);
}
}
class KeySigningKeyAlreadyExists extends Route53ServiceException {
name = "KeySigningKeyAlreadyExists";
$fault = "client";
constructor(opts) {
super({
name: "KeySigningKeyAlreadyExists",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, KeySigningKeyAlreadyExists.prototype);
}
}
class TooManyKeySigningKeys extends Route53ServiceException {
name = "TooManyKeySigningKeys";
$fault = "client";
constructor(opts) {
super({
name: "TooManyKeySigningKeys",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TooManyKeySigningKeys.prototype);
}
}
class InsufficientCloudWatchLogsResourcePolicy extends Route53ServiceException {
name = "InsufficientCloudWatchLogsResourcePolicy";
$fault = "client";
constructor(opts) {
super({
name: "InsufficientCloudWatchLogsResourcePolicy",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InsufficientCloudWatchLogsResourcePolicy.prototype);
}
}
class NoSuchCloudWatchLogsLogGroup extends Route53ServiceException {
name = "NoSuchCloudWatchLogsLogGroup";
$fault = "client";
constructor(opts) {
super({
name: "NoSuchCloudWatchLogsLogGroup",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, NoSuchCloudWatchLogsLogGroup.prototype);
}
}
class QueryLoggingConfigAlreadyExists extends Route53ServiceException {
name = "QueryLoggingConfigAlreadyExists";
$fault = "client";
constructor(opts) {
super({
name: "QueryLoggingConfigAlreadyExists",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, QueryLoggingConfigAlreadyExists.prototype);
}
}
class DelegationSetAlreadyCreated extends Route53ServiceException {
name = "DelegationSetAlreadyCreated";
$fault = "client";
constructor(opts) {
super({
name: "DelegationSetAlreadyCreated",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, DelegationSetAlreadyCreated.prototype);
}
}
class DelegationSetAlreadyReusable extends Route53ServiceException {
name = "DelegationSetAlreadyReusable";
$fault = "client";
constructor(opts) {
super({
name: "DelegationSetAlreadyReusable",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, DelegationSetAlreadyReusable.prototype);
}
}
class HostedZoneNotFound extends Route53ServiceException {
name = "HostedZoneNotFound";
$fault = "client";
constructor(opts) {
super({
name: "HostedZoneNotFound",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, HostedZoneNotFound.prototype);
}
}
class InvalidTrafficPolicyDocument extends Route53ServiceException {
name = "InvalidTrafficPolicyDocument";
$fault = "client";
constructor(opts) {
super({
name: "InvalidTrafficPolicyDocument",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidTrafficPolicyDocument.prototype);
}
}
class TooManyTrafficPolicies extends Route53ServiceException {
name = "TooManyTrafficPolicies";
$fault = "client";
constructor(opts) {
super({
name: "TooManyTrafficPolicies",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TooManyTrafficPolicies.prototype);
}
}
class TrafficPolicyAlreadyExists extends Route53ServiceException {
name = "TrafficPolicyAlreadyExists";
$fault = "client";
constructor(opts) {
super({
name: "TrafficPolicyAlreadyExists",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TrafficPolicyAlreadyExists.prototype);
}
}
class NoSuchTrafficPolicy extends Route53ServiceException {
name = "NoSuchTrafficPolicy";
$fault = "client";
constructor(opts) {
super({
name: "NoSuchTrafficPolicy",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, NoSuchTrafficPolicy.prototype);
}
}
class TooManyTrafficPolicyInstances extends Route53ServiceException {
name = "TooManyTrafficPolicyInstances";
$fault = "client";
constructor(opts) {
super({
name: "TooManyTrafficPolicyInstances",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TooManyTrafficPolicyInstances.prototype);
}
}
class TrafficPolicyInstanceAlreadyExists extends Route53ServiceException {
name = "TrafficPolicyInstanceAlreadyExists";
$fault = "client";
constructor(opts) {
super({
name: "TrafficPolicyInstanceAlreadyExists",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TrafficPolicyInstanceAlreadyExists.prototype);
}
}
class TooManyTrafficPolicyVersionsForCurrentPolicy extends Route53ServiceException {
name = "TooManyTrafficPolicyVersionsForCurrentPolicy";
$fault = "client";
constructor(opts) {
super({
name: "TooManyTrafficPolicyVersionsForCurrentPolicy",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TooManyTrafficPolicyVersionsForCurrentPolicy.prototype);
}
}
class TooManyVPCAssociationAuthorizations extends Route53ServiceException {
name = "TooManyVPCAssociationAuthorizations";
$fault = "client";
constructor(opts) {
super({
name: "TooManyVPCAssociationAuthorizations",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TooManyVPCAssociationAuthorizations.prototype);
}
}
class KeySigningKeyInParentDSRecord extends Route53ServiceException {
name = "KeySigningKeyInParentDSRecord";
$fault = "client";
constructor(opts) {
super({
name: "KeySigningKeyInParentDSRecord",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, KeySigningKeyInParentDSRecord.prototype);
}
}
class KeySigningKeyInUse extends Route53ServiceException {
name = "KeySigningKeyInUse";
$fault = "client";
constructor(opts) {
super({
name: "KeySigningKeyInUse",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, KeySigningKeyInUse.prototype);
}
}
class CidrCollectionInUseException extends Route53ServiceException {
name = "CidrCollectionInUseException";
$fault = "client";
Message;
constructor(opts) {
super({
name: "CidrCollectionInUseException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, CidrCollectionInUseException.prototype);
this.Message = opts.Message;
}
}
class HealthCheckInUse extends Route53ServiceException {
name = "HealthCheckInUse";
$fault = "client";
constructor(opts) {
super({
name: "HealthCheckInUse",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, HealthCheckInUse.prototype);
}
}
class HostedZoneNotEmpty extends Route53ServiceException {
name = "HostedZoneNotEmpty";
$fault = "client";
constructor(opts) {
super({
name: "HostedZoneNotEmpty",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, HostedZoneNotEmpty.prototype);
}
}
class NoSuchQueryLoggingConfig extends Route53ServiceException {
name = "NoSuchQueryLoggingConfig";
$fault = "client";
constructor(opts) {
super({
name: "NoSuchQueryLoggingConfig",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, NoSuchQueryLoggingConfig.prototype);
}
}
class DelegationSetInUse extends Route53ServiceException {
name = "DelegationSetInUse";
$fault = "client";
constructor(opts) {
super({
name: "DelegationSetInUse",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, DelegationSetInUse.prototype);
}
}
class TrafficPolicyInUse extends Route53ServiceException {
name = "TrafficPolicyInUse";
$fault = "client";
constructor(opts) {
super({
name: "TrafficPolicyInUse",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TrafficPolicyInUse.prototype);
}
}
class NoSuchTrafficPolicyInstance extends Route53ServiceException {
name = "NoSuchTrafficPolicyInstance";
$fault = "client";
constructor(opts) {
super({
name: "NoSuchTrafficPolicyInstance",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, NoSuchTrafficPolicyInstance.prototype);
}
}
class VPCAssociationAuthorizationNotFound extends Route53ServiceException {
name = "VPCAssociationAuthorizationNotFound";
$fault = "client";
constructor(opts) {
super({
name: "VPCAssociationAuthorizationNotFound",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, VPCAssociationAuthorizationNotFound.prototype);
}
}
class DNSSECNotFound extends Route53ServiceException {
name = "DNSSECNotFound";
$fault = "client";
constructor(opts) {
super({
name: "DNSSECNotFound",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, DNSSECNotFound.prototype);
}
}
class LastVPCAssociation extends Route53ServiceException {
name = "LastVPCAssociation";
$fault = "client";
constructor(opts) {
super({
name: "LastVPCAssociation",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, LastVPCAssociation.prototype);
}
}
class VPCAssociationNotFound extends Route53ServiceException {
name = "VPCAssociationNotFound";
$fault = "client";
constructor(opts) {
super({
name: "VPCAssociationNotFound",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, VPCAssociationNotFound.prototype);
}
}
class HostedZonePartiallyDelegated extends Route53ServiceException {
name = "HostedZonePartiallyDelegated";
$fault = "client";
constructor(opts) {
super({
name: "HostedZonePartiallyDelegated",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, HostedZonePartiallyDelegated.prototype);
}
}
class KeySigningKeyWithActiveStatusNotFound extends Route53ServiceException {
name = "KeySigningKeyWithActiveStatusNotFound";
$fault = "client";
constructor(opts) {
super({
name: "KeySigningKeyWithActiveStatusNotFound",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, KeySigningKeyWithActiveStatusNotFound.prototype);
}
}
class NoSuchChange extends Route53ServiceException {
name = "NoSuchChange";
$fault = "client";
constructor(opts) {
super({
name: "NoSuchChange",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, NoSuchChange.prototype);
}
}
class NoSuchGeoLocation extends Route53ServiceException {
name = "NoSuchGeoLocation";
$fault = "client";
constructor(opts) {
super({
name: "NoSuchGeoLocation",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, NoSuchGeoLocation.prototype);
}
}
class IncompatibleVersion extends Route53ServiceException {
name = "IncompatibleVersion";
$fault = "client";
constructor(opts) {
super({
name: "IncompatibleVersion",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, IncompatibleVersion.prototype);
}
}
class HostedZoneNotPrivate extends Route53ServiceException {
name = "HostedZoneNotPrivate";
$fault = "client";
constructor(opts) {
super({
name: "HostedZoneNotPrivate",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, HostedZoneNotPrivate.prototype);
}
}
class NoSuchCidrLocationException extends Route53ServiceException {
name = "NoSuchCidrLocationException";
$fault = "client";
Message;
constructor(opts) {
super({
name: "NoSuchCidrLocationException",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, NoSuchCidrLocationException.prototype);
this.Message = opts.Message;
}
}
class InvalidPaginationToken extends Route53ServiceException {
name = "InvalidPaginationToken";
$fault = "client";
constructor(opts) {
super({
name: "InvalidPaginationToken",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidPaginationToken.prototype);
}
}
class HealthCheckVersionMismatch extends Route53ServiceException {
name = "HealthCheckVersionMismatch";
$fault = "client";
constructor(opts) {
super({
name: "HealthCheckVersionMismatch",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, HealthCheckVersionMismatch.prototype);
}
}
class ConflictingTypes extends Route53ServiceException {
name = "ConflictingTypes";
$fault = "client";
constructor(opts) {
super({
name: "ConflictingTypes",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, ConflictingTypes.prototype);
}
}
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/schemas/schemas_0.js
var _A = "Action";
var _AI = "AlarmIdentifier";
var _AKSK = "ActivateKeySigningKey";
var _AKSKR = "ActivateKeySigningKeyRequest";
var _AKSKRc = "ActivateKeySigningKeyResponse";
var _AL = "AccountLimit";
var _AR = "AcceleratedRecovery";
var _ARS = "AcceleratedRecoveryStatus";
var _AT = "AliasTarget";
var _ATd = "AddTags";
var _AVPCWHZ = "AssociateVPCWithHostedZone";
var _AVPCWHZR = "AssociateVPCWithHostedZoneRequest";
var _AVPCWHZRs = "AssociateVPCWithHostedZoneResponse";
var _AWSR = "AWSRegion";
var _Ar = "Arn";
var _B = "Bias";
var _C = "Comment";
var _CB = "ChangeBatch";
var _CBIUE = "CidrBlockInUseException";
var _CBS = "CidrBlockSummary";
var _CBSi = "CidrBlockSummaries";
var _CBi = "CidrBlock";
var _CBid = "CidrBlocks";
var _CC = "CidrCollection";
var _CCAEE = "CidrCollectionAlreadyExistsException";
var _CCC = "CidrCollectionChange";
var _CCCR = "ChangeCidrCollectionRequest";
var _CCCRh = "ChangeCidrCollectionResponse";
var _CCCRr = "CreateCidrCollectionRequest";
var _CCCRre = "CreateCidrCollectionResponse";
var _CCCh = "ChangeCidrCollection";
var _CCCi = "CidrCollectionChanges";
var _CCCr = "CreateCidrCollection";
var _CCIUE = "CidrCollectionInUseException";
var _CCVME = "CidrCollectionVersionMismatchException";
var _CCi = "CidrCollections";
var _CCo = "ContinentCode";
var _CCou = "CountryCode";
var _CD = "CreatedDate";
var _CDE = "ConflictingDomainExists";
var _CHC = "ChildHealthChecks";
var _CHCL = "ChildHealthCheckList";
var _CHCR = "CreateHealthCheckRequest";
var _CHCRr = "CreateHealthCheckResponse";
var _CHCh = "ChildHealthCheck";
var _CHCr = "CreateHealthCheck";
var _CHZ = "CreateHostedZone";
var _CHZR = "CreateHostedZoneRequest";
var _CHZRr = "CreateHostedZoneResponse";
var _CI = "ChangeInfo";
var _CIR = "CheckerIpRanges";
var _CIo = "CollectionId";
var _CKSK = "CreateKeySigningKey";
var _CKSKR = "CreateKeySigningKeyRequest";
var _CKSKRr = "CreateKeySigningKeyResponse";
var _CL = "CidrList";
var _CLi = "CidrLocations";
var _CM = "ConcurrentModification";
var _CN = "ContinentName";
var _CNo = "CountryName";
var _CO = "ComparisonOperator";
var _CQLC = "CreateQueryLoggingConfig";
var _CQLCR = "CreateQueryLoggingConfigRequest";
var _CQLCRr = "CreateQueryLoggingConfigResponse";
var _CR = "CallerReference";
var _CRC = "CidrRoutingConfig";
var _CRDS = "CreateReusableDelegationSet";
var _CRDSR = "CreateReusableDelegationSetRequest";
var _CRDSRr = "CreateReusableDelegationSetResponse";
var _CRRS = "ChangeResourceRecordSets";
var _CRRSR = "ChangeResourceRecordSetsRequest";
var _CRRSRh = "ChangeResourceRecordSetsResponse";
var _CS = "CollectionSummary";
var _CSo = "CollectionSummaries";
var _CT = "ConflictingTypes";
var _CTFR = "ChangeTagsForResource";
var _CTFRR = "ChangeTagsForResourceRequest";
var _CTFRRh = "ChangeTagsForResourceResponse";
var _CTP = "CreateTrafficPolicy";
var _CTPI = "CreateTrafficPolicyInstance";
var _CTPIR = "CreateTrafficPolicyInstanceRequest";
var _CTPIRr = "CreateTrafficPolicyInstanceResponse";
var _CTPR = "CreateTrafficPolicyRequest";
var _CTPRr = "CreateTrafficPolicyResponse";
var _CTPV = "CreateTrafficPolicyVersion";
var _CTPVR = "CreateTrafficPolicyVersionRequest";
var _CTPVRr = "CreateTrafficPolicyVersionResponse";
var _CTh = "CheckedTime";
var _CV = "CollectionVersion";
var _CVPCAA = "CreateVPCAssociationAuthorization";
var _CVPCAAR = "CreateVPCAssociationAuthorizationRequest";
var _CVPCAARr = "CreateVPCAssociationAuthorizationResponse";
var _CWAC = "CloudWatchAlarmConfiguration";
var _CWLLGA = "CloudWatchLogsLogGroupArn";
var _Ch = "Change";
var _Cha = "Changes";
var _Ci = "Cidr";
var _Co = "Coordinates";
var _Col = "Collection";
var _Con = "Config";
var _Cou = "Count";
var _D = "Dimensions";
var _DAM = "DigestAlgorithmMnemonic";
var _DAT = "DigestAlgorithmType";
var _DCC = "DeleteCidrCollection";
var _DCCR = "DeleteCidrCollectionRequest";
var _DCCRe = "DeleteCidrCollectionResponse";
var _DHC = "DeleteHealthCheck";
var _DHCR = "DeleteHealthCheckRequest";
var _DHCRe = "DeleteHealthCheckResponse";
var _DHZ = "DeleteHostedZone";
var _DHZDNSSEC = "DisableHostedZoneDNSSEC";
var _DHZDNSSECR = "DisableHostedZoneDNSSECRequest";
var _DHZDNSSECRi = "DisableHostedZoneDNSSECResponse";
var _DHZR = "DeleteHostedZoneRequest";
var _DHZRe = "DeleteHostedZoneResponse";
var _DKSK = "DeactivateKeySigningKey";
var _DKSKR = "DeactivateKeySigningKeyRequest";
var _DKSKRe = "DeactivateKeySigningKeyResponse";
var _DKSKRel = "DeleteKeySigningKeyRequest";
var _DKSKRele = "DeleteKeySigningKeyResponse";
var _DKSKe = "DeleteKeySigningKey";
var _DL = "DimensionList";
var _DNSKEYR = "DNSKEYRecord";
var _DNSN = "DNSName";
var _DNSSECNF = "DNSSECNotFound";
var _DNSSECS = "DNSSECStatus";
var _DQLC = "DeleteQueryLoggingConfig";
var _DQLCR = "DeleteQueryLoggingConfigRequest";
var _DQLCRe = "DeleteQueryLoggingConfigResponse";
var _DRDS = "DeleteReusableDelegationSet";
var _DRDSR = "DeleteReusableDelegationSetRequest";
var _DRDSRe = "DeleteReusableDelegationSetResponse";
var _DS = "DelegationSet";
var _DSAC = "DelegationSetAlreadyCreated";
var _DSAR = "DelegationSetAlreadyReusable";
var _DSI = "DelegationSetId";
var _DSIU = "DelegationSetInUse";
var _DSNA = "DelegationSetNotAvailable";
var _DSNR = "DelegationSetNotReusable";
var _DSNS = "DelegationSetNameServers";
var _DSR = "DSRecord";
var _DSe = "DelegationSets";
var _DTP = "DeleteTrafficPolicy";
var _DTPI = "DeleteTrafficPolicyInstance";
var _DTPIR = "DeleteTrafficPolicyInstanceRequest";
var _DTPIRe = "DeleteTrafficPolicyInstanceResponse";
var _DTPR = "DeleteTrafficPolicyRequest";
var _DTPRe = "DeleteTrafficPolicyResponse";
var _DV = "DigestValue";
var _DVPCAA = "DeleteVPCAssociationAuthorization";
var _DVPCAAR = "DeleteVPCAssociationAuthorizationRequest";
var _DVPCAARe = "DeleteVPCAssociationAuthorizationResponse";
var _DVPCFHZ = "DisassociateVPCFromHostedZone";
var _DVPCFHZR = "DisassociateVPCFromHostedZoneRequest";
var _DVPCFHZRi = "DisassociateVPCFromHostedZoneResponse";
var _De = "Description";
var _Di = "Dimension";
var _Dis = "Disabled";
var _Do = "Document";
var _EAR = "EnableAcceleratedRecovery";
var _EDNSCSIP = "EDNS0ClientSubnetIP";
var _EDNSCSM = "EDNS0ClientSubnetMask";
var _EHZDNSSEC = "EnableHostedZoneDNSSEC";
var _EHZDNSSECR = "EnableHostedZoneDNSSECRequest";
var _EHZDNSSECRn = "EnableHostedZoneDNSSECResponse";
var _EM = "ErrorMessages";
var _EP = "EvaluationPeriods";
var _ESNI = "EnableSNI";
var _ETH = "EvaluateTargetHealth";
var _F = "Features";
var _FQDN = "FullyQualifiedDomainName";
var _FR = "FailureReasons";
var _FT = "FailureThreshold";
var _Fa = "Failover";
var _Fl = "Flag";
var _GAL = "GetAccountLimit";
var _GALR = "GetAccountLimitRequest";
var _GALRe = "GetAccountLimitResponse";
var _GC = "GetChange";
var _GCIR = "GetCheckerIpRanges";
var _GCIRR = "GetCheckerIpRangesRequest";
var _GCIRRe = "GetCheckerIpRangesResponse";
var _GCR = "GetChangeRequest";
var _GCRe = "GetChangeResponse";
var _GDNSSEC = "GetDNSSEC";
var _GDNSSECR = "GetDNSSECRequest";
var _GDNSSECRe = "GetDNSSECResponse";
var _GGL = "GetGeoLocation";
var _GGLR = "GetGeoLocationRequest";
var _GGLRe = "GetGeoLocationResponse";
var _GHC = "GetHealthCheck";
var _GHCC = "GetHealthCheckCount";
var _GHCCR = "GetHealthCheckCountRequest";
var _GHCCRe = "GetHealthCheckCountResponse";
var _GHCLFR = "GetHealthCheckLastFailureReason";
var _GHCLFRR = "GetHealthCheckLastFailureReasonRequest";
var _GHCLFRRe = "GetHealthCheckLastFailureReasonResponse";
var _GHCR = "GetHealthCheckRequest";
var _GHCRe = "GetHealthCheckResponse";
var _GHCS = "GetHealthCheckStatus";
var _GHCSR = "GetHealthCheckStatusRequest";
var _GHCSRe = "GetHealthCheckStatusResponse";
var _GHZ = "GetHostedZone";
var _GHZC = "GetHostedZoneCount";
var _GHZCR = "GetHostedZoneCountRequest";
var _GHZCRe = "GetHostedZoneCountResponse";
var _GHZL = "GetHostedZoneLimit";
var _GHZLR = "GetHostedZoneLimitRequest";
var _GHZLRe = "GetHostedZoneLimitResponse";
var _GHZR = "GetHostedZoneRequest";
var _GHZRe = "GetHostedZoneResponse";
var _GL = "GeoLocation";
var _GLD = "GeoLocationDetails";
var _GLDL = "GeoLocationDetailsList";
var _GPL = "GeoProximityLocation";
var _GQLC = "GetQueryLoggingConfig";
var _GQLCR = "GetQueryLoggingConfigRequest";
var _GQLCRe = "GetQueryLoggingConfigResponse";
var _GRDS = "GetReusableDelegationSet";
var _GRDSL = "GetReusableDelegationSetLimit";
var _GRDSLR = "GetReusableDelegationSetLimitRequest";
var _GRDSLRe = "GetReusableDelegationSetLimitResponse";
var _GRDSR = "GetReusableDelegationSetRequest";
var _GRDSRe = "GetReusableDelegationSetResponse";
var _GTP = "GetTrafficPolicy";
var _GTPI = "GetTrafficPolicyInstance";
var _GTPIC = "GetTrafficPolicyInstanceCount";
var _GTPICR = "GetTrafficPolicyInstanceCountRequest";
var _GTPICRe = "GetTrafficPolicyInstanceCountResponse";
var _GTPIR = "GetTrafficPolicyInstanceRequest";
var _GTPIRe = "GetTrafficPolicyInstanceResponse";
var _GTPR = "GetTrafficPolicyRequest";
var _GTPRe = "GetTrafficPolicyResponse";
var _HC = "HealthCheck";
var _HCAE = "HealthCheckAlreadyExists";
var _HCC = "HealthCheckConfig";
var _HCCe = "HealthCheckCount";
var _HCI = "HealthCheckId";
var _HCIU = "HealthCheckInUse";
var _HCO = "HealthCheckObservations";
var _HCOe = "HealthCheckObservation";
var _HCRL = "HealthCheckRegionList";
var _HCV = "HealthCheckVersion";
var _HCVM = "HealthCheckVersionMismatch";
var _HCe = "HealthChecks";
var _HT = "HealthThreshold";
var _HZ = "HostedZone";
var _HZAE = "HostedZoneAlreadyExists";
var _HZC = "HostedZoneConfig";
var _HZCo = "HostedZoneCount";
var _HZF = "HostedZoneFeatures";
var _HZFR = "HostedZoneFailureReasons";
var _HZI = "HostedZoneId";
var _HZIM = "HostedZoneIdMarker";
var _HZL = "HostedZoneLimit";
var _HZNE = "HostedZoneNotEmpty";
var _HZNF = "HostedZoneNotFound";
var _HZNP = "HostedZoneNotPrivate";
var _HZO = "HostedZoneOwner";
var _HZPD = "HostedZonePartiallyDelegated";
var _HZS = "HostedZoneSummary";
var _HZSo = "HostedZoneSummaries";
var _HZT = "HostedZoneType";
var _HZo = "HostedZones";
var _I = "Id";
var _IA = "InvalidArgument";
var _ICB = "InvalidChangeBatch";
var _ICWLRP = "InsufficientCloudWatchLogsResourcePolicy";
var _IDHS = "InsufficientDataHealthStatus";
var _IDN = "InvalidDomainName";
var _II = "InvalidInput";
var _IKMSA = "InvalidKMSArn";
var _IKSKN = "InvalidKeySigningKeyName";
var _IKSKS = "InvalidKeySigningKeyStatus";
var _IPA = "IPAddress";
var _IPT = "InvalidPaginationToken";
var _ISS = "InvalidSigningStatus";
var _IT = "IsTruncated";
var _ITPD = "InvalidTrafficPolicyDocument";
var _IV = "IncompatibleVersion";
var _IVPCI = "InvalidVPCId";
var _In = "Inverted";
var _K = "Key";
var _KA = "KmsArn";
var _KMSA = "KeyManagementServiceArn";
var _KSK = "KeySigningKey";
var _KSKAE = "KeySigningKeyAlreadyExists";
var _KSKIPDSR = "KeySigningKeyInParentDSRecord";
var _KSKIU = "KeySigningKeyInUse";
var _KSKWASNF = "KeySigningKeyWithActiveStatusNotFound";
var _KSKe = "KeySigningKeys";
var _KT = "KeyTag";
var _L = "Latitude";
var _LCB = "ListCidrBlocks";
var _LCBR = "ListCidrBlocksRequest";
var _LCBRi = "ListCidrBlocksResponse";
var _LCC = "ListCidrCollections";
var _LCCR = "ListCidrCollectionsRequest";
var _LCCRi = "ListCidrCollectionsResponse";
var _LCL = "ListCidrLocations";
var _LCLR = "ListCidrLocationsRequest";
var _LCLRi = "ListCidrLocationsResponse";
var _LE = "LimitsExceeded";
var _LGL = "ListGeoLocations";
var _LGLR = "ListGeoLocationsRequest";
var _LGLRi = "ListGeoLocationsResponse";
var _LHC = "ListHealthChecks";
var _LHCR = "ListHealthChecksRequest";
var _LHCRi = "ListHealthChecksResponse";
var _LHZ = "ListHostedZones";
var _LHZBN = "ListHostedZonesByName";
var _LHZBNR = "ListHostedZonesByNameRequest";
var _LHZBNRi = "ListHostedZonesByNameResponse";
var _LHZBVPC = "ListHostedZonesByVPC";
var _LHZBVPCR = "ListHostedZonesByVPCRequest";
var _LHZBVPCRi = "ListHostedZonesByVPCResponse";
var _LHZR = "ListHostedZonesRequest";
var _LHZRi = "ListHostedZonesResponse";
var _LMD = "LastModifiedDate";
var _LN = "LocationName";
var _LQLC = "ListQueryLoggingConfigs";
var _LQLCR = "ListQueryLoggingConfigsRequest";
var _LQLCRi = "ListQueryLoggingConfigsResponse";
var _LRDS = "ListReusableDelegationSets";
var _LRDSR = "ListReusableDelegationSetsRequest";
var _LRDSRi = "ListReusableDelegationSetsResponse";
var _LRRS = "ListResourceRecordSets";
var _LRRSR = "ListResourceRecordSetsRequest";
var _LRRSRi = "ListResourceRecordSetsResponse";
var _LS = "LinkedService";
var _LSo = "LocationSummary";
var _LSoc = "LocationSummaries";
var _LTFR = "ListTagsForResource";
var _LTFRR = "ListTagsForResourceRequest";
var _LTFRRi = "ListTagsForResourceResponse";
var _LTFRRis = "ListTagsForResourcesRequest";
var _LTFRRist = "ListTagsForResourcesResponse";
var _LTFRi = "ListTagsForResources";
var _LTP = "ListTrafficPolicies";
var _LTPI = "ListTrafficPolicyInstances";
var _LTPIBHZ = "ListTrafficPolicyInstancesByHostedZone";
var _LTPIBHZR = "ListTrafficPolicyInstancesByHostedZoneRequest";
var _LTPIBHZRi = "ListTrafficPolicyInstancesByHostedZoneResponse";
var _LTPIBP = "ListTrafficPolicyInstancesByPolicy";
var _LTPIBPR = "ListTrafficPolicyInstancesByPolicyRequest";
var _LTPIBPRi = "ListTrafficPolicyInstancesByPolicyResponse";
var _LTPIR = "ListTrafficPolicyInstancesRequest";
var _LTPIRi = "ListTrafficPolicyInstancesResponse";
var _LTPR = "ListTrafficPoliciesRequest";
var _LTPRi = "ListTrafficPoliciesResponse";
var _LTPV = "ListTrafficPolicyVersions";
var _LTPVR = "ListTrafficPolicyVersionsRequest";
var _LTPVRi = "ListTrafficPolicyVersionsResponse";
var _LV = "LatestVersion";
var _LVPCA = "LastVPCAssociation";
var _LVPCAA = "ListVPCAssociationAuthorizations";
var _LVPCAAR = "ListVPCAssociationAuthorizationsRequest";
var _LVPCAARi = "ListVPCAssociationAuthorizationsResponse";
var _LZG = "LocalZoneGroup";
var _Li = "Limit";
var _Lo = "Longitude";
var _Loc = "Location";
var _M = "Message";
var _MI = "MaxItems";
var _ML = "MeasureLatency";
var _MN = "MetricName";
var _MR = "MaxResults";
var _MVA = "MultiValueAnswer";
var _Ma = "Marker";
var _N = "Name";
var _NAE = "NotAuthorizedException";
var _NCC = "NextContinentCode";
var _NCCe = "NextCountryCode";
var _NDNSN = "NextDNSName";
var _NHZI = "NextHostedZoneId";
var _NM = "NextMarker";
var _NRI = "NextRecordIdentifier";
var _NRN = "NextRecordName";
var _NRT = "NextRecordType";
var _NS = "NameServers";
var _NSC = "NoSuchChange";
var _NSCCE = "NoSuchCidrCollectionException";
var _NSCLE = "NoSuchCidrLocationException";
var _NSCWLLG = "NoSuchCloudWatchLogsLogGroup";
var _NSCe = "NextSubdivisionCode";
var _NSDS = "NoSuchDelegationSet";
var _NSGL = "NoSuchGeoLocation";
var _NSHC = "NoSuchHealthCheck";
var _NSHZ = "NoSuchHostedZone";
var _NSKSK = "NoSuchKeySigningKey";
var _NSQLC = "NoSuchQueryLoggingConfig";
var _NSTP = "NoSuchTrafficPolicy";
var _NSTPI = "NoSuchTrafficPolicyInstance";
var _NSa = "NameServer";
var _NT = "NextToken";
var _Na = "Namespace";
var _Nam = "Nameserver";
var _O = "Owner";
var _OA = "OwningAccount";
var _OS = "OwningService";
var _P = "Period";
var _PK = "PublicKey";
var _PRNC = "PriorRequestNotComplete";
var _PZ = "PrivateZone";
var _PZVPCA = "PublicZoneVPCAssociation";
var _Po = "Port";
var _Pr = "Protocol";
var _QLC = "QueryLoggingConfig";
var _QLCAE = "QueryLoggingConfigAlreadyExists";
var _QLCu = "QueryLoggingConfigs";
var _R = "Region";
var _RC2 = "ResponseCode";
var _RCA = "RoutingControlArn";
var _RD = "RecordData";
var _RDE = "RecordDataEntry";
var _RDSL = "ReusableDelegationSetLimit";
var _RE = "ResetElements";
var _REN = "ResettableElementName";
var _RENL = "ResettableElementNameList";
var _RI = "ResourceId";
var _RIP = "ResolverIP";
var _RIe = "RequestInterval";
var _RIes = "ResourceIds";
var _RN = "RecordName";
var _RP = "ResourcePath";
var _RR = "ResourceRecord";
var _RRS = "ResourceRecordSet";
var _RRSC = "ResourceRecordSetCount";
var _RRSe = "ResourceRecordSets";
var _RRe = "ResourceRecords";
var _RT = "ResourceType";
var _RTK = "RemoveTagKeys";
var _RTS = "ResourceTagSet";
var _RTSL = "ResourceTagSetList";
var _RTSe = "ResourceTagSets";
var _RTe = "RecordType";
var _Re = "Regions";
var _S = "Status";
var _SA = "SubmittedAt";
var _SAM = "SigningAlgorithmMnemonic";
var _SAT = "SigningAlgorithmType";
var _SC = "SubdivisionCode";
var _SCC = "StartContinentCode";
var _SCCt = "StartCountryCode";
var _SI = "SetIdentifier";
var _SM = "StatusMessage";
var _SN = "SubdivisionName";
var _SP = "ServicePrincipal";
var _SR = "StatusReport";
var _SRI = "StartRecordIdentifier";
var _SRN = "StartRecordName";
var _SRT = "StartRecordType";
var _SS = "ServeSignature";
var _SSC = "StartSubdivisionCode";
var _SSe = "SearchString";
var _St = "Statistic";
var _Sta = "State";
var _T = "Type";
var _TDNSA = "TestDNSAnswer";
var _TDNSAR = "TestDNSAnswerRequest";
var _TDNSARe = "TestDNSAnswerResponse";
var _TE = "ThrottlingException";
var _TKL = "TagKeyList";
var _TL = "TagList";
var _TMHC = "TooManyHealthChecks";
var _TMHZ = "TooManyHostedZones";
var _TMKSK = "TooManyKeySigningKeys";
var _TMTP = "TooManyTrafficPolicies";
var _TMTPI = "TooManyTrafficPolicyInstances";
var _TMTPVFCP = "TooManyTrafficPolicyVersionsForCurrentPolicy";
var _TMVPCAA = "TooManyVPCAssociationAuthorizations";
var _TP = "TrafficPolicy";
var _TPAE = "TrafficPolicyAlreadyExists";
var _TPC = "TrafficPolicyCount";
var _TPI = "TrafficPolicyId";
var _TPIAE = "TrafficPolicyInstanceAlreadyExists";
var _TPIC = "TrafficPolicyInstanceCount";
var _TPII = "TrafficPolicyInstanceId";
var _TPIM = "TrafficPolicyIdMarker";
var _TPINM = "TrafficPolicyInstanceNameMarker";
var _TPITM = "TrafficPolicyInstanceTypeMarker";
var _TPIU = "TrafficPolicyInUse";
var _TPIr = "TrafficPolicyInstance";
var _TPIra = "TrafficPolicyInstances";
var _TPS = "TrafficPolicySummaries";
var _TPSr = "TrafficPolicySummary";
var _TPT = "TrafficPolicyType";
var _TPV = "TrafficPolicyVersion";
var _TPVM = "TrafficPolicyVersionMarker";
var _TPr = "TrafficPolicies";
var _TRIL = "TagResourceIdList";
var _TTL = "TTL";
var _Ta = "Tags";
var _Tag = "Tag";
var _Th = "Threshold";
var _UHC = "UpdateHealthCheck";
var _UHCR = "UpdateHealthCheckRequest";
var _UHCRp = "UpdateHealthCheckResponse";
var _UHZC = "UpdateHostedZoneComment";
var _UHZCR = "UpdateHostedZoneCommentRequest";
var _UHZCRp = "UpdateHostedZoneCommentResponse";
var _UHZF = "UpdateHostedZoneFeatures";
var _UHZFR = "UpdateHostedZoneFeaturesRequest";
var _UHZFRp = "UpdateHostedZoneFeaturesResponse";
var _UTPC = "UpdateTrafficPolicyComment";
var _UTPCR = "UpdateTrafficPolicyCommentRequest";
var _UTPCRp = "UpdateTrafficPolicyCommentResponse";
var _UTPI = "UpdateTrafficPolicyInstance";
var _UTPIR = "UpdateTrafficPolicyInstanceRequest";
var _UTPIRp = "UpdateTrafficPolicyInstanceResponse";
var _V = "Value";
var _VPC = "VPC";
var _VPCAANF = "VPCAssociationAuthorizationNotFound";
var _VPCANF = "VPCAssociationNotFound";
var _VPCI = "VPCId";
var _VPCR = "VPCRegion";
var _VPCs = "VPCs";
var _Ve = "Version";
var _W = "Weight";
var _c2 = "client";
var _co = "continentcode";
var _cou = "countrycode";
var _d = "dnsname";
var _de = "delegationsetid";
var _e2 = "error";
var _ed = "edns0clientsubnetip";
var _edn = "edns0clientsubnetmask";
var _h2 = "hostedzoneid";
var _hE2 = "httpError";
var _hH2 = "httpHeader";
var _hQ2 = "httpQuery";
var _ho = "hostedzonetype";
var _ht = "http";
var _i = "identifier";
var _id = "id";
var _l = "location";
var _m2 = "message";
var _ma = "maxresults";
var _mar = "marker";
var _max = "maxitems";
var _me = "messages";
var _n = "nexttoken";
var _na = "name";
var _r = "recordname";
var _re = "recordtype";
var _res = "resolverip";
var _s2 = "smithy.ts.sdk.synthetic.com.amazonaws.route53";
var _st = "startcontinentcode";
var _sta = "startcountrycode";
var _star = "startsubdivisioncode";
var _su = "subdivisioncode";
var _t = "type";
var _tr = "trafficpolicyid";
var _tra = "trafficpolicyinstancename";
var _traf = "trafficpolicyinstancetype";
var _traff = "trafficpolicyversion";
var _v = "vpcid";
var _ve = "version";
var _vp = "vpcregion";
var _xN = "xmlName";
var n02 = "com.amazonaws.route53";
var _s_registry2 = import_schema.TypeRegistry.for(_s2);
var Route53ServiceException$ = [-3, _s2, "Route53ServiceException", 0, [], []];
_s_registry2.registerError(Route53ServiceException$, Route53ServiceException);
var n0_registry2 = import_schema.TypeRegistry.for(n02);
var CidrBlockInUseException$ = [
-3,
n02,
_CBIUE,
{ [_e2]: _c2, [_hE2]: 400 },
[_M],
[0]
];
n0_registry2.registerError(CidrBlockInUseException$, CidrBlockInUseException);
var CidrCollectionAlreadyExistsException$ = [
-3,
n02,
_CCAEE,
{ [_e2]: _c2 },
[_M],
[0]
];
n0_registry2.registerError(CidrCollectionAlreadyExistsException$, CidrCollectionAlreadyExistsException);
var CidrCollectionInUseException$ = [
-3,
n02,
_CCIUE,
{ [_e2]: _c2, [_hE2]: 400 },
[_M],
[0]
];
n0_registry2.registerError(CidrCollectionInUseException$, CidrCollectionInUseException);
var CidrCollectionVersionMismatchException$ = [
-3,
n02,
_CCVME,
{ [_e2]: _c2, [_hE2]: 409 },
[_M],
[0]
];
n0_registry2.registerError(CidrCollectionVersionMismatchException$, CidrCollectionVersionMismatchException);
var ConcurrentModification$ = [
-3,
n02,
_CM,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(ConcurrentModification$, ConcurrentModification);
var ConflictingDomainExists$ = [
-3,
n02,
_CDE,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(ConflictingDomainExists$, ConflictingDomainExists);
var ConflictingTypes$ = [
-3,
n02,
_CT,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(ConflictingTypes$, ConflictingTypes);
var DelegationSetAlreadyCreated$ = [
-3,
n02,
_DSAC,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(DelegationSetAlreadyCreated$, DelegationSetAlreadyCreated);
var DelegationSetAlreadyReusable$ = [
-3,
n02,
_DSAR,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(DelegationSetAlreadyReusable$, DelegationSetAlreadyReusable);
var DelegationSetInUse$ = [
-3,
n02,
_DSIU,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(DelegationSetInUse$, DelegationSetInUse);
var DelegationSetNotAvailable$ = [
-3,
n02,
_DSNA,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(DelegationSetNotAvailable$, DelegationSetNotAvailable);
var DelegationSetNotReusable$ = [
-3,
n02,
_DSNR,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(DelegationSetNotReusable$, DelegationSetNotReusable);
var DNSSECNotFound$ = [
-3,
n02,
_DNSSECNF,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(DNSSECNotFound$, DNSSECNotFound);
var HealthCheckAlreadyExists$ = [
-3,
n02,
_HCAE,
{ [_e2]: _c2, [_hE2]: 409 },
[_m2],
[0]
];
n0_registry2.registerError(HealthCheckAlreadyExists$, HealthCheckAlreadyExists);
var HealthCheckInUse$ = [
-3,
n02,
_HCIU,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(HealthCheckInUse$, HealthCheckInUse);
var HealthCheckVersionMismatch$ = [
-3,
n02,
_HCVM,
{ [_e2]: _c2, [_hE2]: 409 },
[_m2],
[0]
];
n0_registry2.registerError(HealthCheckVersionMismatch$, HealthCheckVersionMismatch);
var HostedZoneAlreadyExists$ = [
-3,
n02,
_HZAE,
{ [_e2]: _c2, [_hE2]: 409 },
[_m2],
[0]
];
n0_registry2.registerError(HostedZoneAlreadyExists$, HostedZoneAlreadyExists);
var HostedZoneNotEmpty$ = [
-3,
n02,
_HZNE,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(HostedZoneNotEmpty$, HostedZoneNotEmpty);
var HostedZoneNotFound$ = [
-3,
n02,
_HZNF,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(HostedZoneNotFound$, HostedZoneNotFound);
var HostedZoneNotPrivate$ = [
-3,
n02,
_HZNP,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(HostedZoneNotPrivate$, HostedZoneNotPrivate);
var HostedZonePartiallyDelegated$ = [
-3,
n02,
_HZPD,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(HostedZonePartiallyDelegated$, HostedZonePartiallyDelegated);
var IncompatibleVersion$ = [
-3,
n02,
_IV,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(IncompatibleVersion$, IncompatibleVersion);
var InsufficientCloudWatchLogsResourcePolicy$ = [
-3,
n02,
_ICWLRP,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(InsufficientCloudWatchLogsResourcePolicy$, InsufficientCloudWatchLogsResourcePolicy);
var InvalidArgument$ = [
-3,
n02,
_IA,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(InvalidArgument$, InvalidArgument);
var InvalidChangeBatch$ = [
-3,
n02,
_ICB,
{ [_e2]: _c2 },
[_me, _m2],
[[() => ErrorMessages, 0], 0]
];
n0_registry2.registerError(InvalidChangeBatch$, InvalidChangeBatch);
var InvalidDomainName$ = [
-3,
n02,
_IDN,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(InvalidDomainName$, InvalidDomainName);
var InvalidInput$ = [
-3,
n02,
_II,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(InvalidInput$, InvalidInput);
var InvalidKeySigningKeyName$ = [
-3,
n02,
_IKSKN,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(InvalidKeySigningKeyName$, InvalidKeySigningKeyName);
var InvalidKeySigningKeyStatus$ = [
-3,
n02,
_IKSKS,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(InvalidKeySigningKeyStatus$, InvalidKeySigningKeyStatus);
var InvalidKMSArn$ = [
-3,
n02,
_IKMSA,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(InvalidKMSArn$, InvalidKMSArn);
var InvalidPaginationToken$ = [
-3,
n02,
_IPT,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(InvalidPaginationToken$, InvalidPaginationToken);
var InvalidSigningStatus$ = [
-3,
n02,
_ISS,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(InvalidSigningStatus$, InvalidSigningStatus);
var InvalidTrafficPolicyDocument$ = [
-3,
n02,
_ITPD,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(InvalidTrafficPolicyDocument$, InvalidTrafficPolicyDocument);
var InvalidVPCId$ = [
-3,
n02,
_IVPCI,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(InvalidVPCId$, InvalidVPCId);
var KeySigningKeyAlreadyExists$ = [
-3,
n02,
_KSKAE,
{ [_e2]: _c2, [_hE2]: 409 },
[_m2],
[0]
];
n0_registry2.registerError(KeySigningKeyAlreadyExists$, KeySigningKeyAlreadyExists);
var KeySigningKeyInParentDSRecord$ = [
-3,
n02,
_KSKIPDSR,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(KeySigningKeyInParentDSRecord$, KeySigningKeyInParentDSRecord);
var KeySigningKeyInUse$ = [
-3,
n02,
_KSKIU,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(KeySigningKeyInUse$, KeySigningKeyInUse);
var KeySigningKeyWithActiveStatusNotFound$ = [
-3,
n02,
_KSKWASNF,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(KeySigningKeyWithActiveStatusNotFound$, KeySigningKeyWithActiveStatusNotFound);
var LastVPCAssociation$ = [
-3,
n02,
_LVPCA,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(LastVPCAssociation$, LastVPCAssociation);
var LimitsExceeded$ = [
-3,
n02,
_LE,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(LimitsExceeded$, LimitsExceeded);
var NoSuchChange$ = [
-3,
n02,
_NSC,
{ [_e2]: _c2, [_hE2]: 404 },
[_m2],
[0]
];
n0_registry2.registerError(NoSuchChange$, NoSuchChange);
var NoSuchCidrCollectionException$ = [
-3,
n02,
_NSCCE,
{ [_e2]: _c2, [_hE2]: 404 },
[_M],
[0]
];
n0_registry2.registerError(NoSuchCidrCollectionException$, NoSuchCidrCollectionException);
var NoSuchCidrLocationException$ = [
-3,
n02,
_NSCLE,
{ [_e2]: _c2, [_hE2]: 404 },
[_M],
[0]
];
n0_registry2.registerError(NoSuchCidrLocationException$, NoSuchCidrLocationException);
var NoSuchCloudWatchLogsLogGroup$ = [
-3,
n02,
_NSCWLLG,
{ [_e2]: _c2, [_hE2]: 404 },
[_m2],
[0]
];
n0_registry2.registerError(NoSuchCloudWatchLogsLogGroup$, NoSuchCloudWatchLogsLogGroup);
var NoSuchDelegationSet$ = [
-3,
n02,
_NSDS,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(NoSuchDelegationSet$, NoSuchDelegationSet);
var NoSuchGeoLocation$ = [
-3,
n02,
_NSGL,
{ [_e2]: _c2, [_hE2]: 404 },
[_m2],
[0]
];
n0_registry2.registerError(NoSuchGeoLocation$, NoSuchGeoLocation);
var NoSuchHealthCheck$ = [
-3,
n02,
_NSHC,
{ [_e2]: _c2, [_hE2]: 404 },
[_m2],
[0]
];
n0_registry2.registerError(NoSuchHealthCheck$, NoSuchHealthCheck);
var NoSuchHostedZone$ = [
-3,
n02,
_NSHZ,
{ [_e2]: _c2, [_hE2]: 404 },
[_m2],
[0]
];
n0_registry2.registerError(NoSuchHostedZone$, NoSuchHostedZone);
var NoSuchKeySigningKey$ = [
-3,
n02,
_NSKSK,
{ [_e2]: _c2, [_hE2]: 404 },
[_m2],
[0]
];
n0_registry2.registerError(NoSuchKeySigningKey$, NoSuchKeySigningKey);
var NoSuchQueryLoggingConfig$ = [
-3,
n02,
_NSQLC,
{ [_e2]: _c2, [_hE2]: 404 },
[_m2],
[0]
];
n0_registry2.registerError(NoSuchQueryLoggingConfig$, NoSuchQueryLoggingConfig);
var NoSuchTrafficPolicy$ = [
-3,
n02,
_NSTP,
{ [_e2]: _c2, [_hE2]: 404 },
[_m2],
[0]
];
n0_registry2.registerError(NoSuchTrafficPolicy$, NoSuchTrafficPolicy);
var NoSuchTrafficPolicyInstance$ = [
-3,
n02,
_NSTPI,
{ [_e2]: _c2, [_hE2]: 404 },
[_m2],
[0]
];
n0_registry2.registerError(NoSuchTrafficPolicyInstance$, NoSuchTrafficPolicyInstance);
var NotAuthorizedException$ = [
-3,
n02,
_NAE,
{ [_e2]: _c2, [_hE2]: 401 },
[_m2],
[0]
];
n0_registry2.registerError(NotAuthorizedException$, NotAuthorizedException);
var PriorRequestNotComplete$ = [
-3,
n02,
_PRNC,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(PriorRequestNotComplete$, PriorRequestNotComplete);
var PublicZoneVPCAssociation$ = [
-3,
n02,
_PZVPCA,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(PublicZoneVPCAssociation$, PublicZoneVPCAssociation);
var QueryLoggingConfigAlreadyExists$ = [
-3,
n02,
_QLCAE,
{ [_e2]: _c2, [_hE2]: 409 },
[_m2],
[0]
];
n0_registry2.registerError(QueryLoggingConfigAlreadyExists$, QueryLoggingConfigAlreadyExists);
var ThrottlingException$ = [
-3,
n02,
_TE,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(ThrottlingException$, ThrottlingException);
var TooManyHealthChecks$ = [
-3,
n02,
_TMHC,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(TooManyHealthChecks$, TooManyHealthChecks);
var TooManyHostedZones$ = [
-3,
n02,
_TMHZ,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(TooManyHostedZones$, TooManyHostedZones);
var TooManyKeySigningKeys$ = [
-3,
n02,
_TMKSK,
{ [_e2]: _c2 },
[_m2],
[0]
];
n0_registry2.registerError(TooManyKeySigningKeys$, TooManyKeySigningKeys);
var TooManyTrafficPolicies$ = [
-3,
n02,
_TMTP,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(TooManyTrafficPolicies$, TooManyTrafficPolicies);
var TooManyTrafficPolicyInstances$ = [
-3,
n02,
_TMTPI,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(TooManyTrafficPolicyInstances$, TooManyTrafficPolicyInstances);
var TooManyTrafficPolicyVersionsForCurrentPolicy$ = [
-3,
n02,
_TMTPVFCP,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(TooManyTrafficPolicyVersionsForCurrentPolicy$, TooManyTrafficPolicyVersionsForCurrentPolicy);
var TooManyVPCAssociationAuthorizations$ = [
-3,
n02,
_TMVPCAA,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(TooManyVPCAssociationAuthorizations$, TooManyVPCAssociationAuthorizations);
var TrafficPolicyAlreadyExists$ = [
-3,
n02,
_TPAE,
{ [_e2]: _c2, [_hE2]: 409 },
[_m2],
[0]
];
n0_registry2.registerError(TrafficPolicyAlreadyExists$, TrafficPolicyAlreadyExists);
var TrafficPolicyInstanceAlreadyExists$ = [
-3,
n02,
_TPIAE,
{ [_e2]: _c2, [_hE2]: 409 },
[_m2],
[0]
];
n0_registry2.registerError(TrafficPolicyInstanceAlreadyExists$, TrafficPolicyInstanceAlreadyExists);
var TrafficPolicyInUse$ = [
-3,
n02,
_TPIU,
{ [_e2]: _c2, [_hE2]: 400 },
[_m2],
[0]
];
n0_registry2.registerError(TrafficPolicyInUse$, TrafficPolicyInUse);
var VPCAssociationAuthorizationNotFound$ = [
-3,
n02,
_VPCAANF,
{ [_e2]: _c2, [_hE2]: 404 },
[_m2],
[0]
];
n0_registry2.registerError(VPCAssociationAuthorizationNotFound$, VPCAssociationAuthorizationNotFound);
var VPCAssociationNotFound$ = [
-3,
n02,
_VPCANF,
{ [_e2]: _c2, [_hE2]: 404 },
[_m2],
[0]
];
n0_registry2.registerError(VPCAssociationNotFound$, VPCAssociationNotFound);
var errorTypeRegistries2 = [
_s_registry2,
n0_registry2
];
var AccountLimit$ = [
3,
n02,
_AL,
0,
[_T, _V],
[0, 1],
2
];
var ActivateKeySigningKeyRequest$ = [
3,
n02,
_AKSKR,
0,
[_HZI, _N],
[[0, 1], [0, 1]],
2
];
var ActivateKeySigningKeyResponse$ = [
3,
n02,
_AKSKRc,
0,
[_CI],
[() => ChangeInfo$],
1
];
var AlarmIdentifier$ = [
3,
n02,
_AI,
0,
[_R, _N],
[0, 0],
2
];
var AliasTarget$ = [
3,
n02,
_AT,
0,
[_HZI, _DNSN, _ETH],
[0, 0, 2],
3
];
var AssociateVPCWithHostedZoneRequest$ = [
3,
n02,
_AVPCWHZR,
0,
[_HZI, _VPC, _C],
[[0, 1], () => VPC$, 0],
2
];
var AssociateVPCWithHostedZoneResponse$ = [
3,
n02,
_AVPCWHZRs,
0,
[_CI],
[() => ChangeInfo$],
1
];
var Change$ = [
3,
n02,
_Ch,
0,
[_A, _RRS],
[0, [() => ResourceRecordSet$, 0]],
2
];
var ChangeBatch$ = [
3,
n02,
_CB,
0,
[_Cha, _C],
[[() => Changes, 0], 0],
1
];
var ChangeCidrCollectionRequest$ = [
3,
n02,
_CCCR,
0,
[_I, _Cha, _CV],
[[0, 1], [() => CidrCollectionChanges, 0], 1],
2
];
var ChangeCidrCollectionResponse$ = [
3,
n02,
_CCCRh,
0,
[_I],
[0],
1
];
var ChangeInfo$ = [
3,
n02,
_CI,
0,
[_I, _S, _SA, _C],
[0, 0, 4, 0],
3
];
var ChangeResourceRecordSetsRequest$ = [
3,
n02,
_CRRSR,
0,
[_HZI, _CB],
[[0, 1], [() => ChangeBatch$, 0]],
2
];
var ChangeResourceRecordSetsResponse$ = [
3,
n02,
_CRRSRh,
0,
[_CI],
[() => ChangeInfo$],
1
];
var ChangeTagsForResourceRequest$ = [
3,
n02,
_CTFRR,
0,
[_RT, _RI, _ATd, _RTK],
[[0, 1], [0, 1], [() => TagList, 0], [() => TagKeyList, 0]],
2
];
var ChangeTagsForResourceResponse$ = [
3,
n02,
_CTFRRh,
0,
[],
[]
];
var CidrBlockSummary$ = [
3,
n02,
_CBS,
0,
[_CBi, _LN],
[0, 0]
];
var CidrCollection$ = [
3,
n02,
_CC,
0,
[_Ar, _I, _N, _Ve],
[0, 0, 0, 1]
];
var CidrCollectionChange$ = [
3,
n02,
_CCC,
0,
[_LN, _A, _CL],
[0, 0, [() => CidrList, 0]],
3
];
var CidrRoutingConfig$ = [
3,
n02,
_CRC,
0,
[_CIo, _LN],
[0, 0],
2
];
var CloudWatchAlarmConfiguration$ = [
3,
n02,
_CWAC,
0,
[_EP, _Th, _CO, _P, _MN, _Na, _St, _D],
[1, 1, 0, 1, 0, 0, 0, [() => DimensionList, 0]],
7
];
var CollectionSummary$ = [
3,
n02,
_CS,
0,
[_Ar, _I, _N, _Ve],
[0, 0, 0, 1]
];
var Coordinates$ = [
3,
n02,
_Co,
0,
[_L, _Lo],
[0, 0],
2
];
var CreateCidrCollectionRequest$ = [
3,
n02,
_CCCRr,
0,
[_N, _CR],
[0, 0],
2
];
var CreateCidrCollectionResponse$ = [
3,
n02,
_CCCRre,
0,
[_Col, _Loc],
[() => CidrCollection$, [0, { [_hH2]: _Loc }]]
];
var CreateHealthCheckRequest$ = [
3,
n02,
_CHCR,
0,
[_CR, _HCC],
[0, [() => HealthCheckConfig$, 0]],
2
];
var CreateHealthCheckResponse$ = [
3,
n02,
_CHCRr,
0,
[_HC, _Loc],
[[() => HealthCheck$, 0], [0, { [_hH2]: _Loc }]],
2
];
var CreateHostedZoneRequest$ = [
3,
n02,
_CHZR,
0,
[_N, _CR, _VPC, _HZC, _DSI],
[0, 0, () => VPC$, () => HostedZoneConfig$, 0],
2
];
var CreateHostedZoneResponse$ = [
3,
n02,
_CHZRr,
0,
[_HZ, _CI, _DS, _Loc, _VPC],
[() => HostedZone$, () => ChangeInfo$, [() => DelegationSet$, 0], [0, { [_hH2]: _Loc }], () => VPC$],
4
];
var CreateKeySigningKeyRequest$ = [
3,
n02,
_CKSKR,
0,
[_CR, _HZI, _KMSA, _N, _S],
[0, 0, 0, 0, 0],
5
];
var CreateKeySigningKeyResponse$ = [
3,
n02,
_CKSKRr,
0,
[_CI, _KSK, _Loc],
[() => ChangeInfo$, () => KeySigningKey$, [0, { [_hH2]: _Loc }]],
3
];
var CreateQueryLoggingConfigRequest$ = [
3,
n02,
_CQLCR,
0,
[_HZI, _CWLLGA],
[0, 0],
2
];
var CreateQueryLoggingConfigResponse$ = [
3,
n02,
_CQLCRr,
0,
[_QLC, _Loc],
[() => QueryLoggingConfig$, [0, { [_hH2]: _Loc }]],
2
];
var CreateReusableDelegationSetRequest$ = [
3,
n02,
_CRDSR,
0,
[_CR, _HZI],
[0, 0],
1
];
var CreateReusableDelegationSetResponse$ = [
3,
n02,
_CRDSRr,
0,
[_DS, _Loc],
[[() => DelegationSet$, 0], [0, { [_hH2]: _Loc }]],
2
];
var CreateTrafficPolicyInstanceRequest$ = [
3,
n02,
_CTPIR,
0,
[_HZI, _N, _TTL, _TPI, _TPV],
[0, 0, 1, 0, 1],
5
];
var CreateTrafficPolicyInstanceResponse$ = [
3,
n02,
_CTPIRr,
0,
[_TPIr, _Loc],
[() => TrafficPolicyInstance$, [0, { [_hH2]: _Loc }]],
2
];
var CreateTrafficPolicyRequest$ = [
3,
n02,
_CTPR,
0,
[_N, _Do, _C],
[0, 0, 0],
2
];
var CreateTrafficPolicyResponse$ = [
3,
n02,
_CTPRr,
0,
[_TP, _Loc],
[() => TrafficPolicy$, [0, { [_hH2]: _Loc }]],
2
];
var CreateTrafficPolicyVersionRequest$ = [
3,
n02,
_CTPVR,
0,
[_I, _Do, _C],
[[0, 1], 0, 0],
2
];
var CreateTrafficPolicyVersionResponse$ = [
3,
n02,
_CTPVRr,
0,
[_TP, _Loc],
[() => TrafficPolicy$, [0, { [_hH2]: _Loc }]],
2
];
var CreateVPCAssociationAuthorizationRequest$ = [
3,
n02,
_CVPCAAR,
0,
[_HZI, _VPC],
[[0, 1], () => VPC$],
2
];
var CreateVPCAssociationAuthorizationResponse$ = [
3,
n02,
_CVPCAARr,
0,
[_HZI, _VPC],
[0, () => VPC$],
2
];
var DeactivateKeySigningKeyRequest$ = [
3,
n02,
_DKSKR,
0,
[_HZI, _N],
[[0, 1], [0, 1]],
2
];
var DeactivateKeySigningKeyResponse$ = [
3,
n02,
_DKSKRe,
0,
[_CI],
[() => ChangeInfo$],
1
];
var DelegationSet$ = [
3,
n02,
_DS,
0,
[_NS, _I, _CR],
[[() => DelegationSetNameServers, 0], 0, 0],
1
];
var DeleteCidrCollectionRequest$ = [
3,
n02,
_DCCR,
0,
[_I],
[[0, 1]],
1
];
var DeleteCidrCollectionResponse$ = [
3,
n02,
_DCCRe,
0,
[],
[]
];
var DeleteHealthCheckRequest$ = [
3,
n02,
_DHCR,
0,
[_HCI],
[[0, 1]],
1
];
var DeleteHealthCheckResponse$ = [
3,
n02,
_DHCRe,
0,
[],
[]
];
var DeleteHostedZoneRequest$ = [
3,
n02,
_DHZR,
0,
[_I],
[[0, 1]],
1
];
var DeleteHostedZoneResponse$ = [
3,
n02,
_DHZRe,
0,
[_CI],
[() => ChangeInfo$],
1
];
var DeleteKeySigningKeyRequest$ = [
3,
n02,
_DKSKRel,
0,
[_HZI, _N],
[[0, 1], [0, 1]],
2
];
var DeleteKeySigningKeyResponse$ = [
3,
n02,
_DKSKRele,
0,
[_CI],
[() => ChangeInfo$],
1
];
var DeleteQueryLoggingConfigRequest$ = [
3,
n02,
_DQLCR,
0,
[_I],
[[0, 1]],
1
];
var DeleteQueryLoggingConfigResponse$ = [
3,
n02,
_DQLCRe,
0,
[],
[]
];
var DeleteReusableDelegationSetRequest$ = [
3,
n02,
_DRDSR,
0,
[_I],
[[0, 1]],
1
];
var DeleteReusableDelegationSetResponse$ = [
3,
n02,
_DRDSRe,
0,
[],
[]
];
var DeleteTrafficPolicyInstanceRequest$ = [
3,
n02,
_DTPIR,
0,
[_I],
[[0, 1]],
1
];
var DeleteTrafficPolicyInstanceResponse$ = [
3,
n02,
_DTPIRe,
0,
[],
[]
];
var DeleteTrafficPolicyRequest$ = [
3,
n02,
_DTPR,
0,
[_I, _Ve],
[[0, 1], [1, 1]],
2
];
var DeleteTrafficPolicyResponse$ = [
3,
n02,
_DTPRe,
0,
[],
[]
];
var DeleteVPCAssociationAuthorizationRequest$ = [
3,
n02,
_DVPCAAR,
0,
[_HZI, _VPC],
[[0, 1], () => VPC$],
2
];
var DeleteVPCAssociationAuthorizationResponse$ = [
3,
n02,
_DVPCAARe,
0,
[],
[]
];
var Dimension$ = [
3,
n02,
_Di,
0,
[_N, _V],
[0, 0],
2
];
var DisableHostedZoneDNSSECRequest$ = [
3,
n02,
_DHZDNSSECR,
0,
[_HZI],
[[0, 1]],
1
];
var DisableHostedZoneDNSSECResponse$ = [
3,
n02,
_DHZDNSSECRi,
0,
[_CI],
[() => ChangeInfo$],
1
];
var DisassociateVPCFromHostedZoneRequest$ = [
3,
n02,
_DVPCFHZR,
0,
[_HZI, _VPC, _C],
[[0, 1], () => VPC$, 0],
2
];
var DisassociateVPCFromHostedZoneResponse$ = [
3,
n02,
_DVPCFHZRi,
0,
[_CI],
[() => ChangeInfo$],
1
];
var DNSSECStatus$ = [
3,
n02,
_DNSSECS,
0,
[_SS, _SM],
[0, 0]
];
var EnableHostedZoneDNSSECRequest$ = [
3,
n02,
_EHZDNSSECR,
0,
[_HZI],
[[0, 1]],
1
];
var EnableHostedZoneDNSSECResponse$ = [
3,
n02,
_EHZDNSSECRn,
0,
[_CI],
[() => ChangeInfo$],
1
];
var GeoLocation$ = [
3,
n02,
_GL,
0,
[_CCo, _CCou, _SC],
[0, 0, 0]
];
var GeoLocationDetails$ = [
3,
n02,
_GLD,
0,
[_CCo, _CN, _CCou, _CNo, _SC, _SN],
[0, 0, 0, 0, 0, 0]
];
var GeoProximityLocation$ = [
3,
n02,
_GPL,
0,
[_AWSR, _LZG, _Co, _B],
[0, 0, () => Coordinates$, 1]
];
var GetAccountLimitRequest$ = [
3,
n02,
_GALR,
0,
[_T],
[[0, 1]],
1
];
var GetAccountLimitResponse$ = [
3,
n02,
_GALRe,
0,
[_Li, _Cou],
[() => AccountLimit$, 1],
2
];
var GetChangeRequest$ = [
3,
n02,
_GCR,
0,
[_I],
[[0, 1]],
1
];
var GetChangeResponse$ = [
3,
n02,
_GCRe,
0,
[_CI],
[() => ChangeInfo$],
1
];
var GetCheckerIpRangesRequest$ = [
3,
n02,
_GCIRR,
0,
[],
[]
];
var GetCheckerIpRangesResponse$ = [
3,
n02,
_GCIRRe,
0,
[_CIR],
[64 | 0],
1
];
var GetDNSSECRequest$ = [
3,
n02,
_GDNSSECR,
0,
[_HZI],
[[0, 1]],
1
];
var GetDNSSECResponse$ = [
3,
n02,
_GDNSSECRe,
0,
[_S, _KSKe],
[() => DNSSECStatus$, () => KeySigningKeys],
2
];
var GetGeoLocationRequest$ = [
3,
n02,
_GGLR,
0,
[_CCo, _CCou, _SC],
[[0, { [_hQ2]: _co }], [0, { [_hQ2]: _cou }], [0, { [_hQ2]: _su }]]
];
var GetGeoLocationResponse$ = [
3,
n02,
_GGLRe,
0,
[_GLD],
[() => GeoLocationDetails$],
1
];
var GetHealthCheckCountRequest$ = [
3,
n02,
_GHCCR,
0,
[],
[]
];
var GetHealthCheckCountResponse$ = [
3,
n02,
_GHCCRe,
0,
[_HCCe],
[1],
1
];
var GetHealthCheckLastFailureReasonRequest$ = [
3,
n02,
_GHCLFRR,
0,
[_HCI],
[[0, 1]],
1
];
var GetHealthCheckLastFailureReasonResponse$ = [
3,
n02,
_GHCLFRRe,
0,
[_HCO],
[[() => HealthCheckObservations, 0]],
1
];
var GetHealthCheckRequest$ = [
3,
n02,
_GHCR,
0,
[_HCI],
[[0, 1]],
1
];
var GetHealthCheckResponse$ = [
3,
n02,
_GHCRe,
0,
[_HC],
[[() => HealthCheck$, 0]],
1
];
var GetHealthCheckStatusRequest$ = [
3,
n02,
_GHCSR,
0,
[_HCI],
[[0, 1]],
1
];
var GetHealthCheckStatusResponse$ = [
3,
n02,
_GHCSRe,
0,
[_HCO],
[[() => HealthCheckObservations, 0]],
1
];
var GetHostedZoneCountRequest$ = [
3,
n02,
_GHZCR,
0,
[],
[]
];
var GetHostedZoneCountResponse$ = [
3,
n02,
_GHZCRe,
0,
[_HZCo],
[1],
1
];
var GetHostedZoneLimitRequest$ = [
3,
n02,
_GHZLR,
0,
[_T, _HZI],
[[0, 1], [0, 1]],
2
];
var GetHostedZoneLimitResponse$ = [
3,
n02,
_GHZLRe,
0,
[_Li, _Cou],
[() => HostedZoneLimit$, 1],
2
];
var GetHostedZoneRequest$ = [
3,
n02,
_GHZR,
0,
[_I],
[[0, 1]],
1
];
var GetHostedZoneResponse$ = [
3,
n02,
_GHZRe,
0,
[_HZ, _DS, _VPCs],
[() => HostedZone$, [() => DelegationSet$, 0], [() => VPCs, 0]],
1
];
var GetQueryLoggingConfigRequest$ = [
3,
n02,
_GQLCR,
0,
[_I],
[[0, 1]],
1
];
var GetQueryLoggingConfigResponse$ = [
3,
n02,
_GQLCRe,
0,
[_QLC],
[() => QueryLoggingConfig$],
1
];
var GetReusableDelegationSetLimitRequest$ = [
3,
n02,
_GRDSLR,
0,
[_T, _DSI],
[[0, 1], [0, 1]],
2
];
var GetReusableDelegationSetLimitResponse$ = [
3,
n02,
_GRDSLRe,
0,
[_Li, _Cou],
[() => ReusableDelegationSetLimit$, 1],
2
];
var GetReusableDelegationSetRequest$ = [
3,
n02,
_GRDSR,
0,
[_I],
[[0, 1]],
1
];
var GetReusableDelegationSetResponse$ = [
3,
n02,
_GRDSRe,
0,
[_DS],
[[() => DelegationSet$, 0]],
1
];
var GetTrafficPolicyInstanceCountRequest$ = [
3,
n02,
_GTPICR,
0,
[],
[]
];
var GetTrafficPolicyInstanceCountResponse$ = [
3,
n02,
_GTPICRe,
0,
[_TPIC],
[1],
1
];
var GetTrafficPolicyInstanceRequest$ = [
3,
n02,
_GTPIR,
0,
[_I],
[[0, 1]],
1
];
var GetTrafficPolicyInstanceResponse$ = [
3,
n02,
_GTPIRe,
0,
[_TPIr],
[() => TrafficPolicyInstance$],
1
];
var GetTrafficPolicyRequest$ = [
3,
n02,
_GTPR,
0,
[_I, _Ve],
[[0, 1], [1, 1]],
2
];
var GetTrafficPolicyResponse$ = [
3,
n02,
_GTPRe,
0,
[_TP],
[() => TrafficPolicy$],
1
];
var HealthCheck$ = [
3,
n02,
_HC,
0,
[_I, _CR, _HCC, _HCV, _LS, _CWAC],
[0, 0, [() => HealthCheckConfig$, 0], 1, () => LinkedService$, [() => CloudWatchAlarmConfiguration$, 0]],
4
];
var HealthCheckConfig$ = [
3,
n02,
_HCC,
0,
[_T, _IPA, _Po, _RP, _FQDN, _SSe, _RIe, _FT, _ML, _In, _Dis, _HT, _CHC, _ESNI, _Re, _AI, _IDHS, _RCA],
[0, 0, 1, 0, 0, 0, 1, 1, 2, 2, 2, 1, [() => ChildHealthCheckList, 0], 2, [() => HealthCheckRegionList, 0], () => AlarmIdentifier$, 0, 0],
1
];
var HealthCheckObservation$ = [
3,
n02,
_HCOe,
0,
[_R, _IPA, _SR],
[0, 0, () => StatusReport$]
];
var HostedZone$ = [
3,
n02,
_HZ,
0,
[_I, _N, _CR, _Con, _RRSC, _LS, _F],
[0, 0, 0, () => HostedZoneConfig$, 1, () => LinkedService$, () => HostedZoneFeatures$],
3
];
var HostedZoneConfig$ = [
3,
n02,
_HZC,
0,
[_C, _PZ],
[0, 2]
];
var HostedZoneFailureReasons$ = [
3,
n02,
_HZFR,
0,
[_AR],
[0]
];
var HostedZoneFeatures$ = [
3,
n02,
_HZF,
0,
[_ARS, _FR],
[0, () => HostedZoneFailureReasons$]
];
var HostedZoneLimit$ = [
3,
n02,
_HZL,
0,
[_T, _V],
[0, 1],
2
];
var HostedZoneOwner$ = [
3,
n02,
_HZO,
0,
[_OA, _OS],
[0, 0]
];
var HostedZoneSummary$ = [
3,
n02,
_HZS,
0,
[_HZI, _N, _O],
[0, 0, () => HostedZoneOwner$],
3
];
var KeySigningKey$ = [
3,
n02,
_KSK,
0,
[_N, _KA, _Fl, _SAM, _SAT, _DAM, _DAT, _KT, _DV, _PK, _DSR, _DNSKEYR, _S, _SM, _CD, _LMD],
[0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 4, 4]
];
var LinkedService$ = [
3,
n02,
_LS,
0,
[_SP, _De],
[0, 0]
];
var ListCidrBlocksRequest$ = [
3,
n02,
_LCBR,
0,
[_CIo, _LN, _NT, _MR],
[[0, 1], [0, { [_hQ2]: _l }], [0, { [_hQ2]: _n }], [1, { [_hQ2]: _ma }]],
1
];
var ListCidrBlocksResponse$ = [
3,
n02,
_LCBRi,
0,
[_NT, _CBid],
[0, () => CidrBlockSummaries]
];
var ListCidrCollectionsRequest$ = [
3,
n02,
_LCCR,
0,
[_NT, _MR],
[[0, { [_hQ2]: _n }], [1, { [_hQ2]: _ma }]]
];
var ListCidrCollectionsResponse$ = [
3,
n02,
_LCCRi,
0,
[_NT, _CCi],
[0, () => CollectionSummaries]
];
var ListCidrLocationsRequest$ = [
3,
n02,
_LCLR,
0,
[_CIo, _NT, _MR],
[[0, 1], [0, { [_hQ2]: _n }], [1, { [_hQ2]: _ma }]],
1
];
var ListCidrLocationsResponse$ = [
3,
n02,
_LCLRi,
0,
[_NT, _CLi],
[0, () => LocationSummaries]
];
var ListGeoLocationsRequest$ = [
3,
n02,
_LGLR,
0,
[_SCC, _SCCt, _SSC, _MI],
[[0, { [_hQ2]: _st }], [0, { [_hQ2]: _sta }], [0, { [_hQ2]: _star }], [1, { [_hQ2]: _max }]]
];
var ListGeoLocationsResponse$ = [
3,
n02,
_LGLRi,
0,
[_GLDL, _IT, _MI, _NCC, _NCCe, _NSCe],
[[() => GeoLocationDetailsList, 0], 2, 1, 0, 0, 0],
3
];
var ListHealthChecksRequest$ = [
3,
n02,
_LHCR,
0,
[_Ma, _MI],
[[0, { [_hQ2]: _mar }], [1, { [_hQ2]: _max }]]
];
var ListHealthChecksResponse$ = [
3,
n02,
_LHCRi,
0,
[_HCe, _Ma, _IT, _MI, _NM],
[[() => HealthChecks, 0], 0, 2, 1, 0],
4
];
var ListHostedZonesByNameRequest$ = [
3,
n02,
_LHZBNR,
0,
[_DNSN, _HZI, _MI],
[[0, { [_hQ2]: _d }], [0, { [_hQ2]: _h2 }], [1, { [_hQ2]: _max }]]
];
var ListHostedZonesByNameResponse$ = [
3,
n02,
_LHZBNRi,
0,
[_HZo, _IT, _MI, _DNSN, _HZI, _NDNSN, _NHZI],
[[() => HostedZones, 0], 2, 1, 0, 0, 0, 0],
3
];
var ListHostedZonesByVPCRequest$ = [
3,
n02,
_LHZBVPCR,
0,
[_VPCI, _VPCR, _MI, _NT],
[[0, { [_hQ2]: _v }], [0, { [_hQ2]: _vp }], [1, { [_hQ2]: _max }], [0, { [_hQ2]: _n }]],
2
];
var ListHostedZonesByVPCResponse$ = [
3,
n02,
_LHZBVPCRi,
0,
[_HZSo, _MI, _NT],
[[() => HostedZoneSummaries, 0], 1, 0],
2
];
var ListHostedZonesRequest$ = [
3,
n02,
_LHZR,
0,
[_Ma, _MI, _DSI, _HZT],
[[0, { [_hQ2]: _mar }], [1, { [_hQ2]: _max }], [0, { [_hQ2]: _de }], [0, { [_hQ2]: _ho }]]
];
var ListHostedZonesResponse$ = [
3,
n02,
_LHZRi,
0,
[_HZo, _Ma, _IT, _MI, _NM],
[[() => HostedZones, 0], 0, 2, 1, 0],
4
];
var ListQueryLoggingConfigsRequest$ = [
3,
n02,
_LQLCR,
0,
[_HZI, _NT, _MR],
[[0, { [_hQ2]: _h2 }], [0, { [_hQ2]: _n }], [1, { [_hQ2]: _ma }]]
];
var ListQueryLoggingConfigsResponse$ = [
3,
n02,
_LQLCRi,
0,
[_QLCu, _NT],
[[() => QueryLoggingConfigs, 0], 0],
1
];
var ListResourceRecordSetsRequest$ = [
3,
n02,
_LRRSR,
0,
[_HZI, _SRN, _SRT, _SRI, _MI],
[[0, 1], [0, { [_hQ2]: _na }], [0, { [_hQ2]: _t }], [0, { [_hQ2]: _i }], [1, { [_hQ2]: _max }]],
1
];
var ListResourceRecordSetsResponse$ = [
3,
n02,
_LRRSRi,
0,
[_RRSe, _IT, _MI, _NRN, _NRT, _NRI],
[[() => ResourceRecordSets, 0], 2, 1, 0, 0, 0],
3
];
var ListReusableDelegationSetsRequest$ = [
3,
n02,
_LRDSR,
0,
[_Ma, _MI],
[[0, { [_hQ2]: _mar }], [1, { [_hQ2]: _max }]]
];
var ListReusableDelegationSetsResponse$ = [
3,
n02,
_LRDSRi,
0,
[_DSe, _Ma, _IT, _MI, _NM],
[[() => DelegationSets, 0], 0, 2, 1, 0],
4
];
var ListTagsForResourceRequest$ = [
3,
n02,
_LTFRR,
0,
[_RT, _RI],
[[0, 1], [0, 1]],
2
];
var ListTagsForResourceResponse$ = [
3,
n02,
_LTFRRi,
0,
[_RTS],
[[() => ResourceTagSet$, 0]],
1
];
var ListTagsForResourcesRequest$ = [
3,
n02,
_LTFRRis,
0,
[_RT, _RIes],
[[0, 1], [() => TagResourceIdList, 0]],
2
];
var ListTagsForResourcesResponse$ = [
3,
n02,
_LTFRRist,
0,
[_RTSe],
[[() => ResourceTagSetList, 0]],
1
];
var ListTrafficPoliciesRequest$ = [
3,
n02,
_LTPR,
0,
[_TPIM, _MI],
[[0, { [_hQ2]: _tr }], [1, { [_hQ2]: _max }]]
];
var ListTrafficPoliciesResponse$ = [
3,
n02,
_LTPRi,
0,
[_TPS, _IT, _TPIM, _MI],
[[() => TrafficPolicySummaries, 0], 2, 0, 1],
4
];
var ListTrafficPolicyInstancesByHostedZoneRequest$ = [
3,
n02,
_LTPIBHZR,
0,
[_HZI, _TPINM, _TPITM, _MI],
[[0, { [_hQ2]: _id }], [0, { [_hQ2]: _tra }], [0, { [_hQ2]: _traf }], [1, { [_hQ2]: _max }]],
1
];
var ListTrafficPolicyInstancesByHostedZoneResponse$ = [
3,
n02,
_LTPIBHZRi,
0,
[_TPIra, _IT, _MI, _TPINM, _TPITM],
[[() => TrafficPolicyInstances, 0], 2, 1, 0, 0],
3
];
var ListTrafficPolicyInstancesByPolicyRequest$ = [
3,
n02,
_LTPIBPR,
0,
[_TPI, _TPV, _HZIM, _TPINM, _TPITM, _MI],
[[0, { [_hQ2]: _id }], [1, { [_hQ2]: _ve }], [0, { [_hQ2]: _h2 }], [0, { [_hQ2]: _tra }], [0, { [_hQ2]: _traf }], [1, { [_hQ2]: _max }]],
2
];
var ListTrafficPolicyInstancesByPolicyResponse$ = [
3,
n02,
_LTPIBPRi,
0,
[_TPIra, _IT, _MI, _HZIM, _TPINM, _TPITM],
[[() => TrafficPolicyInstances, 0], 2, 1, 0, 0, 0],
3
];
var ListTrafficPolicyInstancesRequest$ = [
3,
n02,
_LTPIR,
0,
[_HZIM, _TPINM, _TPITM, _MI],
[[0, { [_hQ2]: _h2 }], [0, { [_hQ2]: _tra }], [0, { [_hQ2]: _traf }], [1, { [_hQ2]: _max }]]
];
var ListTrafficPolicyInstancesResponse$ = [
3,
n02,
_LTPIRi,
0,
[_TPIra, _IT, _MI, _HZIM, _TPINM, _TPITM],
[[() => TrafficPolicyInstances, 0], 2, 1, 0, 0, 0],
3
];
var ListTrafficPolicyVersionsRequest$ = [
3,
n02,
_LTPVR,
0,
[_I, _TPVM, _MI],
[[0, 1], [0, { [_hQ2]: _traff }], [1, { [_hQ2]: _max }]],
1
];
var ListTrafficPolicyVersionsResponse$ = [
3,
n02,
_LTPVRi,
0,
[_TPr, _IT, _TPVM, _MI],
[[() => TrafficPolicies, 0], 2, 0, 1],
4
];
var ListVPCAssociationAuthorizationsRequest$ = [
3,
n02,
_LVPCAAR,
0,
[_HZI, _NT, _MR],
[[0, 1], [0, { [_hQ2]: _n }], [1, { [_hQ2]: _ma }]],
1
];
var ListVPCAssociationAuthorizationsResponse$ = [
3,
n02,
_LVPCAARi,
0,
[_HZI, _VPCs, _NT],
[0, [() => VPCs, 0], 0],
2
];
var LocationSummary$ = [
3,
n02,
_LSo,
0,
[_LN],
[0]
];
var QueryLoggingConfig$ = [
3,
n02,
_QLC,
0,
[_I, _HZI, _CWLLGA],
[0, 0, 0],
3
];
var ResourceRecord$ = [
3,
n02,
_RR,
0,
[_V],
[0],
1
];
var ResourceRecordSet$ = [
3,
n02,
_RRS,
0,
[_N, _T, _SI, _W, _R, _GL, _Fa, _MVA, _TTL, _RRe, _AT, _HCI, _TPII, _CRC, _GPL],
[0, 0, 0, 1, 0, () => GeoLocation$, 0, 2, 1, [() => ResourceRecords, 0], () => AliasTarget$, 0, 0, () => CidrRoutingConfig$, () => GeoProximityLocation$],
2
];
var ResourceTagSet$ = [
3,
n02,
_RTS,
0,
[_RT, _RI, _Ta],
[0, 0, [() => TagList, 0]]
];
var ReusableDelegationSetLimit$ = [
3,
n02,
_RDSL,
0,
[_T, _V],
[0, 1],
2
];
var StatusReport$ = [
3,
n02,
_SR,
0,
[_S, _CTh],
[0, 4]
];
var Tag$ = [
3,
n02,
_Tag,
0,
[_K, _V],
[0, 0]
];
var TestDNSAnswerRequest$ = [
3,
n02,
_TDNSAR,
0,
[_HZI, _RN, _RTe, _RIP, _EDNSCSIP, _EDNSCSM],
[[0, { [_hQ2]: _h2 }], [0, { [_hQ2]: _r }], [0, { [_hQ2]: _re }], [0, { [_hQ2]: _res }], [0, { [_hQ2]: _ed }], [0, { [_hQ2]: _edn }]],
3
];
var TestDNSAnswerResponse$ = [
3,
n02,
_TDNSARe,
0,
[_Nam, _RN, _RTe, _RD, _RC2, _Pr],
[0, 0, 0, [() => RecordData, 0], 0, 0],
6
];
var TrafficPolicy$ = [
3,
n02,
_TP,
0,
[_I, _Ve, _N, _T, _Do, _C],
[0, 1, 0, 0, 0, 0],
5
];
var TrafficPolicyInstance$ = [
3,
n02,
_TPIr,
0,
[_I, _HZI, _N, _TTL, _Sta, _M, _TPI, _TPV, _TPT],
[0, 0, 0, 1, 0, 0, 0, 1, 0],
9
];
var TrafficPolicySummary$ = [
3,
n02,
_TPSr,
0,
[_I, _N, _T, _LV, _TPC],
[0, 0, 0, 1, 1],
5
];
var UpdateHealthCheckRequest$ = [
3,
n02,
_UHCR,
0,
[_HCI, _HCV, _IPA, _Po, _RP, _FQDN, _SSe, _FT, _In, _Dis, _HT, _CHC, _ESNI, _Re, _AI, _IDHS, _RE],
[[0, 1], 1, 0, 1, 0, 0, 0, 1, 2, 2, 1, [() => ChildHealthCheckList, 0], 2, [() => HealthCheckRegionList, 0], () => AlarmIdentifier$, 0, [() => ResettableElementNameList, 0]],
1
];
var UpdateHealthCheckResponse$ = [
3,
n02,
_UHCRp,
0,
[_HC],
[[() => HealthCheck$, 0]],
1
];
var UpdateHostedZoneCommentRequest$ = [
3,
n02,
_UHZCR,
0,
[_I, _C],
[[0, 1], 0],
1
];
var UpdateHostedZoneCommentResponse$ = [
3,
n02,
_UHZCRp,
0,
[_HZ],
[() => HostedZone$],
1
];
var UpdateHostedZoneFeaturesRequest$ = [
3,
n02,
_UHZFR,
0,
[_HZI, _EAR],
[[0, 1], 2],
1
];
var UpdateHostedZoneFeaturesResponse$ = [
3,
n02,
_UHZFRp,
0,
[],
[]
];
var UpdateTrafficPolicyCommentRequest$ = [
3,
n02,
_UTPCR,
0,
[_I, _Ve, _C],
[[0, 1], [1, 1], 0],
3
];
var UpdateTrafficPolicyCommentResponse$ = [
3,
n02,
_UTPCRp,
0,
[_TP],
[() => TrafficPolicy$],
1
];
var UpdateTrafficPolicyInstanceRequest$ = [
3,
n02,
_UTPIR,
0,
[_I, _TTL, _TPI, _TPV],
[[0, 1], 1, 0, 1],
4
];
var UpdateTrafficPolicyInstanceResponse$ = [
3,
n02,
_UTPIRp,
0,
[_TPIr],
[() => TrafficPolicyInstance$],
1
];
var VPC$ = [
3,
n02,
_VPC,
0,
[_VPCR, _VPCI],
[0, 0]
];
var Changes = [
1,
n02,
_Cha,
0,
[
() => Change$,
{ [_xN]: _Ch }
]
];
var CheckerIpRanges = 64 | 0;
var ChildHealthCheckList = [
1,
n02,
_CHCL,
0,
[
0,
{ [_xN]: _CHCh }
]
];
var CidrBlockSummaries = [
1,
n02,
_CBSi,
0,
() => CidrBlockSummary$
];
var CidrCollectionChanges = [
1,
n02,
_CCCi,
0,
[
() => CidrCollectionChange$,
0
]
];
var CidrList = [
1,
n02,
_CL,
0,
[
0,
{ [_xN]: _Ci }
]
];
var CollectionSummaries = [
1,
n02,
_CSo,
0,
() => CollectionSummary$
];
var DelegationSetNameServers = [
1,
n02,
_DSNS,
0,
[
0,
{ [_xN]: _NSa }
]
];
var DelegationSets = [
1,
n02,
_DSe,
0,
[
() => DelegationSet$,
{ [_xN]: _DS }
]
];
var DimensionList = [
1,
n02,
_DL,
0,
[
() => Dimension$,
{ [_xN]: _Di }
]
];
var ErrorMessages = [
1,
n02,
_EM,
0,
[
0,
{ [_xN]: _M }
]
];
var GeoLocationDetailsList = [
1,
n02,
_GLDL,
0,
[
() => GeoLocationDetails$,
{ [_xN]: _GLD }
]
];
var HealthCheckObservations = [
1,
n02,
_HCO,
0,
[
() => HealthCheckObservation$,
{ [_xN]: _HCOe }
]
];
var HealthCheckRegionList = [
1,
n02,
_HCRL,
0,
[
0,
{ [_xN]: _R }
]
];
var HealthChecks = [
1,
n02,
_HCe,
0,
[
() => HealthCheck$,
{ [_xN]: _HC }
]
];
var HostedZones = [
1,
n02,
_HZo,
0,
[
() => HostedZone$,
{ [_xN]: _HZ }
]
];
var HostedZoneSummaries = [
1,
n02,
_HZSo,
0,
[
() => HostedZoneSummary$,
{ [_xN]: _HZS }
]
];
var KeySigningKeys = [
1,
n02,
_KSKe,
0,
() => KeySigningKey$
];
var LocationSummaries = [
1,
n02,
_LSoc,
0,
() => LocationSummary$
];
var QueryLoggingConfigs = [
1,
n02,
_QLCu,
0,
[
() => QueryLoggingConfig$,
{ [_xN]: _QLC }
]
];
var RecordData = [
1,
n02,
_RD,
0,
[
0,
{ [_xN]: _RDE }
]
];
var ResettableElementNameList = [
1,
n02,
_RENL,
0,
[
0,
{ [_xN]: _REN }
]
];
var ResourceRecords = [
1,
n02,
_RRe,
0,
[
() => ResourceRecord$,
{ [_xN]: _RR }
]
];
var ResourceRecordSets = [
1,
n02,
_RRSe,
0,
[
() => ResourceRecordSet$,
{ [_xN]: _RRS }
]
];
var ResourceTagSetList = [
1,
n02,
_RTSL,
0,
[
() => ResourceTagSet$,
{ [_xN]: _RTS }
]
];
var TagKeyList = [
1,
n02,
_TKL,
0,
[
0,
{ [_xN]: _K }
]
];
var TagList = [
1,
n02,
_TL,
0,
[
() => Tag$,
{ [_xN]: _Tag }
]
];
var TagResourceIdList = [
1,
n02,
_TRIL,
0,
[
0,
{ [_xN]: _RI }
]
];
var TrafficPolicies = [
1,
n02,
_TPr,
0,
[
() => TrafficPolicy$,
{ [_xN]: _TP }
]
];
var TrafficPolicyInstances = [
1,
n02,
_TPIra,
0,
[
() => TrafficPolicyInstance$,
{ [_xN]: _TPIr }
]
];
var TrafficPolicySummaries = [
1,
n02,
_TPS,
0,
[
() => TrafficPolicySummary$,
{ [_xN]: _TPSr }
]
];
var VPCs = [
1,
n02,
_VPCs,
0,
[
() => VPC$,
{ [_xN]: _VPC }
]
];
var ActivateKeySigningKey$ = [
9,
n02,
_AKSK,
{ [_ht]: ["POST", "/2013-04-01/keysigningkey/{HostedZoneId}/{Name}/activate", 200] },
() => ActivateKeySigningKeyRequest$,
() => ActivateKeySigningKeyResponse$
];
var AssociateVPCWithHostedZone$ = [
9,
n02,
_AVPCWHZ,
{ [_ht]: ["POST", "/2013-04-01/hostedzone/{HostedZoneId}/associatevpc", 200] },
() => AssociateVPCWithHostedZoneRequest$,
() => AssociateVPCWithHostedZoneResponse$
];
var ChangeCidrCollection$ = [
9,
n02,
_CCCh,
{ [_ht]: ["POST", "/2013-04-01/cidrcollection/{Id}", 200] },
() => ChangeCidrCollectionRequest$,
() => ChangeCidrCollectionResponse$
];
var ChangeResourceRecordSets$ = [
9,
n02,
_CRRS,
{ [_ht]: ["POST", "/2013-04-01/hostedzone/{HostedZoneId}/rrset", 200] },
() => ChangeResourceRecordSetsRequest$,
() => ChangeResourceRecordSetsResponse$
];
var ChangeTagsForResource$ = [
9,
n02,
_CTFR,
{ [_ht]: ["POST", "/2013-04-01/tags/{ResourceType}/{ResourceId}", 200] },
() => ChangeTagsForResourceRequest$,
() => ChangeTagsForResourceResponse$
];
var CreateCidrCollection$ = [
9,
n02,
_CCCr,
{ [_ht]: ["POST", "/2013-04-01/cidrcollection", 201] },
() => CreateCidrCollectionRequest$,
() => CreateCidrCollectionResponse$
];
var CreateHealthCheck$ = [
9,
n02,
_CHCr,
{ [_ht]: ["POST", "/2013-04-01/healthcheck", 201] },
() => CreateHealthCheckRequest$,
() => CreateHealthCheckResponse$
];
var CreateHostedZone$ = [
9,
n02,
_CHZ,
{ [_ht]: ["POST", "/2013-04-01/hostedzone", 201] },
() => CreateHostedZoneRequest$,
() => CreateHostedZoneResponse$
];
var CreateKeySigningKey$ = [
9,
n02,
_CKSK,
{ [_ht]: ["POST", "/2013-04-01/keysigningkey", 201] },
() => CreateKeySigningKeyRequest$,
() => CreateKeySigningKeyResponse$
];
var CreateQueryLoggingConfig$ = [
9,
n02,
_CQLC,
{ [_ht]: ["POST", "/2013-04-01/queryloggingconfig", 201] },
() => CreateQueryLoggingConfigRequest$,
() => CreateQueryLoggingConfigResponse$
];
var CreateReusableDelegationSet$ = [
9,
n02,
_CRDS,
{ [_ht]: ["POST", "/2013-04-01/delegationset", 201] },
() => CreateReusableDelegationSetRequest$,
() => CreateReusableDelegationSetResponse$
];
var CreateTrafficPolicy$ = [
9,
n02,
_CTP,
{ [_ht]: ["POST", "/2013-04-01/trafficpolicy", 201] },
() => CreateTrafficPolicyRequest$,
() => CreateTrafficPolicyResponse$
];
var CreateTrafficPolicyInstance$ = [
9,
n02,
_CTPI,
{ [_ht]: ["POST", "/2013-04-01/trafficpolicyinstance", 201] },
() => CreateTrafficPolicyInstanceRequest$,
() => CreateTrafficPolicyInstanceResponse$
];
var CreateTrafficPolicyVersion$ = [
9,
n02,
_CTPV,
{ [_ht]: ["POST", "/2013-04-01/trafficpolicy/{Id}", 201] },
() => CreateTrafficPolicyVersionRequest$,
() => CreateTrafficPolicyVersionResponse$
];
var CreateVPCAssociationAuthorization$ = [
9,
n02,
_CVPCAA,
{ [_ht]: ["POST", "/2013-04-01/hostedzone/{HostedZoneId}/authorizevpcassociation", 200] },
() => CreateVPCAssociationAuthorizationRequest$,
() => CreateVPCAssociationAuthorizationResponse$
];
var DeactivateKeySigningKey$ = [
9,
n02,
_DKSK,
{ [_ht]: ["POST", "/2013-04-01/keysigningkey/{HostedZoneId}/{Name}/deactivate", 200] },
() => DeactivateKeySigningKeyRequest$,
() => DeactivateKeySigningKeyResponse$
];
var DeleteCidrCollection$ = [
9,
n02,
_DCC,
{ [_ht]: ["DELETE", "/2013-04-01/cidrcollection/{Id}", 200] },
() => DeleteCidrCollectionRequest$,
() => DeleteCidrCollectionResponse$
];
var DeleteHealthCheck$ = [
9,
n02,
_DHC,
{ [_ht]: ["DELETE", "/2013-04-01/healthcheck/{HealthCheckId}", 200] },
() => DeleteHealthCheckRequest$,
() => DeleteHealthCheckResponse$
];
var DeleteHostedZone$ = [
9,
n02,
_DHZ,
{ [_ht]: ["DELETE", "/2013-04-01/hostedzone/{Id}", 200] },
() => DeleteHostedZoneRequest$,
() => DeleteHostedZoneResponse$
];
var DeleteKeySigningKey$ = [
9,
n02,
_DKSKe,
{ [_ht]: ["DELETE", "/2013-04-01/keysigningkey/{HostedZoneId}/{Name}", 200] },
() => DeleteKeySigningKeyRequest$,
() => DeleteKeySigningKeyResponse$
];
var DeleteQueryLoggingConfig$ = [
9,
n02,
_DQLC,
{ [_ht]: ["DELETE", "/2013-04-01/queryloggingconfig/{Id}", 200] },
() => DeleteQueryLoggingConfigRequest$,
() => DeleteQueryLoggingConfigResponse$
];
var DeleteReusableDelegationSet$ = [
9,
n02,
_DRDS,
{ [_ht]: ["DELETE", "/2013-04-01/delegationset/{Id}", 200] },
() => DeleteReusableDelegationSetRequest$,
() => DeleteReusableDelegationSetResponse$
];
var DeleteTrafficPolicy$ = [
9,
n02,
_DTP,
{ [_ht]: ["DELETE", "/2013-04-01/trafficpolicy/{Id}/{Version}", 200] },
() => DeleteTrafficPolicyRequest$,
() => DeleteTrafficPolicyResponse$
];
var DeleteTrafficPolicyInstance$ = [
9,
n02,
_DTPI,
{ [_ht]: ["DELETE", "/2013-04-01/trafficpolicyinstance/{Id}", 200] },
() => DeleteTrafficPolicyInstanceRequest$,
() => DeleteTrafficPolicyInstanceResponse$
];
var DeleteVPCAssociationAuthorization$ = [
9,
n02,
_DVPCAA,
{ [_ht]: ["POST", "/2013-04-01/hostedzone/{HostedZoneId}/deauthorizevpcassociation", 200] },
() => DeleteVPCAssociationAuthorizationRequest$,
() => DeleteVPCAssociationAuthorizationResponse$
];
var DisableHostedZoneDNSSEC$ = [
9,
n02,
_DHZDNSSEC,
{ [_ht]: ["POST", "/2013-04-01/hostedzone/{HostedZoneId}/disable-dnssec", 200] },
() => DisableHostedZoneDNSSECRequest$,
() => DisableHostedZoneDNSSECResponse$
];
var DisassociateVPCFromHostedZone$ = [
9,
n02,
_DVPCFHZ,
{ [_ht]: ["POST", "/2013-04-01/hostedzone/{HostedZoneId}/disassociatevpc", 200] },
() => DisassociateVPCFromHostedZoneRequest$,
() => DisassociateVPCFromHostedZoneResponse$
];
var EnableHostedZoneDNSSEC$ = [
9,
n02,
_EHZDNSSEC,
{ [_ht]: ["POST", "/2013-04-01/hostedzone/{HostedZoneId}/enable-dnssec", 200] },
() => EnableHostedZoneDNSSECRequest$,
() => EnableHostedZoneDNSSECResponse$
];
var GetAccountLimit$ = [
9,
n02,
_GAL,
{ [_ht]: ["GET", "/2013-04-01/accountlimit/{Type}", 200] },
() => GetAccountLimitRequest$,
() => GetAccountLimitResponse$
];
var GetChange$ = [
9,
n02,
_GC,
{ [_ht]: ["GET", "/2013-04-01/change/{Id}", 200] },
() => GetChangeRequest$,
() => GetChangeResponse$
];
var GetCheckerIpRanges$ = [
9,
n02,
_GCIR,
{ [_ht]: ["GET", "/2013-04-01/checkeripranges", 200] },
() => GetCheckerIpRangesRequest$,
() => GetCheckerIpRangesResponse$
];
var GetDNSSEC$ = [
9,
n02,
_GDNSSEC,
{ [_ht]: ["GET", "/2013-04-01/hostedzone/{HostedZoneId}/dnssec", 200] },
() => GetDNSSECRequest$,
() => GetDNSSECResponse$
];
var GetGeoLocation$ = [
9,
n02,
_GGL,
{ [_ht]: ["GET", "/2013-04-01/geolocation", 200] },
() => GetGeoLocationRequest$,
() => GetGeoLocationResponse$
];
var GetHealthCheck$ = [
9,
n02,
_GHC,
{ [_ht]: ["GET", "/2013-04-01/healthcheck/{HealthCheckId}", 200] },
() => GetHealthCheckRequest$,
() => GetHealthCheckResponse$
];
var GetHealthCheckCount$ = [
9,
n02,
_GHCC,
{ [_ht]: ["GET", "/2013-04-01/healthcheckcount", 200] },
() => GetHealthCheckCountRequest$,
() => GetHealthCheckCountResponse$
];
var GetHealthCheckLastFailureReason$ = [
9,
n02,
_GHCLFR,
{ [_ht]: ["GET", "/2013-04-01/healthcheck/{HealthCheckId}/lastfailurereason", 200] },
() => GetHealthCheckLastFailureReasonRequest$,
() => GetHealthCheckLastFailureReasonResponse$
];
var GetHealthCheckStatus$ = [
9,
n02,
_GHCS,
{ [_ht]: ["GET", "/2013-04-01/healthcheck/{HealthCheckId}/status", 200] },
() => GetHealthCheckStatusRequest$,
() => GetHealthCheckStatusResponse$
];
var GetHostedZone$ = [
9,
n02,
_GHZ,
{ [_ht]: ["GET", "/2013-04-01/hostedzone/{Id}", 200] },
() => GetHostedZoneRequest$,
() => GetHostedZoneResponse$
];
var GetHostedZoneCount$ = [
9,
n02,
_GHZC,
{ [_ht]: ["GET", "/2013-04-01/hostedzonecount", 200] },
() => GetHostedZoneCountRequest$,
() => GetHostedZoneCountResponse$
];
var GetHostedZoneLimit$ = [
9,
n02,
_GHZL,
{ [_ht]: ["GET", "/2013-04-01/hostedzonelimit/{HostedZoneId}/{Type}", 200] },
() => GetHostedZoneLimitRequest$,
() => GetHostedZoneLimitResponse$
];
var GetQueryLoggingConfig$ = [
9,
n02,
_GQLC,
{ [_ht]: ["GET", "/2013-04-01/queryloggingconfig/{Id}", 200] },
() => GetQueryLoggingConfigRequest$,
() => GetQueryLoggingConfigResponse$
];
var GetReusableDelegationSet$ = [
9,
n02,
_GRDS,
{ [_ht]: ["GET", "/2013-04-01/delegationset/{Id}", 200] },
() => GetReusableDelegationSetRequest$,
() => GetReusableDelegationSetResponse$
];
var GetReusableDelegationSetLimit$ = [
9,
n02,
_GRDSL,
{ [_ht]: ["GET", "/2013-04-01/reusabledelegationsetlimit/{DelegationSetId}/{Type}", 200] },
() => GetReusableDelegationSetLimitRequest$,
() => GetReusableDelegationSetLimitResponse$
];
var GetTrafficPolicy$ = [
9,
n02,
_GTP,
{ [_ht]: ["GET", "/2013-04-01/trafficpolicy/{Id}/{Version}", 200] },
() => GetTrafficPolicyRequest$,
() => GetTrafficPolicyResponse$
];
var GetTrafficPolicyInstance$ = [
9,
n02,
_GTPI,
{ [_ht]: ["GET", "/2013-04-01/trafficpolicyinstance/{Id}", 200] },
() => GetTrafficPolicyInstanceRequest$,
() => GetTrafficPolicyInstanceResponse$
];
var GetTrafficPolicyInstanceCount$ = [
9,
n02,
_GTPIC,
{ [_ht]: ["GET", "/2013-04-01/trafficpolicyinstancecount", 200] },
() => GetTrafficPolicyInstanceCountRequest$,
() => GetTrafficPolicyInstanceCountResponse$
];
var ListCidrBlocks$ = [
9,
n02,
_LCB,
{ [_ht]: ["GET", "/2013-04-01/cidrcollection/{CollectionId}/cidrblocks", 200] },
() => ListCidrBlocksRequest$,
() => ListCidrBlocksResponse$
];
var ListCidrCollections$ = [
9,
n02,
_LCC,
{ [_ht]: ["GET", "/2013-04-01/cidrcollection", 200] },
() => ListCidrCollectionsRequest$,
() => ListCidrCollectionsResponse$
];
var ListCidrLocations$ = [
9,
n02,
_LCL,
{ [_ht]: ["GET", "/2013-04-01/cidrcollection/{CollectionId}", 200] },
() => ListCidrLocationsRequest$,
() => ListCidrLocationsResponse$
];
var ListGeoLocations$ = [
9,
n02,
_LGL,
{ [_ht]: ["GET", "/2013-04-01/geolocations", 200] },
() => ListGeoLocationsRequest$,
() => ListGeoLocationsResponse$
];
var ListHealthChecks$ = [
9,
n02,
_LHC,
{ [_ht]: ["GET", "/2013-04-01/healthcheck", 200] },
() => ListHealthChecksRequest$,
() => ListHealthChecksResponse$
];
var ListHostedZones$ = [
9,
n02,
_LHZ,
{ [_ht]: ["GET", "/2013-04-01/hostedzone", 200] },
() => ListHostedZonesRequest$,
() => ListHostedZonesResponse$
];
var ListHostedZonesByName$ = [
9,
n02,
_LHZBN,
{ [_ht]: ["GET", "/2013-04-01/hostedzonesbyname", 200] },
() => ListHostedZonesByNameRequest$,
() => ListHostedZonesByNameResponse$
];
var ListHostedZonesByVPC$ = [
9,
n02,
_LHZBVPC,
{ [_ht]: ["GET", "/2013-04-01/hostedzonesbyvpc", 200] },
() => ListHostedZonesByVPCRequest$,
() => ListHostedZonesByVPCResponse$
];
var ListQueryLoggingConfigs$ = [
9,
n02,
_LQLC,
{ [_ht]: ["GET", "/2013-04-01/queryloggingconfig", 200] },
() => ListQueryLoggingConfigsRequest$,
() => ListQueryLoggingConfigsResponse$
];
var ListResourceRecordSets$ = [
9,
n02,
_LRRS,
{ [_ht]: ["GET", "/2013-04-01/hostedzone/{HostedZoneId}/rrset", 200] },
() => ListResourceRecordSetsRequest$,
() => ListResourceRecordSetsResponse$
];
var ListReusableDelegationSets$ = [
9,
n02,
_LRDS,
{ [_ht]: ["GET", "/2013-04-01/delegationset", 200] },
() => ListReusableDelegationSetsRequest$,
() => ListReusableDelegationSetsResponse$
];
var ListTagsForResource$ = [
9,
n02,
_LTFR,
{ [_ht]: ["GET", "/2013-04-01/tags/{ResourceType}/{ResourceId}", 200] },
() => ListTagsForResourceRequest$,
() => ListTagsForResourceResponse$
];
var ListTagsForResources$ = [
9,
n02,
_LTFRi,
{ [_ht]: ["POST", "/2013-04-01/tags/{ResourceType}", 200] },
() => ListTagsForResourcesRequest$,
() => ListTagsForResourcesResponse$
];
var ListTrafficPolicies$ = [
9,
n02,
_LTP,
{ [_ht]: ["GET", "/2013-04-01/trafficpolicies", 200] },
() => ListTrafficPoliciesRequest$,
() => ListTrafficPoliciesResponse$
];
var ListTrafficPolicyInstances$ = [
9,
n02,
_LTPI,
{ [_ht]: ["GET", "/2013-04-01/trafficpolicyinstances", 200] },
() => ListTrafficPolicyInstancesRequest$,
() => ListTrafficPolicyInstancesResponse$
];
var ListTrafficPolicyInstancesByHostedZone$ = [
9,
n02,
_LTPIBHZ,
{ [_ht]: ["GET", "/2013-04-01/trafficpolicyinstances/hostedzone", 200] },
() => ListTrafficPolicyInstancesByHostedZoneRequest$,
() => ListTrafficPolicyInstancesByHostedZoneResponse$
];
var ListTrafficPolicyInstancesByPolicy$ = [
9,
n02,
_LTPIBP,
{ [_ht]: ["GET", "/2013-04-01/trafficpolicyinstances/trafficpolicy", 200] },
() => ListTrafficPolicyInstancesByPolicyRequest$,
() => ListTrafficPolicyInstancesByPolicyResponse$
];
var ListTrafficPolicyVersions$ = [
9,
n02,
_LTPV,
{ [_ht]: ["GET", "/2013-04-01/trafficpolicies/{Id}/versions", 200] },
() => ListTrafficPolicyVersionsRequest$,
() => ListTrafficPolicyVersionsResponse$
];
var ListVPCAssociationAuthorizations$ = [
9,
n02,
_LVPCAA,
{ [_ht]: ["GET", "/2013-04-01/hostedzone/{HostedZoneId}/authorizevpcassociation", 200] },
() => ListVPCAssociationAuthorizationsRequest$,
() => ListVPCAssociationAuthorizationsResponse$
];
var TestDNSAnswer$ = [
9,
n02,
_TDNSA,
{ [_ht]: ["GET", "/2013-04-01/testdnsanswer", 200] },
() => TestDNSAnswerRequest$,
() => TestDNSAnswerResponse$
];
var UpdateHealthCheck$ = [
9,
n02,
_UHC,
{ [_ht]: ["POST", "/2013-04-01/healthcheck/{HealthCheckId}", 200] },
() => UpdateHealthCheckRequest$,
() => UpdateHealthCheckResponse$
];
var UpdateHostedZoneComment$ = [
9,
n02,
_UHZC,
{ [_ht]: ["POST", "/2013-04-01/hostedzone/{Id}", 200] },
() => UpdateHostedZoneCommentRequest$,
() => UpdateHostedZoneCommentResponse$
];
var UpdateHostedZoneFeatures$ = [
9,
n02,
_UHZF,
{ [_ht]: ["POST", "/2013-04-01/hostedzone/{HostedZoneId}/features", 200] },
() => UpdateHostedZoneFeaturesRequest$,
() => UpdateHostedZoneFeaturesResponse$
];
var UpdateTrafficPolicyComment$ = [
9,
n02,
_UTPC,
{ [_ht]: ["POST", "/2013-04-01/trafficpolicy/{Id}/{Version}", 200] },
() => UpdateTrafficPolicyCommentRequest$,
() => UpdateTrafficPolicyCommentResponse$
];
var UpdateTrafficPolicyInstance$ = [
9,
n02,
_UTPI,
{ [_ht]: ["POST", "/2013-04-01/trafficpolicyinstance/{Id}", 200] },
() => UpdateTrafficPolicyInstanceRequest$,
() => UpdateTrafficPolicyInstanceResponse$
];
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/runtimeConfig.shared.js
var getRuntimeConfig2 = (config) => {
return {
apiVersion: "2013-04-01",
base64Decoder: config?.base64Decoder ?? import_serde3.fromBase64,
base64Encoder: config?.base64Encoder ?? import_serde3.toBase64,
disableHostPrefix: config?.disableHostPrefix ?? false,
endpointProvider: config?.endpointProvider ?? defaultEndpointResolver2,
extensions: config?.extensions ?? [],
httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultRoute53HttpAuthSchemeProvider,
httpAuthSchemes: config?.httpAuthSchemes ?? [
{
schemeId: "aws.auth#sigv4",
identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
signer: new import_httpAuthSchemes2.AwsSdkSigV4Signer
}
],
logger: config?.logger ?? new import_client19.NoOpLogger,
protocol: config?.protocol ?? import_protocols4.AwsRestXmlProtocol,
protocolSettings: config?.protocolSettings ?? {
defaultNamespace: "com.amazonaws.route53",
errorTypeRegistries: errorTypeRegistries2,
xmlNamespace: "https://route53.amazonaws.com/doc/2013-04-01/",
version: "2013-04-01",
serviceTarget: "AWSDnsV20130401"
},
serviceId: config?.serviceId ?? "Route 53",
sha256: config?.sha256 ?? import_checksum.Sha256,
urlParser: config?.urlParser ?? import_protocols5.parseUrl,
utf8Decoder: config?.utf8Decoder ?? import_serde3.fromUtf8,
utf8Encoder: config?.utf8Encoder ?? import_serde3.toUtf8
};
};
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/runtimeConfig.js
var getRuntimeConfig3 = (config) => {
import_client21.emitWarningIfUnsupportedVersion(process.version);
const defaultsMode = import_config28.resolveDefaultsModeConfig(config);
const defaultConfigProvider = () => defaultsMode().then(import_client21.loadConfigsForDefaultMode);
const clientSharedValues = getRuntimeConfig2(config);
import_client20.emitWarningIfUnsupportedVersion(process.version);
const loaderConfig = {
profile: config?.profile,
logger: clientSharedValues.logger
};
return {
...clientSharedValues,
...config,
runtime: "node",
defaultsMode,
authSchemePreference: config?.authSchemePreference ?? import_config28.loadConfig(import_httpAuthSchemes3.NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
bodyLengthChecker: config?.bodyLengthChecker ?? import_serde4.calculateBodyLength,
credentialDefaultProvider: config?.credentialDefaultProvider ?? defaultProvider,
defaultUserAgentProvider: config?.defaultUserAgentProvider ?? import_client20.createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: package_default.version }),
maxAttempts: config?.maxAttempts ?? import_config28.loadConfig(import_retry3.NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
region: config?.region ?? import_config28.loadConfig(import_config28.NODE_REGION_CONFIG_OPTIONS, { ...import_config28.NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
requestHandler: import_node_http_handler2.NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
retryMode: config?.retryMode ?? import_config28.loadConfig({
...import_retry3.NODE_RETRY_MODE_CONFIG_OPTIONS,
default: async () => (await defaultConfigProvider()).retryMode || import_retry3.DEFAULT_RETRY_MODE
}, config),
streamCollector: config?.streamCollector ?? import_node_http_handler2.streamCollector,
useDualstackEndpoint: config?.useDualstackEndpoint ?? import_config28.loadConfig(import_config28.NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
useFipsEndpoint: config?.useFipsEndpoint ?? import_config28.loadConfig(import_config28.NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
userAgentAppId: config?.userAgentAppId ?? import_config28.loadConfig(import_client20.NODE_APP_ID_CONFIG_OPTIONS, loaderConfig)
};
};
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/runtimeExtensions.js
var import_client22 = __toESM(require_client2());
var import_client23 = __toESM(require_client());
var import_protocols6 = __toESM(require_protocols());
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/auth/httpAuthExtensionConfiguration.js
var getHttpAuthExtensionConfiguration2 = (runtimeConfig) => {
const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
let _credentials = runtimeConfig.credentials;
return {
setHttpAuthScheme(httpAuthScheme) {
const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
if (index === -1) {
_httpAuthSchemes.push(httpAuthScheme);
} else {
_httpAuthSchemes.splice(index, 1, httpAuthScheme);
}
},
httpAuthSchemes() {
return _httpAuthSchemes;
},
setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
_httpAuthSchemeProvider = httpAuthSchemeProvider;
},
httpAuthSchemeProvider() {
return _httpAuthSchemeProvider;
},
setCredentials(credentials) {
_credentials = credentials;
},
credentials() {
return _credentials;
}
};
};
var resolveHttpAuthRuntimeConfig2 = (config) => {
return {
httpAuthSchemes: config.httpAuthSchemes(),
httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
credentials: config.credentials()
};
};
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/runtimeExtensions.js
var resolveRuntimeExtensions2 = (runtimeConfig, extensions) => {
const extensionConfiguration = Object.assign(import_client22.getAwsRegionExtensionConfiguration(runtimeConfig), import_client23.getDefaultExtensionConfiguration(runtimeConfig), import_protocols6.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration2(runtimeConfig));
extensions.forEach((extension) => extension.configure(extensionConfiguration));
return Object.assign(runtimeConfig, import_client22.resolveAwsRegionExtensionConfiguration(extensionConfiguration), import_client23.resolveDefaultRuntimeConfig(extensionConfiguration), import_protocols6.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig2(extensionConfiguration));
};
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/Route53Client.js
class Route53Client extends import_client25.Client {
config;
constructor(...[configuration]) {
const _config_0 = getRuntimeConfig3(configuration || {});
super(_config_0);
this.initConfig = _config_0;
const _config_1 = resolveClientEndpointParameters(_config_0);
const _config_2 = import_client24.resolveUserAgentConfig(_config_1);
const _config_3 = import_retry4.resolveRetryConfig(_config_2);
const _config_4 = import_config29.resolveRegionConfig(_config_3);
const _config_5 = import_client24.resolveHostHeaderConfig(_config_4);
const _config_6 = import_endpoints3.resolveEndpointConfig(_config_5);
const _config_7 = resolveHttpAuthSchemeConfig(_config_6);
const _config_8 = resolveRuntimeExtensions2(_config_7, configuration?.extensions || []);
this.config = _config_8;
this.middlewareStack.use(import_schema2.getSchemaSerdePlugin(this.config));
this.middlewareStack.use(import_client24.getUserAgentPlugin(this.config));
this.middlewareStack.use(import_retry4.getRetryPlugin(this.config));
this.middlewareStack.use(import_protocols7.getContentLengthPlugin(this.config));
this.middlewareStack.use(import_client24.getHostHeaderPlugin(this.config));
this.middlewareStack.use(import_client24.getLoggerPlugin(this.config));
this.middlewareStack.use(import_client24.getRecursionDetectionPlugin(this.config));
this.middlewareStack.use(import_core.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
httpAuthSchemeParametersProvider: defaultRoute53HttpAuthSchemeParametersProvider,
identityProviderConfigProvider: async (config) => new import_core.DefaultIdentityProviderConfig({
"aws.auth#sigv4": config.credentials
})
}));
this.middlewareStack.use(import_core.getHttpSigningPlugin(this.config));
}
destroy() {
super.destroy();
}
}
// ../../node_modules/.bun/@aws-sdk+middleware-sdk-route53@3.972.26/node_modules/@aws-sdk/middleware-sdk-route53/dist-es/constants.js
var IDENTIFIER_PREFIX_PATTERN = /^\/(hostedzone|change|delegationset)\//;
// ../../node_modules/.bun/@aws-sdk+middleware-sdk-route53@3.972.26/node_modules/@aws-sdk/middleware-sdk-route53/dist-es/change-resource-record-sets.js
function changeResourceRecordSetsMiddleware() {
return (next) => async (args) => {
const { ChangeBatch } = args.input;
const Changes = [];
for (const change of ChangeBatch?.Changes ?? []) {
const { AliasTarget } = change.ResourceRecordSet ?? {};
if (AliasTarget) {
Changes.push({
...change,
ResourceRecordSet: {
...change.ResourceRecordSet,
AliasTarget: {
...AliasTarget,
HostedZoneId: AliasTarget.HostedZoneId.replace(IDENTIFIER_PREFIX_PATTERN, "")
}
}
});
} else {
Changes.push(change);
}
}
return next({
...args,
input: {
...args.input,
ChangeBatch: {
...ChangeBatch,
Changes
}
}
});
};
}
var changeResourceRecordSetsMiddlewareOptions = {
step: "initialize",
tags: ["ROUTE53_IDS", "CHANGE_RESOURCE_RECORD_SETS"],
name: "changeResourceRecordSetsMiddleware",
override: true
};
var getChangeResourceRecordSetsPlugin = (unused) => ({
applyToStack: (clientStack) => {
clientStack.add(changeResourceRecordSetsMiddleware(), changeResourceRecordSetsMiddlewareOptions);
}
});
// ../../node_modules/.bun/@aws-sdk+middleware-sdk-route53@3.972.26/node_modules/@aws-sdk/middleware-sdk-route53/dist-es/id-normalizer.js
var IDENTIFIER_PARAMETERS = ["DelegationSetId", "HostedZoneId", "Id"];
function idNormalizerMiddleware() {
return (next) => async (args) => {
const input = { ...args.input };
for (const paramName of IDENTIFIER_PARAMETERS) {
const param = input[paramName];
if (param) {
input[paramName] = param.replace(IDENTIFIER_PREFIX_PATTERN, "");
}
}
return next({
...args,
input
});
};
}
var idNormalizerMiddlewareOptions = {
step: "initialize",
tags: ["ROUTE53_IDS"],
name: "idNormalizerMiddleware",
override: true
};
var getIdNormalizerPlugin = (unused) => ({
applyToStack: (clientStack) => {
clientStack.add(idNormalizerMiddleware(), idNormalizerMiddlewareOptions);
}
});
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/commandBuilder.js
var import_client26 = __toESM(require_client());
var import_endpoints4 = __toESM(require_endpoints());
var command2 = import_client26.makeBuilder(commonParams, "AWSDnsV20130401", "Route53Client", import_endpoints4.getEndpointPlugin);
var _ep02 = {};
var _mw02 = (Command, cs, config, o) => [
getIdNormalizerPlugin(config)
];
var _mw1 = (Command, cs, config, o) => [
getChangeResourceRecordSetsPlugin(config),
getIdNormalizerPlugin(config)
];
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/commands/ChangeResourceRecordSetsCommand.js
class ChangeResourceRecordSetsCommand extends command2(_ep02, _mw1, "ChangeResourceRecordSets", ChangeResourceRecordSets$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/commands/CreateHostedZoneCommand.js
class CreateHostedZoneCommand extends command2(_ep02, _mw02, "CreateHostedZone", CreateHostedZone$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/commands/DeleteHostedZoneCommand.js
class DeleteHostedZoneCommand extends command2(_ep02, _mw02, "DeleteHostedZone", DeleteHostedZone$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/commands/GetHostedZoneCommand.js
class GetHostedZoneCommand extends command2(_ep02, _mw02, "GetHostedZone", GetHostedZone$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/commands/ListHostedZonesCommand.js
class ListHostedZonesCommand extends command2(_ep02, _mw02, "ListHostedZones", ListHostedZones$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53@3.1127.0/node_modules/@aws-sdk/client-route-53/dist-es/commands/ListResourceRecordSetsCommand.js
class ListResourceRecordSetsCommand extends command2(_ep02, _mw02, "ListResourceRecordSets", ListResourceRecordSets$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/Route53DomainsClient.js
var import_client35 = __toESM(require_client2());
var import_core2 = __toESM(require_dist_cjs2());
var import_client36 = __toESM(require_client());
var import_config31 = __toESM(require_config());
var import_endpoints7 = __toESM(require_endpoints());
var import_protocols11 = __toESM(require_protocols());
var import_retry6 = __toESM(require_retry());
var import_schema4 = __toESM(require_schema());
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/auth/httpAuthSchemeProvider.js
var import_httpAuthSchemes4 = __toESM(require_httpAuthSchemes());
var import_client27 = __toESM(require_client());
var defaultRoute53DomainsHttpAuthSchemeParametersProvider = async (config, context, input) => {
return {
operation: import_client27.getSmithyContext(context).operation,
region: await import_client27.normalizeProvider(config.region)() || (() => {
throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
})()
};
};
function createAwsAuthSigv4HttpAuthOption3(authParameters) {
return {
schemeId: "aws.auth#sigv4",
signingProperties: {
name: "route53domains",
region: authParameters.region
},
propertiesExtractor: (config, context) => ({
signingProperties: {
config,
context
}
})
};
}
var defaultRoute53DomainsHttpAuthSchemeProvider = (authParameters) => {
const options = [];
switch (authParameters.operation) {
default: {
options.push(createAwsAuthSigv4HttpAuthOption3(authParameters));
}
}
return options;
};
var resolveHttpAuthSchemeConfig3 = (config) => {
const config_0 = import_httpAuthSchemes4.resolveAwsSdkSigV4Config(config);
return Object.assign(config_0, {
authSchemePreference: import_client27.normalizeProvider(config.authSchemePreference ?? [])
});
};
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/endpoint/EndpointParameters.js
var resolveClientEndpointParameters3 = (options) => {
return Object.assign(options, {
useDualstackEndpoint: options.useDualstackEndpoint ?? false,
useFipsEndpoint: options.useFipsEndpoint ?? false,
defaultSigningName: "route53domains"
});
};
var commonParams3 = {
UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
Endpoint: { type: "builtInParams", name: "endpoint" },
Region: { type: "builtInParams", name: "region" },
UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
};
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/package.json
var package_default2 = {
name: "@aws-sdk/client-route-53-domains",
version: "3.1127.0",
description: "AWS SDK for JavaScript Route 53 Domains Client for Node.js, Browser and React Native",
homepage: "https://github.com/aws/aws-sdk-js-v3/tree/main/clients/client-route-53-domains",
license: "Apache-2.0",
author: {
name: "AWS SDK for JavaScript Team",
url: "https://aws.amazon.com/sdk-for-javascript/"
},
repository: {
type: "git",
url: "https://github.com/aws/aws-sdk-js-v3.git",
directory: "clients/client-route-53-domains"
},
files: [
"dist-*/**"
],
sideEffects: false,
main: "./dist-cjs/index.js",
module: "./dist-es/index.js",
browser: {
"./dist-es/runtimeConfig": "./dist-es/runtimeConfig.browser"
},
types: "./dist-types/index.d.ts",
typesVersions: {
"<4.5": {
"dist-types/*": [
"dist-types/ts3.4/*"
]
}
},
"react-native": {
"./dist-es/runtimeConfig": "./dist-es/runtimeConfig.native"
},
scripts: {
build: "concurrently 'yarn:build:types' 'yarn:build:es' && yarn build:cjs",
"build:cjs": "node ../../scripts/compilation/inline",
"build:es": "premove dist-es && tsc -p tsconfig.es.json",
"build:include:deps": 'yarn g:turbo run build -F="$npm_package_name"',
"build:types": "premove dist-types && tsc -p tsconfig.types.json",
"build:types:downlevel": "downlevel-dts dist-types dist-types/ts3.4",
clean: "premove dist-cjs dist-es dist-types",
"extract:docs": "api-extractor run --local",
"generate:client": "node ../../scripts/generate-clients/single-service",
"test:e2e": "yarn g:vitest run -c vitest.config.e2e.mts",
"test:e2e:watch": "yarn g:vitest watch -c vitest.config.e2e.mts",
"test:index": "tsc -p tsconfig.test.json && node ./test/index-objects.spec.mjs"
},
dependencies: {
"@aws-sdk/core": "^3.977.9",
"@aws-sdk/credential-provider-node": "^3.972.82",
"@aws-sdk/types": "^3.974.5",
"@smithy/core": "^3.33.3",
"@smithy/fetch-http-handler": "^5.7.2",
"@smithy/node-http-handler": "^4.11.3",
"@smithy/types": "^4.17.2",
tslib: "^2.6.2"
},
devDependencies: {
"@tsconfig/node20": "20.1.8",
"@types/node": "^20.14.8",
concurrently: "7.0.0",
"downlevel-dts": "0.10.1",
premove: "4.0.0",
typescript: "~7.0.2"
},
engines: {
node: ">=20.0.0"
}
};
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/runtimeConfig.js
var import_client31 = __toESM(require_client2());
var import_httpAuthSchemes6 = __toESM(require_httpAuthSchemes());
var import_client32 = __toESM(require_client());
var import_config30 = __toESM(require_config());
var import_retry5 = __toESM(require_retry());
var import_serde6 = __toESM(require_serde());
var import_node_http_handler3 = __toESM(require_dist_cjs4());
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/runtimeConfig.shared.js
var import_httpAuthSchemes5 = __toESM(require_httpAuthSchemes());
var import_protocols8 = __toESM(require_protocols2());
var import_checksum2 = __toESM(require_checksum());
var import_client30 = __toESM(require_client());
var import_protocols9 = __toESM(require_protocols());
var import_serde5 = __toESM(require_serde());
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/endpoint/endpointResolver.js
var import_client28 = __toESM(require_client2());
var import_endpoints6 = __toESM(require_endpoints());
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/endpoint/bdd.js
var import_endpoints5 = __toESM(require_endpoints());
var k3 = "ref";
var a3 = -1;
var b3 = true;
var c3 = "isSet";
var d3 = "PartitionResult";
var e4 = "booleanEquals";
var f3 = "getAttr";
var g3 = { [k3]: "Endpoint" };
var h3 = { [k3]: d3 };
var i3 = {};
var j3 = [{ [k3]: "Region" }];
var _data3 = {
conditions: [
[c3, [g3]],
[c3, j3],
["aws.partition", j3, d3],
[e4, [{ [k3]: "UseFIPS" }, b3]],
[e4, [{ [k3]: "UseDualStack" }, b3]],
[e4, [{ fn: f3, argv: [h3, "supportsDualStack"] }, b3]],
[e4, [{ fn: f3, argv: [h3, "supportsFIPS"] }, b3]]
],
results: [
[a3],
[a3, "Invalid Configuration: FIPS and custom endpoint are not supported"],
[a3, "Invalid Configuration: Dualstack and custom endpoint are not supported"],
[g3, i3],
["https://route53domains-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", i3],
[a3, "FIPS and DualStack are enabled, but this partition does not support one or both"],
["https://route53domains-fips.{Region}.{PartitionResult#dnsSuffix}", i3],
[a3, "FIPS is enabled but this partition does not support FIPS"],
["https://route53domains.{Region}.{PartitionResult#dualStackDnsSuffix}", i3],
[a3, "DualStack is enabled but this partition does not support DualStack"],
["https://route53domains.{Region}.{PartitionResult#dnsSuffix}", i3],
[a3, "Invalid Configuration: Missing Region"]
]
};
var root3 = 2;
var r4 = 1e8;
var nodes3 = new Int32Array([
-1,
1,
-1,
0,
12,
3,
1,
4,
r4 + 11,
2,
5,
r4 + 11,
3,
8,
6,
4,
7,
r4 + 10,
5,
r4 + 8,
r4 + 9,
4,
10,
9,
6,
r4 + 6,
r4 + 7,
5,
11,
r4 + 5,
6,
r4 + 4,
r4 + 5,
3,
r4 + 1,
13,
4,
r4 + 2,
r4 + 3
]);
var bdd3 = import_endpoints5.BinaryDecisionDiagram.from(nodes3, root3, _data3.conditions, _data3.results);
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/endpoint/endpointResolver.js
var cache3 = new import_endpoints6.EndpointCache({
size: 50,
params: ["Endpoint", "Region", "UseDualStack", "UseFIPS"]
});
var defaultEndpointResolver3 = (endpointParams, context = {}) => {
return cache3.get(endpointParams, () => import_endpoints6.decideEndpoint(bdd3, {
endpointParams,
logger: context.logger
}));
};
import_endpoints6.customEndpointFunctions.aws = import_client28.awsEndpointFunctions;
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/schemas/schemas_0.js
var import_schema3 = __toESM(require_schema());
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/models/Route53DomainsServiceException.js
var import_client29 = __toESM(require_client());
class Route53DomainsServiceException extends import_client29.ServiceException {
constructor(options) {
super(options);
Object.setPrototypeOf(this, Route53DomainsServiceException.prototype);
}
}
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/models/errors.js
class DomainLimitExceeded extends Route53DomainsServiceException {
name = "DomainLimitExceeded";
$fault = "client";
constructor(opts) {
super({
name: "DomainLimitExceeded",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, DomainLimitExceeded.prototype);
}
}
class InvalidInput2 extends Route53DomainsServiceException {
name = "InvalidInput";
$fault = "client";
constructor(opts) {
super({
name: "InvalidInput",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, InvalidInput2.prototype);
}
}
class OperationLimitExceeded extends Route53DomainsServiceException {
name = "OperationLimitExceeded";
$fault = "client";
constructor(opts) {
super({
name: "OperationLimitExceeded",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, OperationLimitExceeded.prototype);
}
}
class UnsupportedTLD extends Route53DomainsServiceException {
name = "UnsupportedTLD";
$fault = "client";
constructor(opts) {
super({
name: "UnsupportedTLD",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, UnsupportedTLD.prototype);
}
}
class DnssecLimitExceeded extends Route53DomainsServiceException {
name = "DnssecLimitExceeded";
$fault = "client";
constructor(opts) {
super({
name: "DnssecLimitExceeded",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, DnssecLimitExceeded.prototype);
}
}
class DuplicateRequest extends Route53DomainsServiceException {
name = "DuplicateRequest";
$fault = "client";
requestId;
constructor(opts) {
super({
name: "DuplicateRequest",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, DuplicateRequest.prototype);
this.requestId = opts.requestId;
}
}
class TLDRulesViolation extends Route53DomainsServiceException {
name = "TLDRulesViolation";
$fault = "client";
constructor(opts) {
super({
name: "TLDRulesViolation",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TLDRulesViolation.prototype);
}
}
class TLDInMaintenance extends Route53DomainsServiceException {
name = "TLDInMaintenance";
$fault = "client";
tld;
constructor(opts) {
super({
name: "TLDInMaintenance",
$fault: "client",
...opts
});
Object.setPrototypeOf(this, TLDInMaintenance.prototype);
this.tld = opts.tld;
}
}
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/schemas/schemas_0.js
var _A2 = "Availability";
var _ACE = "AbuseContactEmail";
var _ACP = "AbuseContactPhone";
var _ACd = "AdminContact";
var _AL2 = "AddressLine";
var _ALd = "AddressLine1";
var _ALdd = "AddressLine2";
var _AP = "AdminPrivacy";
var _AR2 = "AutoRenew";
var _Al = "Algorithm";
var _BC = "BillingContact";
var _BP = "BillingPrivacy";
var _C2 = "City";
var _CC2 = "CountryCode";
var _CD2 = "ContactDetail";
var _CDA = "CheckDomainAvailability";
var _CDAR = "CheckDomainAvailabilityRequest";
var _CDARh = "CheckDomainAvailabilityResponse";
var _CDr = "CreationDate";
var _CN2 = "ContactName";
var _CNo2 = "ContactNumber";
var _COP = "ChangeOwnershipPrice";
var _CT2 = "ContactType";
var _Cu = "Currency";
var _D2 = "Digest";
var _DIY = "DurationInYears";
var _DK = "DnssecKey";
var _DKL = "DnssecKeyList";
var _DKn = "DnssecKeys";
var _DLE = "DnssecLimitExceeded";
var _DLEo = "DomainLimitExceeded";
var _DN = "DomainName";
var _DP = "DomainPrice";
var _DPL = "DomainPriceList";
var _DR = "DuplicateRequest";
var _DSLo = "DomainSummaryList";
var _DSn = "DnsSec";
var _DSo = "DomainSummary";
var _DT = "DigestType";
var _DTFDR = "DeleteTagsForDomainRequest";
var _Do2 = "Domains";
var _E = "Email";
var _ED = "ExpirationDate";
var _EP2 = "ExtraParams";
var _EPL = "ExtraParamList";
var _EPV = "ExtraParamValue";
var _EPx = "ExtraParam";
var _Ex = "Expiry";
var _F2 = "Fax";
var _FC = "FilterCondition";
var _FCi = "FilterConditions";
var _FIAK = "FIAuthKey";
var _FN = "FirstName";
var _Fl2 = "Flags";
var _GDD = "GetDomainDetail";
var _GDDR = "GetDomainDetailRequest";
var _GDDRe = "GetDomainDetailResponse";
var _GI = "GlueIps";
var _GOD = "GetOperationDetail";
var _GODR = "GetOperationDetailRequest";
var _GODRe = "GetOperationDetailResponse";
var _I2 = "Id";
var _II2 = "InvalidInput";
var _ILC = "IdnLangCode";
var _KT2 = "KeyTag";
var _LD = "ListDomains";
var _LDR = "ListDomainsRequest";
var _LDRi = "ListDomainsResponse";
var _LN2 = "LastName";
var _LOR = "ListOperationsRequest";
var _LP = "ListPrices";
var _LPR = "ListPricesRequest";
var _LPRi = "ListPricesResponse";
var _LUD = "LastUpdatedDate";
var _M2 = "Message";
var _MI2 = "MaxItems";
var _Ma2 = "Marker";
var _N2 = "Name";
var _NL = "NameserverList";
var _NPM = "NextPageMarker";
var _Na2 = "Nameservers";
var _Nam2 = "Nameserver";
var _OI = "OperationId";
var _OLE = "OperationLimitExceeded";
var _ON = "OrganizationName";
var _Op = "Operator";
var _PK2 = "PublicKey";
var _PN = "PhoneNumber";
var _PPAC = "PrivacyProtectAdminContact";
var _PPBC = "PrivacyProtectBillingContact";
var _PPRC = "PrivacyProtectRegistrantContact";
var _PPTC = "PrivacyProtectTechContact";
var _PWC = "PriceWithCurrency";
var _Pr2 = "Price";
var _Pri = "Prices";
var _R2 = "Reseller";
var _RC3 = "RegistrantContact";
var _RD2 = "RegisterDomain";
var _RDI = "RegistryDomainId";
var _RDR = "RegisterDomainRequest";
var _RDRe = "RegisterDomainResponse";
var _RN2 = "RegistrarName";
var _RP2 = "RegistrationPrice";
var _RPe = "RenewalPrice";
var _RPeg = "RegistrantPrivacy";
var _RPes = "RestorationPrice";
var _RU = "RegistrarUrl";
var _S2 = "State";
var _SB = "SortBy";
var _SCo = "SortCondition";
var _SD = "SubmittedDate";
var _SF = "StatusFlag";
var _SL = "StatusList";
var _SO = "SortOrder";
var _SS2 = "SubmittedSince";
var _St2 = "Status";
var _TC = "TechContact";
var _TL2 = "TransferLock";
var _TLDIM = "TLDInMaintenance";
var _TLDRV = "TLDRulesViolation";
var _TP2 = "TransferPrice";
var _TPe = "TechPrivacy";
var _TTD = "TagsToDelete";
var _Tl = "Tld";
var _Ty = "Type";
var _UD = "UpdatedDate";
var _UDN = "UpdateDomainNameservers";
var _UDNR = "UpdateDomainNameserversRequest";
var _UDNRp = "UpdateDomainNameserversResponse";
var _UTLD = "UnsupportedTLD";
var _V2 = "Value";
var _Va = "Values";
var _WIS = "WhoIsServer";
var _ZC = "ZipCode";
var _c3 = "client";
var _e3 = "error";
var _hE3 = "httpError";
var _m3 = "message";
var _rI = "requestId";
var _s3 = "smithy.ts.sdk.synthetic.com.amazonaws.route53domains";
var _t2 = "tld";
var n03 = "com.amazonaws.route53domains";
var _s_registry3 = import_schema3.TypeRegistry.for(_s3);
var Route53DomainsServiceException$ = [-3, _s3, "Route53DomainsServiceException", 0, [], []];
_s_registry3.registerError(Route53DomainsServiceException$, Route53DomainsServiceException);
var n0_registry3 = import_schema3.TypeRegistry.for(n03);
var DnssecLimitExceeded$ = [
-3,
n03,
_DLE,
{ [_e3]: _c3, [_hE3]: 400 },
[_m3],
[0]
];
n0_registry3.registerError(DnssecLimitExceeded$, DnssecLimitExceeded);
var DomainLimitExceeded$ = [
-3,
n03,
_DLEo,
{ [_e3]: _c3, [_hE3]: 400 },
[_m3],
[0]
];
n0_registry3.registerError(DomainLimitExceeded$, DomainLimitExceeded);
var DuplicateRequest$ = [
-3,
n03,
_DR,
{ [_e3]: _c3, [_hE3]: 400 },
[_rI, _m3],
[0, 0]
];
n0_registry3.registerError(DuplicateRequest$, DuplicateRequest);
var InvalidInput$2 = [
-3,
n03,
_II2,
{ [_e3]: _c3, [_hE3]: 400 },
[_m3],
[0]
];
n0_registry3.registerError(InvalidInput$2, InvalidInput2);
var OperationLimitExceeded$ = [
-3,
n03,
_OLE,
{ [_e3]: _c3, [_hE3]: 400 },
[_m3],
[0]
];
n0_registry3.registerError(OperationLimitExceeded$, OperationLimitExceeded);
var TLDInMaintenance$ = [
-3,
n03,
_TLDIM,
{ [_e3]: _c3, [_hE3]: 400 },
[_m3, _t2],
[0, 0]
];
n0_registry3.registerError(TLDInMaintenance$, TLDInMaintenance);
var TLDRulesViolation$ = [
-3,
n03,
_TLDRV,
{ [_e3]: _c3, [_hE3]: 400 },
[_m3],
[0]
];
n0_registry3.registerError(TLDRulesViolation$, TLDRulesViolation);
var UnsupportedTLD$ = [
-3,
n03,
_UTLD,
{ [_e3]: _c3, [_hE3]: 400 },
[_m3],
[0]
];
n0_registry3.registerError(UnsupportedTLD$, UnsupportedTLD);
var errorTypeRegistries3 = [
_s_registry3,
n0_registry3
];
var AddressLine = [0, n03, _AL2, 8, 0];
var City = [0, n03, _C2, 8, 0];
var ContactName = [0, n03, _CN2, 8, 0];
var ContactNumber = [0, n03, _CNo2, 8, 0];
var CountryCode = [0, n03, _CC2, 8, 0];
var Email = [0, n03, _E, 8, 0];
var ExtraParamValue = [0, n03, _EPV, 8, 0];
var FIAuthKey = [0, n03, _FIAK, 8, 0];
var State = [0, n03, _S2, 8, 0];
var ZipCode = [0, n03, _ZC, 8, 0];
var CheckDomainAvailabilityRequest$ = [
3,
n03,
_CDAR,
0,
[_DN, _ILC],
[0, 0],
1
];
var CheckDomainAvailabilityResponse$ = [
3,
n03,
_CDARh,
0,
[_A2],
[0]
];
var ContactDetail$ = [
3,
n03,
_CD2,
8,
[_FN, _LN2, _CT2, _ON, _ALd, _ALdd, _C2, _S2, _CC2, _ZC, _PN, _E, _F2, _EP2],
[[() => ContactName, 0], [() => ContactName, 0], 0, [() => ContactName, 0], [() => AddressLine, 0], [() => AddressLine, 0], [() => City, 0], [() => State, 0], [() => CountryCode, 0], [() => ZipCode, 0], [() => ContactNumber, 0], [() => Email, 0], [() => ContactNumber, 0], [() => ExtraParamList, 0]]
];
var DeleteTagsForDomainRequest$ = [
3,
n03,
_DTFDR,
0,
[_DN, _TTD],
[0, 64 | 0],
2
];
var DnssecKey$ = [
3,
n03,
_DK,
0,
[_Al, _Fl2, _PK2, _DT, _D2, _KT2, _I2],
[1, 1, 0, 1, 0, 1, 0]
];
var DomainPrice$ = [
3,
n03,
_DP,
0,
[_N2, _RP2, _TP2, _RPe, _COP, _RPes],
[0, () => PriceWithCurrency$, () => PriceWithCurrency$, () => PriceWithCurrency$, () => PriceWithCurrency$, () => PriceWithCurrency$]
];
var DomainSummary$ = [
3,
n03,
_DSo,
0,
[_DN, _AR2, _TL2, _Ex],
[0, 2, 2, 4]
];
var ExtraParam$ = [
3,
n03,
_EPx,
0,
[_N2, _V2],
[0, [() => ExtraParamValue, 0]],
2
];
var FilterCondition$ = [
3,
n03,
_FC,
0,
[_N2, _Op, _Va],
[0, 0, 64 | 0],
3
];
var GetDomainDetailRequest$ = [
3,
n03,
_GDDR,
0,
[_DN],
[0],
1
];
var GetDomainDetailResponse$ = [
3,
n03,
_GDDRe,
0,
[_DN, _Na2, _AR2, _ACd, _RC3, _TC, _AP, _RPeg, _TPe, _RN2, _WIS, _RU, _ACE, _ACP, _RDI, _CDr, _UD, _ED, _R2, _DSn, _SL, _DKn, _BC, _BP],
[0, () => NameserverList, 2, [() => ContactDetail$, 0], [() => ContactDetail$, 0], [() => ContactDetail$, 0], 2, 2, 2, 0, 0, 0, [() => Email, 0], [() => ContactNumber, 0], 0, 4, 4, 4, 0, 0, 64 | 0, () => DnssecKeyList, [() => ContactDetail$, 0], 2]
];
var GetOperationDetailRequest$ = [
3,
n03,
_GODR,
0,
[_OI],
[0],
1
];
var GetOperationDetailResponse$ = [
3,
n03,
_GODRe,
0,
[_OI, _St2, _M2, _DN, _Ty, _SD, _LUD, _SF],
[0, 0, 0, 0, 0, 4, 4, 0]
];
var ListDomainsRequest$ = [
3,
n03,
_LDR,
0,
[_FCi, _SCo, _Ma2, _MI2],
[() => FilterConditions, () => SortCondition$, 0, 1]
];
var ListDomainsResponse$ = [
3,
n03,
_LDRi,
0,
[_Do2, _NPM],
[() => DomainSummaryList, 0]
];
var ListOperationsRequest$ = [
3,
n03,
_LOR,
0,
[_SS2, _Ma2, _MI2, _St2, _Ty, _SB, _SO],
[4, 0, 1, 64 | 0, 64 | 0, 0, 0]
];
var ListPricesRequest$ = [
3,
n03,
_LPR,
0,
[_Tl, _Ma2, _MI2],
[0, 0, 1]
];
var ListPricesResponse$ = [
3,
n03,
_LPRi,
0,
[_Pri, _NPM],
[() => DomainPriceList, 0]
];
var Nameserver$ = [
3,
n03,
_Nam2,
0,
[_N2, _GI],
[0, 64 | 0],
1
];
var PriceWithCurrency$ = [
3,
n03,
_PWC,
0,
[_Pr2, _Cu],
[1, 0],
2
];
var RegisterDomainRequest$ = [
3,
n03,
_RDR,
0,
[_DN, _DIY, _ACd, _RC3, _TC, _ILC, _AR2, _PPAC, _PPRC, _PPTC, _BC, _PPBC],
[0, 1, [() => ContactDetail$, 0], [() => ContactDetail$, 0], [() => ContactDetail$, 0], 0, 2, 2, 2, 2, [() => ContactDetail$, 0], 2],
5
];
var RegisterDomainResponse$ = [
3,
n03,
_RDRe,
0,
[_OI],
[0]
];
var SortCondition$ = [
3,
n03,
_SCo,
0,
[_N2, _SO],
[0, 0],
2
];
var UpdateDomainNameserversRequest$ = [
3,
n03,
_UDNR,
0,
[_DN, _Na2, _FIAK],
[0, () => NameserverList, [() => FIAuthKey, 0]],
2
];
var UpdateDomainNameserversResponse$ = [
3,
n03,
_UDNRp,
0,
[_OI],
[0]
];
var DnssecKeyList = [
1,
n03,
_DKL,
0,
() => DnssecKey$
];
var DomainPriceList = [
1,
n03,
_DPL,
0,
() => DomainPrice$
];
var DomainStatusList = 64 | 0;
var DomainSummaryList = [
1,
n03,
_DSLo,
0,
() => DomainSummary$
];
var ExtraParamList = [
1,
n03,
_EPL,
0,
[
() => ExtraParam$,
0
]
];
var FilterConditions = [
1,
n03,
_FCi,
0,
() => FilterCondition$
];
var GlueIpList = 64 | 0;
var NameserverList = [
1,
n03,
_NL,
0,
() => Nameserver$
];
var OperationStatusList = 64 | 0;
var OperationTypeList = 64 | 0;
var TagKeyList2 = 64 | 0;
var Values = 64 | 0;
var CheckDomainAvailability$ = [
9,
n03,
_CDA,
0,
() => CheckDomainAvailabilityRequest$,
() => CheckDomainAvailabilityResponse$
];
var GetDomainDetail$ = [
9,
n03,
_GDD,
0,
() => GetDomainDetailRequest$,
() => GetDomainDetailResponse$
];
var GetOperationDetail$ = [
9,
n03,
_GOD,
0,
() => GetOperationDetailRequest$,
() => GetOperationDetailResponse$
];
var ListDomains$ = [
9,
n03,
_LD,
0,
() => ListDomainsRequest$,
() => ListDomainsResponse$
];
var ListPrices$ = [
9,
n03,
_LP,
0,
() => ListPricesRequest$,
() => ListPricesResponse$
];
var RegisterDomain$ = [
9,
n03,
_RD2,
0,
() => RegisterDomainRequest$,
() => RegisterDomainResponse$
];
var UpdateDomainNameservers$ = [
9,
n03,
_UDN,
0,
() => UpdateDomainNameserversRequest$,
() => UpdateDomainNameserversResponse$
];
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/runtimeConfig.shared.js
var getRuntimeConfig4 = (config) => {
return {
apiVersion: "2014-05-15",
base64Decoder: config?.base64Decoder ?? import_serde5.fromBase64,
base64Encoder: config?.base64Encoder ?? import_serde5.toBase64,
disableHostPrefix: config?.disableHostPrefix ?? false,
endpointProvider: config?.endpointProvider ?? defaultEndpointResolver3,
extensions: config?.extensions ?? [],
httpAuthSchemeProvider: config?.httpAuthSchemeProvider ?? defaultRoute53DomainsHttpAuthSchemeProvider,
httpAuthSchemes: config?.httpAuthSchemes ?? [
{
schemeId: "aws.auth#sigv4",
identityProvider: (ipc) => ipc.getIdentityProvider("aws.auth#sigv4"),
signer: new import_httpAuthSchemes5.AwsSdkSigV4Signer
}
],
logger: config?.logger ?? new import_client30.NoOpLogger,
protocol: config?.protocol ?? import_protocols8.AwsJson1_1Protocol,
protocolSettings: config?.protocolSettings ?? {
defaultNamespace: "com.amazonaws.route53domains",
errorTypeRegistries: errorTypeRegistries3,
xmlNamespace: "https://route53domains.amazonaws.com/doc/2014-05-15/",
version: "2014-05-15",
serviceTarget: "Route53Domains_v20140515"
},
serviceId: config?.serviceId ?? "Route 53 Domains",
sha256: config?.sha256 ?? import_checksum2.Sha256,
urlParser: config?.urlParser ?? import_protocols9.parseUrl,
utf8Decoder: config?.utf8Decoder ?? import_serde5.fromUtf8,
utf8Encoder: config?.utf8Encoder ?? import_serde5.toUtf8
};
};
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/runtimeConfig.js
var getRuntimeConfig5 = (config) => {
import_client32.emitWarningIfUnsupportedVersion(process.version);
const defaultsMode = import_config30.resolveDefaultsModeConfig(config);
const defaultConfigProvider = () => defaultsMode().then(import_client32.loadConfigsForDefaultMode);
const clientSharedValues = getRuntimeConfig4(config);
import_client31.emitWarningIfUnsupportedVersion(process.version);
const loaderConfig = {
profile: config?.profile,
logger: clientSharedValues.logger
};
return {
...clientSharedValues,
...config,
runtime: "node",
defaultsMode,
authSchemePreference: config?.authSchemePreference ?? import_config30.loadConfig(import_httpAuthSchemes6.NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, loaderConfig),
bodyLengthChecker: config?.bodyLengthChecker ?? import_serde6.calculateBodyLength,
credentialDefaultProvider: config?.credentialDefaultProvider ?? defaultProvider,
defaultUserAgentProvider: config?.defaultUserAgentProvider ?? import_client31.createDefaultUserAgentProvider({ serviceId: clientSharedValues.serviceId, clientVersion: package_default2.version }),
maxAttempts: config?.maxAttempts ?? import_config30.loadConfig(import_retry5.NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
region: config?.region ?? import_config30.loadConfig(import_config30.NODE_REGION_CONFIG_OPTIONS, { ...import_config30.NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
requestHandler: import_node_http_handler3.NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
retryMode: config?.retryMode ?? import_config30.loadConfig({
...import_retry5.NODE_RETRY_MODE_CONFIG_OPTIONS,
default: async () => (await defaultConfigProvider()).retryMode || import_retry5.DEFAULT_RETRY_MODE
}, config),
streamCollector: config?.streamCollector ?? import_node_http_handler3.streamCollector,
useDualstackEndpoint: config?.useDualstackEndpoint ?? import_config30.loadConfig(import_config30.NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
useFipsEndpoint: config?.useFipsEndpoint ?? import_config30.loadConfig(import_config30.NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
userAgentAppId: config?.userAgentAppId ?? import_config30.loadConfig(import_client31.NODE_APP_ID_CONFIG_OPTIONS, loaderConfig)
};
};
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/runtimeExtensions.js
var import_client33 = __toESM(require_client2());
var import_client34 = __toESM(require_client());
var import_protocols10 = __toESM(require_protocols());
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/auth/httpAuthExtensionConfiguration.js
var getHttpAuthExtensionConfiguration3 = (runtimeConfig) => {
const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
let _credentials = runtimeConfig.credentials;
return {
setHttpAuthScheme(httpAuthScheme) {
const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
if (index === -1) {
_httpAuthSchemes.push(httpAuthScheme);
} else {
_httpAuthSchemes.splice(index, 1, httpAuthScheme);
}
},
httpAuthSchemes() {
return _httpAuthSchemes;
},
setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
_httpAuthSchemeProvider = httpAuthSchemeProvider;
},
httpAuthSchemeProvider() {
return _httpAuthSchemeProvider;
},
setCredentials(credentials) {
_credentials = credentials;
},
credentials() {
return _credentials;
}
};
};
var resolveHttpAuthRuntimeConfig3 = (config) => {
return {
httpAuthSchemes: config.httpAuthSchemes(),
httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
credentials: config.credentials()
};
};
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/runtimeExtensions.js
var resolveRuntimeExtensions3 = (runtimeConfig, extensions) => {
const extensionConfiguration = Object.assign(import_client33.getAwsRegionExtensionConfiguration(runtimeConfig), import_client34.getDefaultExtensionConfiguration(runtimeConfig), import_protocols10.getHttpHandlerExtensionConfiguration(runtimeConfig), getHttpAuthExtensionConfiguration3(runtimeConfig));
extensions.forEach((extension) => extension.configure(extensionConfiguration));
return Object.assign(runtimeConfig, import_client33.resolveAwsRegionExtensionConfiguration(extensionConfiguration), import_client34.resolveDefaultRuntimeConfig(extensionConfiguration), import_protocols10.resolveHttpHandlerRuntimeConfig(extensionConfiguration), resolveHttpAuthRuntimeConfig3(extensionConfiguration));
};
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/Route53DomainsClient.js
class Route53DomainsClient extends import_client36.Client {
config;
constructor(...[configuration]) {
const _config_0 = getRuntimeConfig5(configuration || {});
super(_config_0);
this.initConfig = _config_0;
const _config_1 = resolveClientEndpointParameters3(_config_0);
const _config_2 = import_client35.resolveUserAgentConfig(_config_1);
const _config_3 = import_retry6.resolveRetryConfig(_config_2);
const _config_4 = import_config31.resolveRegionConfig(_config_3);
const _config_5 = import_client35.resolveHostHeaderConfig(_config_4);
const _config_6 = import_endpoints7.resolveEndpointConfig(_config_5);
const _config_7 = resolveHttpAuthSchemeConfig3(_config_6);
const _config_8 = resolveRuntimeExtensions3(_config_7, configuration?.extensions || []);
this.config = _config_8;
this.middlewareStack.use(import_schema4.getSchemaSerdePlugin(this.config));
this.middlewareStack.use(import_client35.getUserAgentPlugin(this.config));
this.middlewareStack.use(import_retry6.getRetryPlugin(this.config));
this.middlewareStack.use(import_protocols11.getContentLengthPlugin(this.config));
this.middlewareStack.use(import_client35.getHostHeaderPlugin(this.config));
this.middlewareStack.use(import_client35.getLoggerPlugin(this.config));
this.middlewareStack.use(import_client35.getRecursionDetectionPlugin(this.config));
this.middlewareStack.use(import_core2.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
httpAuthSchemeParametersProvider: defaultRoute53DomainsHttpAuthSchemeParametersProvider,
identityProviderConfigProvider: async (config) => new import_core2.DefaultIdentityProviderConfig({
"aws.auth#sigv4": config.credentials
})
}));
this.middlewareStack.use(import_core2.getHttpSigningPlugin(this.config));
}
destroy() {
super.destroy();
}
}
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/commandBuilder.js
var import_client37 = __toESM(require_client());
var import_endpoints8 = __toESM(require_endpoints());
var command3 = import_client37.makeBuilder(commonParams3, "Route53Domains_v20140515", "Route53DomainsClient", import_endpoints8.getEndpointPlugin);
var _ep03 = {};
var _mw03 = (Command, cs, config, o) => [];
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/commands/CheckDomainAvailabilityCommand.js
class CheckDomainAvailabilityCommand extends command3(_ep03, _mw03, "CheckDomainAvailability", CheckDomainAvailability$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/commands/GetDomainDetailCommand.js
class GetDomainDetailCommand extends command3(_ep03, _mw03, "GetDomainDetail", GetDomainDetail$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/commands/GetOperationDetailCommand.js
class GetOperationDetailCommand extends command3(_ep03, _mw03, "GetOperationDetail", GetOperationDetail$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/commands/ListDomainsCommand.js
class ListDomainsCommand extends command3(_ep03, _mw03, "ListDomains", ListDomains$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/commands/ListPricesCommand.js
class ListPricesCommand extends command3(_ep03, _mw03, "ListPrices", ListPrices$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/commands/RegisterDomainCommand.js
class RegisterDomainCommand extends command3(_ep03, _mw03, "RegisterDomain", RegisterDomain$) {
}
// ../../node_modules/.bun/@aws-sdk+client-route-53-domains@3.1127.0/node_modules/@aws-sdk/client-route-53-domains/dist-es/commands/UpdateDomainNameserversCommand.js
class UpdateDomainNameserversCommand extends command3(_ep03, _mw03, "UpdateDomainNameservers", UpdateDomainNameservers$) {
}
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.972.53/node_modules/@aws-sdk/credential-provider-ini/dist-es/fromIni.js
var import_config35 = __toESM(require_config());
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.972.53/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveProfileData.js
var import_config34 = __toESM(require_config());
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.972.53/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveAssumeRoleCredentials.js
var import_client39 = __toESM(require_client2());
var import_config33 = __toESM(require_config());
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.972.53/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveCredentialSource.js
var import_client38 = __toESM(require_client2());
var import_config32 = __toESM(require_config());
var resolveCredentialSource2 = (credentialSource, profileName, logger) => {
const sourceProvidersMap = {
EcsContainer: async (options) => {
await Promise.resolve().then(() => init_dist_es3());
await Promise.resolve().then(() => init_dist_es2());
logger?.debug("@aws-sdk/credential-provider-ini - credential_source is EcsContainer");
return async () => import_config32.chain(fromHttp(options ?? {}), fromContainerMetadata(options))().then(setNamedProvider2);
},
Ec2InstanceMetadata: async (options) => {
logger?.debug("@aws-sdk/credential-provider-ini - credential_source is Ec2InstanceMetadata");
await Promise.resolve().then(() => init_dist_es2());
return async () => fromInstanceMetadata(options)().then(setNamedProvider2);
},
Environment: async (options) => {
logger?.debug("@aws-sdk/credential-provider-ini - credential_source is Environment");
await Promise.resolve().then(() => init_dist_es());
return async () => fromEnv(options)().then(setNamedProvider2);
}
};
if (credentialSource in sourceProvidersMap) {
return sourceProvidersMap[credentialSource];
} else {
throw new import_config32.CredentialsProviderError(`Unsupported credential source in profile ${profileName}. Got ${credentialSource}, expected EcsContainer or Ec2InstanceMetadata or Environment.`, { logger });
}
};
var setNamedProvider2 = (creds) => import_client38.setCredentialFeature(creds, "CREDENTIALS_PROFILE_NAMED_PROVIDER", "p");
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.972.53/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveAssumeRoleCredentials.js
var isAssumeRoleProfile2 = (arg, { profile = "default", logger } = {}) => {
return Boolean(arg) && typeof arg === "object" && typeof arg.role_arn === "string" && ["undefined", "string"].indexOf(typeof arg.role_session_name) > -1 && ["undefined", "string"].indexOf(typeof arg.external_id) > -1 && ["undefined", "string"].indexOf(typeof arg.mfa_serial) > -1 && (isAssumeRoleWithSourceProfile2(arg, { profile, logger }) || isCredentialSourceProfile2(arg, { profile, logger }));
};
var isAssumeRoleWithSourceProfile2 = (arg, { profile, logger }) => {
const withSourceProfile = typeof arg.source_profile === "string" && typeof arg.credential_source === "undefined";
if (withSourceProfile) {
logger?.debug?.(` ${profile} isAssumeRoleWithSourceProfile source_profile=${arg.source_profile}`);
}
return withSourceProfile;
};
var isCredentialSourceProfile2 = (arg, { profile, logger }) => {
const withProviderProfile = typeof arg.credential_source === "string" && typeof arg.source_profile === "undefined";
if (withProviderProfile) {
logger?.debug?.(` ${profile} isCredentialSourceProfile credential_source=${arg.credential_source}`);
}
return withProviderProfile;
};
var resolveAssumeRoleCredentials2 = async (profileName, profiles, options, callerClientConfig, visitedProfiles = {}, resolveProfileData) => {
options.logger?.debug("@aws-sdk/credential-provider-ini - resolveAssumeRoleCredentials (STS)");
const profileData = profiles[profileName];
const { source_profile, region } = profileData;
if (!options.roleAssumer) {
const { getDefaultRoleAssumer } = await Promise.resolve().then(() => __toESM(require_sts()));
options.roleAssumer = getDefaultRoleAssumer({
...options.clientConfig,
credentialProviderLogger: options.logger,
parentClientConfig: {
...callerClientConfig,
...options?.parentClientConfig,
region: region ?? options?.parentClientConfig?.region ?? callerClientConfig?.region
}
}, options.clientPlugins);
}
if (source_profile && source_profile in visitedProfiles) {
throw new import_config33.CredentialsProviderError(`Detected a cycle attempting to resolve credentials for profile ${import_config33.getProfileName(options)}. Profiles visited: ` + Object.keys(visitedProfiles).join(", "), { logger: options.logger });
}
options.logger?.debug(`@aws-sdk/credential-provider-ini - finding credential resolver using ${source_profile ? `source_profile=[${source_profile}]` : `profile=[${profileName}]`}`);
const sourceCredsProvider = source_profile ? resolveProfileData(source_profile, profiles, options, callerClientConfig, {
...visitedProfiles,
[source_profile]: true
}, isCredentialSourceWithoutRoleArn2(profiles[source_profile] ?? {})) : (await resolveCredentialSource2(profileData.credential_source, profileName, options.logger)(options))();
if (isCredentialSourceWithoutRoleArn2(profileData)) {
return sourceCredsProvider.then((creds) => import_client39.setCredentialFeature(creds, "CREDENTIALS_PROFILE_SOURCE_PROFILE", "o"));
} else {
const params = {
RoleArn: profileData.role_arn,
RoleSessionName: profileData.role_session_name || `aws-sdk-js-${Date.now()}`,
ExternalId: profileData.external_id,
DurationSeconds: parseInt(profileData.duration_seconds || "3600", 10)
};
const { mfa_serial } = profileData;
if (mfa_serial) {
if (!options.mfaCodeProvider) {
throw new import_config33.CredentialsProviderError(`Profile ${profileName} requires multi-factor authentication, but no MFA code callback was provided.`, { logger: options.logger, tryNextLink: false });
}
params.SerialNumber = mfa_serial;
params.TokenCode = await options.mfaCodeProvider(mfa_serial);
}
const sourceCreds = await sourceCredsProvider;
return options.roleAssumer(sourceCreds, params).then((creds) => import_client39.setCredentialFeature(creds, "CREDENTIALS_PROFILE_SOURCE_PROFILE", "o"));
}
};
var isCredentialSourceWithoutRoleArn2 = (section) => {
return !section.role_arn && !!section.credential_source;
};
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.972.53/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveLoginCredentials.js
init_dist_es6();
var import_client40 = __toESM(require_client2());
var isLoginProfile2 = (data) => {
return Boolean(data && data.login_session);
};
var resolveLoginCredentials2 = async (profileName, options, callerClientConfig) => {
const credentials = await fromLoginCredentials({
...options,
profile: profileName
})({ callerClientConfig });
return import_client40.setCredentialFeature(credentials, "CREDENTIALS_PROFILE_LOGIN", "AC");
};
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.972.53/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveProcessCredentials.js
var import_client41 = __toESM(require_client2());
var isProcessProfile2 = (arg) => Boolean(arg) && typeof arg === "object" && typeof arg.credential_process === "string";
var resolveProcessCredentials3 = async (options, profile) => Promise.resolve().then(() => (init_dist_es7(), {})).then(({}) => fromProcess({
...options,
profile
})().then((creds) => import_client41.setCredentialFeature(creds, "CREDENTIALS_PROFILE_PROCESS", "v")));
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.972.53/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveSsoCredentials.js
var import_client42 = __toESM(require_client2());
var resolveSsoCredentials2 = async (profile, profileData, options = {}, callerClientConfig) => {
await Promise.resolve().then(() => init_dist_es5());
return fromSSO({
profile,
logger: options.logger,
parentClientConfig: options.parentClientConfig,
clientConfig: options.clientConfig
})({
callerClientConfig
}).then((creds) => {
if (profileData.sso_session) {
return import_client42.setCredentialFeature(creds, "CREDENTIALS_PROFILE_SSO", "r");
} else {
return import_client42.setCredentialFeature(creds, "CREDENTIALS_PROFILE_SSO_LEGACY", "t");
}
});
};
var isSsoProfile4 = (arg) => arg && (typeof arg.sso_start_url === "string" || typeof arg.sso_account_id === "string" || typeof arg.sso_session === "string" || typeof arg.sso_region === "string" || typeof arg.sso_role_name === "string");
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.972.53/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveStaticCredentials.js
var import_client43 = __toESM(require_client2());
var isStaticCredsProfile2 = (arg) => Boolean(arg) && typeof arg === "object" && typeof arg.aws_access_key_id === "string" && typeof arg.aws_secret_access_key === "string" && ["undefined", "string"].indexOf(typeof arg.aws_session_token) > -1 && ["undefined", "string"].indexOf(typeof arg.aws_account_id) > -1;
var resolveStaticCredentials2 = async (profile, options) => {
options?.logger?.debug("@aws-sdk/credential-provider-ini - resolveStaticCredentials");
const credentials = {
accessKeyId: profile.aws_access_key_id,
secretAccessKey: profile.aws_secret_access_key,
sessionToken: profile.aws_session_token,
...profile.aws_credential_scope && { credentialScope: profile.aws_credential_scope },
...profile.aws_account_id && { accountId: profile.aws_account_id }
};
return import_client43.setCredentialFeature(credentials, "CREDENTIALS_PROFILE", "n");
};
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.972.53/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveWebIdentityCredentials.js
var import_client44 = __toESM(require_client2());
var isWebIdentityProfile2 = (arg) => Boolean(arg) && typeof arg === "object" && typeof arg.web_identity_token_file === "string" && typeof arg.role_arn === "string" && ["undefined", "string"].indexOf(typeof arg.role_session_name) > -1;
var resolveWebIdentityCredentials2 = async (profile, options, callerClientConfig) => Promise.resolve().then(() => (init_dist_es8(), {})).then(({}) => fromTokenFile({
webIdentityTokenFile: profile.web_identity_token_file,
roleArn: profile.role_arn,
roleSessionName: profile.role_session_name,
roleAssumerWithWebIdentity: options.roleAssumerWithWebIdentity,
logger: options.logger,
parentClientConfig: options.parentClientConfig
})({
callerClientConfig
}).then((creds) => import_client44.setCredentialFeature(creds, "CREDENTIALS_PROFILE_STS_WEB_ID_TOKEN", "q")));
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.972.53/node_modules/@aws-sdk/credential-provider-ini/dist-es/resolveProfileData.js
var resolveProfileData2 = async (profileName, profiles, options, callerClientConfig, visitedProfiles = {}, isAssumeRoleRecursiveCall = false) => {
const data = profiles[profileName];
if (Object.keys(visitedProfiles).length > 0 && isStaticCredsProfile2(data)) {
return resolveStaticCredentials2(data, options);
}
if (isAssumeRoleRecursiveCall || isAssumeRoleProfile2(data, { profile: profileName, logger: options.logger })) {
return resolveAssumeRoleCredentials2(profileName, profiles, options, callerClientConfig, visitedProfiles, resolveProfileData2);
}
if (isStaticCredsProfile2(data)) {
return resolveStaticCredentials2(data, options);
}
if (isWebIdentityProfile2(data)) {
return resolveWebIdentityCredentials2(data, options, callerClientConfig);
}
if (isProcessProfile2(data)) {
return resolveProcessCredentials3(options, profileName);
}
if (isSsoProfile4(data)) {
return await resolveSsoCredentials2(profileName, data, options, callerClientConfig);
}
if (isLoginProfile2(data)) {
return resolveLoginCredentials2(profileName, options, callerClientConfig);
}
throw new import_config34.CredentialsProviderError(`Could not resolve credentials using profile: [${profileName}] in configuration/credentials file(s).`, { logger: options.logger });
};
// ../../node_modules/.bun/@aws-sdk+credential-provider-ini@3.972.53/node_modules/@aws-sdk/credential-provider-ini/dist-es/fromIni.js
var fromIni2 = (init = {}) => async ({ callerClientConfig } = {}) => {
init.logger?.debug("@aws-sdk/credential-provider-ini - fromIni");
const profiles = await import_config35.parseKnownFiles(init);
return resolveProfileData2(import_config35.getProfileName({
profile: init.profile ?? callerClientConfig?.profile
}), profiles, init, callerClientConfig);
};
// src/lib/route53.ts
function getConfig2() {
return {
region: process.env["ROUTE53_REGION"] || process.env["ROUTE53_AWS_REGION"] || process.env["AWS_REGION"] || "us-east-1",
accessKeyId: process.env["ROUTE53_ACCESS_KEY_ID"] || process.env["AWS_ACCESS_KEY_ID"],
secretAccessKey: process.env["ROUTE53_SECRET_ACCESS_KEY"] || process.env["AWS_SECRET_ACCESS_KEY"],
sessionToken: process.env["ROUTE53_SESSION_TOKEN"] || process.env["AWS_SESSION_TOKEN"],
profile: process.env["ROUTE53_AWS_PROFILE"] || process.env["AWS_PROFILE"]
};
}
function makeClients(config) {
const cfg = config ?? getConfig2();
const region = cfg.region || "us-east-1";
const credentials = cfg.credentials ?? (cfg.accessKeyId && cfg.secretAccessKey ? { accessKeyId: cfg.accessKeyId, secretAccessKey: cfg.secretAccessKey, sessionToken: cfg.sessionToken } : cfg.profile ? fromIni2({ profile: cfg.profile }) : undefined);
return {
route53: new Route53Client({ region, credentials }),
domains: new Route53DomainsClient({ region: "us-east-1", credentials })
};
}
async function checkAvailability3(domain, config) {
const { domains } = makeClients(config);
const result = await domains.send(new CheckDomainAvailabilityCommand({ DomainName: domain }));
const availability = {
domain,
available: result.Availability === "AVAILABLE",
availability: result.Availability ?? "UNKNOWN"
};
if (availability.available) {
try {
const tld = domain.split(".").slice(1).join(".");
const price = await getTldPrice(tld, config);
if (price) {
availability.currency = price.currency;
availability.price = price.registration_price;
availability.renewal_price = price.renewal_price;
availability.transfer_price = price.transfer_price;
}
} catch {}
}
return availability;
}
function normalizeTld(tld) {
return tld.trim().replace(/^\./, "");
}
function priceString(value) {
return value == null ? undefined : value.toString();
}
function tldPriceFromRoute53Price(tld, price) {
return {
tld: price.Name || tld,
registration_price: priceString(price.RegistrationPrice?.Price),
renewal_price: priceString(price.RenewalPrice?.Price),
transfer_price: priceString(price.TransferPrice?.Price),
currency: price.RegistrationPrice?.Currency ?? price.RenewalPrice?.Currency ?? price.TransferPrice?.Currency
};
}
async function getTldPrice(tld, config) {
const { domains } = makeClients(config);
const normalized = normalizeTld(tld);
const prices = await domains.send(new ListPricesCommand({ Tld: normalized, MaxItems: 1 }));
const price = prices.Prices?.[0];
return price ? tldPriceFromRoute53Price(normalized, price) : null;
}
async function registerDomain2(domain, contact, durationYears = 1, autoRenew = true, config, options = {}) {
const { domains } = makeClients(config);
const contactDetail = contactToRoute53Contact(contact);
const result = await domains.send(new RegisterDomainCommand({
DomainName: domain,
DurationInYears: durationYears,
AutoRenew: autoRenew,
AdminContact: contactDetail,
RegistrantContact: contactDetail,
TechContact: contactDetail,
PrivacyProtectAdminContact: options.privacy_protected ?? true,
PrivacyProtectRegistrantContact: options.privacy_protected ?? true,
PrivacyProtectTechContact: options.privacy_protected ?? true,
...options.nameservers?.length ? { Nameservers: options.nameservers.map((Name) => ({ Name })) } : {}
}));
return { operationId: result.OperationId ?? "" };
}
function contactToRoute53Contact(contact) {
return {
FirstName: contact.first_name,
LastName: contact.last_name,
Email: contact.email,
PhoneNumber: contact.phone,
AddressLine1: contact.address_line_1,
...contact.address_line_2 ? { AddressLine2: contact.address_line_2 } : {},
City: contact.city,
...contact.state ? { State: contact.state } : {},
CountryCode: contact.country_code.toUpperCase(),
ZipCode: contact.zip_code,
ContactType: contact.organization_name ? "COMPANY" : "PERSON",
...contact.organization_name ? { OrganizationName: contact.organization_name } : {}
};
}
async function getRegistrationStatus(operationId, config) {
const { domains } = makeClients(config);
const result = await domains.send(new GetOperationDetailCommand({ OperationId: operationId }));
return {
status: result.Status ?? "UNKNOWN",
domain: result.DomainName,
message: result.Message
};
}
async function getDomainDetail(domain, config) {
const { domains } = makeClients(config);
const [result, summary] = await Promise.all([
domains.send(new GetDomainDetailCommand({ DomainName: domain })),
getDomainSummary(domain, config)
]);
const privacy = result;
return {
domain: result.DomainName ?? domain,
expiry: result.ExpirationDate?.toISOString() ?? summary?.expiry ?? "",
auto_renew: result.AutoRenew ?? summary?.auto_renew ?? null,
transfer_lock: summary?.transfer_lock ?? (result.StatusList?.includes("TRANSFER_LOCK") ? true : null),
created: result.CreationDate?.toISOString() ?? "",
updated: result.UpdatedDate?.toISOString() ?? "",
nameservers: (result.Nameservers ?? []).map((ns) => ns.Name ?? "").filter(Boolean),
status_list: result.StatusList ?? [],
registrar_name: result.RegistrarName,
privacy_protected: privacy.RegistrantPrivacy ?? privacy.AdminPrivacy ?? privacy.TechPrivacy ?? null
};
}
async function getDomainSummary(domain, config) {
let marker;
do {
const { domains } = makeClients(config);
const result = await domains.send(new ListDomainsCommand({ Marker: marker, MaxItems: 100 }));
const summary = (result.Domains ?? []).find((item) => item.DomainName === domain);
if (summary) {
return {
domain: summary.DomainName ?? domain,
expiry: summary.Expiry?.toISOString() ?? "",
auto_renew: summary.AutoRenew ?? false,
transfer_lock: summary.TransferLock ?? false
};
}
marker = result.NextPageMarker;
} while (marker);
return null;
}
async function updateNameservers2(domain, nameservers, config, client) {
if (!nameservers.length) {
throw new Error("updateNameservers requires at least one nameserver");
}
const domains = client ?? makeClients(config).domains;
const result = await domains.send(new UpdateDomainNameserversCommand({
DomainName: domain,
Nameservers: nameservers.map((name) => ({ Name: name }))
}));
return { operationId: result.OperationId ?? "" };
}
async function listRegisteredDomains(config) {
const { domains } = makeClients(config);
const all = [];
let nextPageMarker;
do {
const result = await domains.send(new ListDomainsCommand({ Marker: nextPageMarker }));
for (const d of result.Domains ?? []) {
all.push({
domain: d.DomainName ?? "",
expiry: d.Expiry?.toISOString() ?? "",
auto_renew: d.AutoRenew ?? false,
transfer_lock: d.TransferLock ?? false
});
}
nextPageMarker = result.NextPageMarker;
} while (nextPageMarker);
return all;
}
function cleanZoneId(id) {
return id.replace("/hostedzone/", "");
}
function normalizeZoneId(id) {
return cleanZoneId(id.trim());
}
function cleanChangeId(id) {
return id?.replace("/change/", "") || null;
}
async function createHostedZone(domain, comment, config, options) {
const { route53 } = makeClients(config);
const callerRef = options?.callerReference ?? `domains-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
const result = await route53.send(new CreateHostedZoneCommand({
Name: domain,
CallerReference: callerRef,
HostedZoneConfig: comment ? { Comment: comment } : undefined
}));
return {
id: cleanZoneId(result.HostedZone?.Id ?? ""),
name: result.HostedZone?.Name ?? domain,
record_count: result.HostedZone?.ResourceRecordSetCount ?? 0,
comment,
name_servers: result.DelegationSet?.NameServers ?? []
};
}
async function listHostedZones(config) {
const { route53 } = makeClients(config);
const zones = [];
let marker;
do {
const result = await route53.send(new ListHostedZonesCommand({ Marker: marker }));
for (const z of result.HostedZones ?? []) {
zones.push({
id: cleanZoneId(z.Id ?? ""),
name: z.Name ?? "",
record_count: z.ResourceRecordSetCount ?? 0,
comment: z.Config?.Comment,
private_zone: z.Config?.PrivateZone
});
}
marker = result.IsTruncated ? result.NextMarker : undefined;
} while (marker);
return zones;
}
async function getHostedZone(hostedZoneId, config) {
const { route53 } = makeClients(config);
const result = await route53.send(new GetHostedZoneCommand({ Id: normalizeZoneId(hostedZoneId) }));
return {
id: cleanZoneId(result.HostedZone?.Id ?? ""),
name: result.HostedZone?.Name ?? "",
record_count: result.HostedZone?.ResourceRecordSetCount ?? 0,
comment: result.HostedZone?.Config?.Comment,
name_servers: result.DelegationSet?.NameServers ?? [],
private_zone: result.HostedZone?.Config?.PrivateZone
};
}
async function deleteHostedZone(hostedZoneId, config) {
const { route53 } = makeClients(config);
const zoneId = normalizeZoneId(hostedZoneId);
const managedRecords = [];
let nextName;
let nextType;
let nextIdentifier;
do {
const result = await route53.send(new ListResourceRecordSetsCommand({
HostedZoneId: zoneId,
StartRecordName: nextName,
StartRecordType: nextType,
StartRecordIdentifier: nextIdentifier
}));
managedRecords.push(...result.ResourceRecordSets?.filter((record) => record.Type !== "NS" && record.Type !== "SOA") ?? []);
nextName = result.IsTruncated ? result.NextRecordName : undefined;
nextType = result.IsTruncated ? result.NextRecordType : undefined;
nextIdentifier = result.IsTruncated ? result.NextRecordIdentifier : undefined;
} while (nextName && nextType);
for (let index = 0;index < managedRecords.length; index += 100) {
const batch = managedRecords.slice(index, index + 100);
if (batch.length === 0)
continue;
await route53.send(new ChangeResourceRecordSetsCommand({
HostedZoneId: zoneId,
ChangeBatch: {
Changes: batch.map((record) => ({
Action: "DELETE",
ResourceRecordSet: record
}))
}
}));
}
await route53.send(new DeleteHostedZoneCommand({ Id: zoneId }));
}
async function findHostedZoneByDomain(domain, config) {
const zones = await listHostedZones(config);
const normalized = domain.endsWith(".") ? domain : `${domain}.`;
const matches = zones.filter((z) => z.name === normalized);
if (matches.length === 0)
return null;
const publicMatches = matches.filter((z) => !z.private_zone);
const candidates = publicMatches.length > 0 ? publicMatches : matches;
if (candidates.length > 1) {
throw new Error(`Multiple Route 53 hosted zones found for ${domain}; specify hosted zone id`);
}
return candidates[0] ?? null;
}
function rrsToRecord(rrs) {
if (rrs.AliasTarget) {
return {
name: rrs.Name ?? "",
type: rrs.Type ?? "",
ttl: 0,
values: [],
alias_target: {
hosted_zone_id: rrs.AliasTarget.HostedZoneId ?? "",
dns_name: rrs.AliasTarget.DNSName ?? ""
}
};
}
return {
name: rrs.Name ?? "",
type: rrs.Type ?? "",
ttl: rrs.TTL ?? 0,
values: (rrs.ResourceRecords ?? []).map((r) => r.Value ?? "")
};
}
function recordToRrs(record) {
if (record.alias_target) {
return {
Name: record.name,
Type: record.type,
AliasTarget: {
HostedZoneId: record.alias_target.hosted_zone_id,
DNSName: record.alias_target.dns_name,
EvaluateTargetHealth: false
}
};
}
return {
Name: record.name,
Type: record.type,
TTL: record.ttl ?? 300,
ResourceRecords: record.values.map((v) => ({ Value: v }))
};
}
async function listRecords(hostedZoneId, config, options = {}) {
const { route53 } = makeClients(config);
const records = [];
let nextName;
let nextType;
do {
const result = await route53.send(new ListResourceRecordSetsCommand({
HostedZoneId: normalizeZoneId(hostedZoneId),
StartRecordName: nextName,
StartRecordType: nextType
}));
for (const rrs of result.ResourceRecordSets ?? []) {
if (options.requireSimpleRouting && (rrs.SetIdentifier !== undefined || rrs.Weight !== undefined || rrs.Region !== undefined || rrs.GeoLocation !== undefined || rrs.Failover !== undefined || rrs.HealthCheckId !== undefined || rrs.TrafficPolicyInstanceId !== undefined || rrs.CidrRoutingConfig !== undefined || rrs.GeoProximityLocation !== undefined || rrs.MultiValueAnswer !== undefined && rrs.MultiValueAnswer !== false)) {
throw new Error("Route 53 routing policy or health check cannot be preserved automatically");
}
records.push(rrsToRecord(rrs));
}
if (result.IsTruncated) {
nextName = result.NextRecordName;
nextType = result.NextRecordType;
} else {
nextName = undefined;
nextType = undefined;
}
} while (nextName);
return records;
}
async function upsertRecord(hostedZoneId, record, config, options) {
const { route53 } = makeClients(config);
const result = await route53.send(new ChangeResourceRecordSetsCommand({
HostedZoneId: normalizeZoneId(hostedZoneId),
ChangeBatch: {
...options?.comment ? { Comment: options.comment } : {},
Changes: [{ Action: "UPSERT", ResourceRecordSet: recordToRrs(record) }]
}
}));
return { changeId: cleanChangeId(result.ChangeInfo?.Id) };
}
async function deleteRecord(hostedZoneId, record, config, options) {
const { route53 } = makeClients(config);
const result = await route53.send(new ChangeResourceRecordSetsCommand({
HostedZoneId: normalizeZoneId(hostedZoneId),
ChangeBatch: {
...options?.comment ? { Comment: options.comment } : {},
Changes: [{ Action: "DELETE", ResourceRecordSet: recordToRrs(record) }]
}
}));
return { changeId: cleanChangeId(result.ChangeInfo?.Id) };
}
async function upsertRecords(hostedZoneId, records, config, options) {
if (records.length === 0)
return { changeId: null };
const { route53 } = makeClients(config);
const changes = records.map((r) => ({
Action: "UPSERT",
ResourceRecordSet: recordToRrs(r)
}));
const result = await route53.send(new ChangeResourceRecordSetsCommand({
HostedZoneId: normalizeZoneId(hostedZoneId),
ChangeBatch: {
...options?.comment ? { Comment: options.comment } : {},
Changes: changes
}
}));
return { changeId: cleanChangeId(result.ChangeInfo?.Id) };
}
function parseMxValue(raw) {
const match = /^([0-9]+)[ \t]+([^\s]+)$/u.exec(raw.trim());
const priority = match ? Number(match[1]) : NaN;
if (!match || !Number.isInteger(priority) || priority < 0 || priority > 65535) {
throw new Error("Route 53 contains an invalid MX preference or exchange");
}
return { priority, value: match[2] };
}
function createRoute53Provider(config) {
const cfg = config ?? getConfig2();
const registerWithRoute53 = registerDomain2;
const updateRoute53Nameservers = updateNameservers2;
async function listDomainInventory() {
const byDomain = new Map;
try {
const registered = await listRegisteredDomains(cfg);
for (const d of registered) {
byDomain.set(d.domain, {
domain: d.domain,
registrar: "AWS Route 53",
created: "",
expires: d.expiry,
nameservers: [],
status: "active",
auto_renew: d.auto_renew
});
}
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
if (!message.includes("route53domains:ListDomains") && !message.includes("AccessDenied")) {
throw error;
}
}
const zones = await listHostedZones(cfg);
for (const z of zones) {
const zone = z.name_servers?.length ? z : await getHostedZone(z.id, cfg).catch(() => z);
const domain = zone.name.replace(/\.$/, "");
const nameservers = zone.name_servers ?? [];
const existing = byDomain.get(domain);
if (existing) {
existing.nameservers = nameservers.length > 0 ? nameservers : existing.nameservers;
continue;
}
byDomain.set(domain, {
domain,
registrar: "AWS Route 53 DNS",
created: "",
expires: "",
nameservers,
status: "active",
auto_renew: false
});
}
return Array.from(byDomain.values());
}
return {
name: "route53",
dnsWriteScope: "changed-groups",
async listDomains() {
return listDomainInventory();
},
async getDomainInfo(domain) {
const detail = await getDomainDetail(domain, cfg);
return {
domain: detail.domain,
registrar: "AWS Route 53",
created: detail.created,
expires: detail.expiry,
nameservers: detail.nameservers,
status: "active",
auto_renew: detail.auto_renew ?? false
};
},
async registerDomain(domain, contact, options = {}) {
const result = await registerWithRoute53(domain, contact, options.years ?? 1, options.autoRenew ?? true, cfg);
return { domain, success: !!result.operationId, operationId: result.operationId };
},
async updateNameservers(domain, nameservers) {
const result = await updateRoute53Nameservers(domain, nameservers, cfg);
return { domain, success: !!result.operationId, operationId: result.operationId };
},
async renewDomain(_domain) {
return { domain: _domain, success: false, orderId: undefined, chargedAmount: undefined };
},
async getDnsRecords(domain) {
const zone = await findHostedZoneByDomain(domain, cfg);
if (!zone)
return [];
const records = await listRecords(zone.id, cfg, { requireSimpleRouting: true });
const result = [];
for (const r of records) {
if (r.alias_target) {
result.push({ type: r.type, name: r.name, value: r.alias_target.dns_name, ttl: 0 });
} else {
for (const v of r.values) {
const mx = r.type === "MX" ? parseMxValue(v) : undefined;
result.push({
type: r.type,
name: r.name,
value: mx?.value ?? v,
ttl: r.ttl,
...mx === undefined ? {} : { priority: mx.priority }
});
}
}
}
return result;
},
async setDnsRecords(domain, records) {
const zone = await findHostedZoneByDomain(domain, cfg);
if (!zone)
throw new Error(`No hosted zone found for ${domain}`);
const grouped = new Map;
for (const r of records) {
const mx = r.type === "MX" ? parseMxValue(r.priority === undefined ? r.value : `${r.priority} ${r.value}`) : undefined;
const value = mx === undefined ? r.value : `${mx.priority} ${mx.value}`;
const key = `${r.name}|${r.type}`;
const existing = grouped.get(key);
if (existing) {
existing.values.push(value);
} else {
grouped.set(key, { name: r.name, type: r.type, ttl: r.ttl, values: [value] });
}
}
await upsertRecords(zone.id, Array.from(grouped.values()), cfg);
return true;
},
async checkAvailability(domain) {
const result = await checkAvailability3(domain, cfg);
return {
domain: result.domain,
available: result.available,
standard_price: result.price ? Number(result.price) : undefined,
currency: result.currency
};
},
async syncToLocalDb(dbFns) {
const domains = await listDomainInventory();
const syncedAt = new Date().toISOString();
let synced = 0;
let created = 0;
let updated = 0;
const errors = [];
for (const d of domains) {
try {
const existing = await dbFns.getDomainByName(d.domain);
if (existing) {
const existingRoute53 = existing.metadata["route53"];
const staleDnsOnlyRegistrar = d.registrar !== "AWS Route 53" && (existing.registrar === "AWS Route 53 DNS" || existing.registrar === "AWS Route 53" && existingRoute53?.source === "route53:hosted_zones");
await dbFns.updateDomain(existing.id, {
...d.registrar === "AWS Route 53" ? { registrar: "AWS Route 53" } : {},
...staleDnsOnlyRegistrar ? { registrar: null } : {},
...d.registrar === "AWS Route 53" ? { expiry_synced_at: syncedAt } : {},
expires_at: d.expires || undefined,
auto_renew: d.auto_renew,
nameservers: d.nameservers.length > 0 ? d.nameservers : existing.nameservers,
metadata: {
...existing.metadata,
route53: {
source: d.registrar === "AWS Route 53" ? "route53domains+hosted_zones" : "route53:hosted_zones",
synced_at: syncedAt
}
},
status: "active"
});
updated++;
} else {
await dbFns.createDomain({
name: d.domain,
...d.registrar === "AWS Route 53" ? { registrar: "AWS Route 53" } : {},
...d.registrar === "AWS Route 53" ? { expiry_synced_at: syncedAt } : {},
expires_at: d.expires || undefined,
auto_renew: d.auto_renew,
nameservers: d.nameservers,
status: "active",
notes: d.registrar === "AWS Route 53 DNS" ? "Discovered from Route 53 hosted zones; registrar ownership was not inferred." : undefined,
metadata: {
route53: {
source: d.registrar === "AWS Route 53" ? "route53domains+hosted_zones" : "route53:hosted_zones",
synced_at: syncedAt
}
}
});
created++;
}
synced++;
} catch (err) {
errors.push(`${d.domain}: ${err instanceof Error ? err.message : String(err)}`);
}
}
return { synced, created, updated, errors };
}
};
}
// src/lib/env-aliases.ts
function firstEnv(env, names) {
for (const key of names) {
const value = env[key];
if (value)
return { key, value };
}
return;
}
function hasEveryEnv(env, groups) {
return groups.every((names) => !!firstEnv(env, names));
}
function flattenEnvNames(groups) {
return Array.from(new Set(groups.flatMap((names) => [...names])));
}
var NAMECHEAP_ENV = {
apiKey: ["NAMECHEAP_API_KEY"],
username: ["NAMECHEAP_USERNAME"],
clientIp: ["NAMECHEAP_CLIENT_IP"]
};
var GODADDY_ENV = {
apiKey: ["GODADDY_API_KEY"],
apiSecret: ["GODADDY_API_SECRET"]
};
var BRANDSIGHT_ENV = {
apiKey: ["BRANDSIGHT_API_KEY"],
apiSecret: ["BRANDSIGHT_API_SECRET"],
customerId: ["BRANDSIGHT_CUSTOMER_ID"],
shopperId: ["BRANDSIGHT_SHOPPER_ID"],
accountId: ["BRANDSIGHT_ACCOUNT_ID"]
};
var SEDO_ENV = {
partnerId: ["SEDO_PARTNER_ID"],
signKey: ["SEDO_API_KEY", "SEDO_SIGN_KEY"],
username: ["SEDO_USERNAME", "SEDO_EMAIL"],
password: ["SEDO_PASSWORD"]
};
var CLOUDFLARE_ENV = {
apiToken: ["CLOUDFLARE_API_TOKEN"],
apiKey: ["CLOUDFLARE_API_KEY"],
email: ["CLOUDFLARE_EMAIL"],
accountId: ["CLOUDFLARE_ACCOUNT_ID"]
};
var ROUTE53_ENV = {
accessKeyId: ["ROUTE53_ACCESS_KEY_ID", "AWS_ACCESS_KEY_ID"],
secretAccessKey: ["ROUTE53_SECRET_ACCESS_KEY", "AWS_SECRET_ACCESS_KEY"],
sessionToken: ["ROUTE53_SESSION_TOKEN", "AWS_SESSION_TOKEN"],
profile: ["ROUTE53_AWS_PROFILE", "AWS_PROFILE"],
region: ["ROUTE53_REGION", "ROUTE53_AWS_REGION", "AWS_REGION"],
webIdentityTokenFile: ["AWS_WEB_IDENTITY_TOKEN_FILE"],
roleArn: ["AWS_ROLE_ARN"],
containerCredentials: [
"AWS_CONTAINER_CREDENTIALS_RELATIVE_URI",
"AWS_CONTAINER_CREDENTIALS_FULL_URI"
]
};
function providerEnvNames(provider) {
switch (provider.toLowerCase()) {
case "namecheap":
return flattenEnvNames([NAMECHEAP_ENV.apiKey, NAMECHEAP_ENV.username, NAMECHEAP_ENV.clientIp]);
case "godaddy":
return flattenEnvNames([GODADDY_ENV.apiKey, GODADDY_ENV.apiSecret]);
case "brandsight":
return flattenEnvNames([
BRANDSIGHT_ENV.apiKey,
BRANDSIGHT_ENV.apiSecret,
BRANDSIGHT_ENV.customerId,
BRANDSIGHT_ENV.shopperId,
BRANDSIGHT_ENV.accountId
]);
case "sedo":
return flattenEnvNames([SEDO_ENV.partnerId, SEDO_ENV.signKey, SEDO_ENV.username, SEDO_ENV.password]);
case "cloudflare":
return flattenEnvNames([CLOUDFLARE_ENV.apiToken, CLOUDFLARE_ENV.apiKey, CLOUDFLARE_ENV.email, CLOUDFLARE_ENV.accountId]);
case "route53":
return flattenEnvNames([
ROUTE53_ENV.profile,
ROUTE53_ENV.accessKeyId,
ROUTE53_ENV.secretAccessKey,
ROUTE53_ENV.sessionToken,
ROUTE53_ENV.region,
ROUTE53_ENV.webIdentityTokenFile,
ROUTE53_ENV.roleArn,
ROUTE53_ENV.containerCredentials
]);
default:
return [];
}
}
function hasProviderCredentials(provider, env = process.env) {
switch (provider.toLowerCase()) {
case "namecheap":
return hasEveryEnv(env, [NAMECHEAP_ENV.apiKey, NAMECHEAP_ENV.username, NAMECHEAP_ENV.clientIp]);
case "godaddy":
return hasEveryEnv(env, [GODADDY_ENV.apiKey, GODADDY_ENV.apiSecret]);
case "brandsight":
return hasEveryEnv(env, [BRANDSIGHT_ENV.apiKey, BRANDSIGHT_ENV.apiSecret, BRANDSIGHT_ENV.customerId]);
case "sedo":
return hasEveryEnv(env, [SEDO_ENV.partnerId, SEDO_ENV.signKey, SEDO_ENV.username, SEDO_ENV.password]);
case "cloudflare": {
const tokenMode = !!firstEnv(env, CLOUDFLARE_ENV.apiToken);
const keyMode = hasEveryEnv(env, [CLOUDFLARE_ENV.apiKey, CLOUDFLARE_ENV.email]);
return tokenMode || keyMode;
}
case "route53": {
const profileMode = !!firstEnv(env, ROUTE53_ENV.profile);
const keyMode = hasEveryEnv(env, [ROUTE53_ENV.accessKeyId, ROUTE53_ENV.secretAccessKey]);
const webIdentityMode = hasEveryEnv(env, [ROUTE53_ENV.webIdentityTokenFile, ROUTE53_ENV.roleArn]);
const containerMode = !!firstEnv(env, ROUTE53_ENV.containerCredentials);
return profileMode || keyMode || webIdentityMode || containerMode;
}
default:
return false;
}
}
// src/lib/cloudflare-auth.ts
function resolveCloudflareConfig(env = process.env) {
const accountId = firstEnv(env, CLOUDFLARE_ENV.accountId)?.value;
const apiToken = firstEnv(env, CLOUDFLARE_ENV.apiToken)?.value;
if (apiToken)
return { apiToken, accountId };
const apiKey = firstEnv(env, CLOUDFLARE_ENV.apiKey)?.value;
const email = firstEnv(env, CLOUDFLARE_ENV.email)?.value;
if (apiKey && email)
return { apiKey, email, accountId };
return accountId ? { accountId } : {};
}
function cloudflareAuthHeaders(cfg) {
if (cfg.apiToken)
return { Authorization: `Bearer ${cfg.apiToken}` };
if (cfg.apiKey && cfg.email)
return { "X-Auth-Key": cfg.apiKey, "X-Auth-Email": cfg.email };
throw new Error("Cloudflare credentials not configured. Set CLOUDFLARE_API_TOKEN, or CLOUDFLARE_API_KEY + CLOUDFLARE_EMAIL.");
}
// src/lib/cloudflare.ts
class CloudflareApiError extends Error {
statusCode;
providerCode;
constructor(message, statusCode, providerCode) {
const code = providerCode ? `, code ${providerCode}` : "";
super(`Cloudflare API error (HTTP ${statusCode}${code}): ${message}`);
this.statusCode = statusCode;
this.providerCode = providerCode;
this.name = "CloudflareApiError";
}
}
function getConfig3() {
return resolveCloudflareConfig();
}
function checkCredentials(cfg) {
cloudflareAuthHeaders(cfg);
}
var CF_BASE = "https://api.cloudflare.com/client/v4";
var DEFAULT_CF_TIMEOUT_MS = 30000;
var MAX_CF_TIMEOUT_MS = 120000;
var DEFAULT_CF_MAX_RESPONSE_BYTES = 1048576;
var MAX_CF_RESPONSE_BYTES = 4194304;
function positiveBoundedEnv(name, fallback, maximum) {
const raw = process.env[name]?.trim();
if (!raw)
return fallback;
const value = Number(raw);
if (!Number.isSafeInteger(value) || value < 1 || value > maximum) {
throw new Error(`${name} must be an integer between 1 and ${maximum}`);
}
return value;
}
async function boundedResponseText(response, maxBytes, signal) {
const contentLength = Number(response.headers.get("content-length"));
if (Number.isFinite(contentLength) && contentLength > maxBytes) {
throw new Error(`Cloudflare API response exceeds ${maxBytes} bytes`);
}
if (!response.body)
return "";
const reader = response.body.getReader();
const abort = () => void reader.cancel("Cloudflare API request aborted");
if (signal.aborted)
abort();
signal.addEventListener("abort", abort, { once: true });
const chunks = [];
let length = 0;
try {
while (true) {
const { done, value } = await reader.read();
if (done)
break;
length += value.byteLength;
if (length > maxBytes) {
await reader.cancel("Cloudflare API response exceeds bounded size");
throw new Error(`Cloudflare API response exceeds ${maxBytes} bytes`);
}
chunks.push(value);
}
} finally {
signal.removeEventListener("abort", abort);
}
const bytes = new Uint8Array(length);
let offset = 0;
for (const chunk of chunks) {
bytes.set(chunk, offset);
offset += chunk.byteLength;
}
return new TextDecoder().decode(bytes);
}
async function cfFetch(path, opts = {}) {
const cfg = opts.config ?? getConfig3();
checkCredentials(cfg);
const timeoutMs = Math.min(opts.timeoutMs ?? MAX_CF_TIMEOUT_MS, positiveBoundedEnv("DOMAINS_PROVIDER_HTTP_TIMEOUT_MS", DEFAULT_CF_TIMEOUT_MS, MAX_CF_TIMEOUT_MS));
const maxResponseBytes = positiveBoundedEnv("DOMAINS_PROVIDER_MAX_RESPONSE_BYTES", DEFAULT_CF_MAX_RESPONSE_BYTES, MAX_CF_RESPONSE_BYTES);
const controller = new AbortController;
let timer;
const timeout = new Promise((_resolve, reject) => {
timer = setTimeout(() => {
controller.abort();
reject(new Error(`Cloudflare API request exceeded ${timeoutMs}ms`));
}, timeoutMs);
});
let json;
let status = 0;
try {
({ json, status } = await Promise.race([
(async () => {
const response = await fetch(`${CF_BASE}${path}`, {
method: opts.method ?? "GET",
headers: {
...cloudflareAuthHeaders(cfg),
"Content-Type": "application/json"
},
body: opts.body ? JSON.stringify(opts.body) : undefined,
signal: controller.signal
});
const text = await boundedResponseText(response, maxResponseBytes, controller.signal);
try {
return {
status: response.status,
json: JSON.parse(text)
};
} catch {
throw new Error(`Cloudflare API returned invalid JSON (${response.status})`);
}
})(),
timeout
]));
} finally {
if (timer !== undefined)
clearTimeout(timer);
}
if (status < 200 || status >= 300 || json.success !== true) {
const first = json.errors?.[0];
const msg = first?.message ?? "request failed";
const providerCode = typeof first?.code === "string" || typeof first?.code === "number" ? String(first.code) : undefined;
throw new CloudflareApiError(msg, status, providerCode);
}
opts.onResultInfo?.(json.result_info);
return json.result;
}
async function listZones(config) {
const zones = [];
let page = 1;
while (true) {
const result = await cfFetch(`/zones?per_page=50&page=${page}`, { config });
if (!result || result.length === 0)
break;
for (const z of result) {
zones.push({ id: z.id, name: z.name, status: z.status, nameservers: z.name_servers, original_nameservers: z.original_name_servers });
}
if (result.length < 50)
break;
page++;
}
return zones;
}
async function getZone(domain, config) {
const result = await cfFetch(`/zones?name=${encodeURIComponent(domain)}`, { config });
if (!result || result.length === 0)
return null;
const z = result[0];
return { id: z.id, name: z.name, status: z.status, nameservers: z.name_servers, original_nameservers: z.original_name_servers };
}
async function createZone(domain, config) {
const cfg = config ?? getConfig3();
if (!cfg.accountId) {
throw new Error("CLOUDFLARE_ACCOUNT_ID is required to create a zone.");
}
const result = await cfFetch("/zones", { method: "POST", body: { name: domain, account: { id: cfg.accountId }, jump_start: false }, config: cfg });
return { id: result.id, name: result.name, status: result.status, nameservers: result.name_servers };
}
async function ensureZone(domain, config, deps) {
const get = deps?.getZone ?? getZone;
const create = deps?.createZone ?? createZone;
const existing = await get(domain, config);
const zone = existing ?? await create(domain, config);
if (!zone.nameservers || zone.nameservers.length === 0) {
throw new Error(`Cloudflare zone for ${domain} has no nameservers yet`);
}
return zone;
}
class CloudflareDnsPaginationError extends Error {
constructor(reason, page, count, metadata) {
const numeric = metadata ? Object.fromEntries(["page", "per_page", "count", "total_count", "total_pages"].map((key) => [key, typeof metadata[key] === "number" && Number.isFinite(metadata[key]) ? metadata[key] : null])) : null;
super(`Cloudflare DNS pagination ${reason} (page=${page}, returned=${count}, metadata=${JSON.stringify(numeric)})`);
this.name = "CloudflareDnsPaginationError";
}
}
async function listRecords2(zoneId, config, options = {}) {
const deadline = Math.min(performance.now() + 1e4, options.deadline ?? Infinity);
if (!Number.isFinite(deadline))
throw new Error("Invalid DNS enumeration deadline");
const assertRead = async () => {
await options.assertLease?.();
if (performance.now() >= deadline)
throw new Error("Cloudflare DNS enumeration time budget exhausted");
};
for (let attempt = 1;; attempt++) {
await assertRead();
try {
const records = await listRecordsAttempt(zoneId, config, assertRead, deadline);
await assertRead();
return records;
} catch (error) {
if (!(error instanceof CloudflareDnsPaginationError) || attempt >= 6)
throw error;
await assertRead();
const delay = 250 * 2 ** (attempt - 1);
if (performance.now() + delay >= deadline)
throw error;
await new Promise((resolve) => setTimeout(resolve, delay));
}
}
}
var CF_DNS_READ_TYPES = new Set(["A", "AAAA", "CAA", "CERT", "CNAME", "DNSKEY", "DS", "HTTPS", "LOC", "MX", "NAPTR", "NS", "OPENPGPKEY", "PTR", "SMIMEA", "SRV", "SSHFP", "SVCB", "TLSA", "TXT", "URI"]);
function readDnsRecord(value) {
const malformed = () => new Error("Cloudflare returned a malformed DNS record");
if (!value || typeof value !== "object" || Array.isArray(value))
throw malformed();
const r = value;
if (typeof r.id !== "string" || !/^[A-Za-z0-9_-]{1,128}$/u.test(r.id) || typeof r.type !== "string" || !CF_DNS_READ_TYPES.has(r.type) || typeof r.name !== "string" || r.name.length > 253 || !/^(?:\*|[A-Za-z0-9_-]+)(?:\.[A-Za-z0-9_-]+)+\.?$/u.test(r.name) || typeof r.content !== "string" || r.content.length === 0 && r.type !== "TXT" || typeof r.ttl !== "number" || !Number.isSafeInteger(r.ttl) || !(r.ttl === 1 || r.ttl >= 30 && r.ttl <= 86400) || (r.type === "MX" || r.priority !== undefined) && (typeof r.priority !== "number" || !Number.isSafeInteger(r.priority) || r.priority < 0 || r.priority > 65535) || r.proxied !== undefined && typeof r.proxied !== "boolean")
throw malformed();
return {
id: r.id,
type: r.type,
name: r.name,
content: r.content,
ttl: r.ttl,
priority: r.priority,
proxied: r.proxied
};
}
async function listRecordsAttempt(zoneId, config, assertRead, deadline) {
const records = [];
let page = 1;
const seenIds = new Set;
let pagination;
while (true) {
await assertRead();
let resultInfo;
const result = await cfFetch(`/zones/${zoneId}/dns_records?per_page=100&page=${page}`, { config, onResultInfo: (value) => {
resultInfo = value;
}, timeoutMs: Math.max(1, Math.ceil(deadline - performance.now())) });
await assertRead();
if (!Array.isArray(result))
throw new Error("Cloudflare DNS list result is not an array");
const pageRecords = result.map(readDnsRecord);
for (const record of pageRecords) {
if (seenIds.has(record.id))
throw new Error("Cloudflare DNS pagination repeated a record identity");
seenIds.add(record.id);
}
if (resultInfo !== undefined) {
if (!resultInfo || typeof resultInfo !== "object")
throw new Error("Cloudflare DNS pagination is malformed");
const info = resultInfo;
const values = [info.page, info.per_page, info.count, info.total_count, info.total_pages];
if (!values.every((value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0))
throw new CloudflareDnsPaginationError("is incomplete", page, result.length, info);
const current = { perPage: info.per_page, totalCount: info.total_count, totalPages: info.total_pages };
const expectedPages = Math.ceil(current.totalCount / current.perPage);
if (info.page !== page || current.perPage < 1 || current.perPage > 100)
throw new Error("Cloudflare DNS pagination has invalid page identity or size");
if (info.count !== result.length || current.totalPages !== expectedPages && !(current.totalCount === 0 && current.totalPages === 1) || result.length !== Math.min(current.perPage, Math.max(0, current.totalCount - (page - 1) * current.perPage)) || pagination && JSON.stringify(pagination) !== JSON.stringify(current))
throw new CloudflareDnsPaginationError("changed or contradicts the result", page, result.length, info);
pagination = current;
} else if (pagination)
throw new CloudflareDnsPaginationError("disappeared before completion", page, result.length);
records.push(...pageRecords);
if (pagination ? page >= pagination.totalPages : result.length < 100) {
if (pagination && records.length !== pagination.totalCount)
throw new CloudflareDnsPaginationError("did not yield the complete population", page, result.length);
break;
}
page++;
}
return records;
}
async function listRecordsByNameType(zoneId, type, name, config) {
const result = await cfFetch(`/zones/${zoneId}/dns_records?type=${encodeURIComponent(type)}&name=${encodeURIComponent(name)}`, { config });
return (result ?? []).map((r) => ({
id: r.id,
type: r.type,
name: r.name,
content: r.content,
ttl: r.ttl,
priority: r.priority,
proxied: r.proxied
}));
}
function sameRecordIdentity(a, b) {
return a.type === b.type && a.name === b.name && a.content === b.content && (a.priority ?? undefined) === (b.priority ?? undefined);
}
function resolveDesiredProxied(records, existing) {
const omitted = records.filter((record) => record.proxied === undefined);
if (omitted.length === 0)
return records;
const { type, name } = records[0];
if (omitted.length === records.length) {
const proxyStates = new Set(existing.map((record) => record.proxied));
if (proxyStates.size > 1) {
throw new Error(`Cannot safely preserve Cloudflare proxied state for ${type} ${name}: ` + "existing records have mixed proxied values while desired records omit proxied; " + "set proxied explicitly on every desired record");
}
const inherited = existing[0]?.proxied;
return inherited === undefined ? records : records.map((record) => ({ ...record, proxied: inherited }));
}
const existingHasProxyState = existing.some((record) => record.proxied !== undefined);
return records.map((record) => {
if (record.proxied !== undefined)
return record;
const matches = existing.filter((candidate) => sameRecordIdentity(candidate, record));
if (matches.length === 1 && matches[0].proxied !== undefined) {
return { ...record, proxied: matches[0].proxied };
}
if (!existingHasProxyState)
return record;
throw new Error(`Cannot safely preserve Cloudflare proxied state for ${type} ${name} record ${record.content}: ` + "omitted proxied does not resolve to exactly one existing value; " + "set proxied explicitly on this desired record");
});
}
async function prepareRecordsByNameType(zoneId, records, config) {
if (records.length === 0)
return;
const { type, name } = records[0];
const existing = await listRecordsByNameType(zoneId, type, name, config);
if (existing.length === records.length && records.every((record) => existing.some((candidate) => sameRecordIdentity(candidate, record) && candidate.ttl === record.ttl && (record.proxied === undefined || candidate.proxied === record.proxied)))) {
return;
}
return { existing, desired: resolveDesiredProxied(records, existing) };
}
async function replaceRecordsByNameType(zoneId, replacement, config) {
for (const record of replacement.existing) {
if (record.id)
await deleteRecord2(zoneId, record.id, config);
}
for (const record of replacement.desired) {
await cfFetch(`/zones/${zoneId}/dns_records`, {
method: "POST",
body: {
type: record.type,
name: record.name,
content: record.content,
ttl: record.ttl ?? 1,
priority: record.priority,
...record.proxied === undefined ? {} : { proxied: record.proxied }
},
config
});
}
}
async function reconcileRecords(zoneId, records, config) {
const grouped = new Map;
for (const record of records) {
const key = `${record.type}|${record.name}`;
const group = grouped.get(key) ?? [];
group.push(record);
grouped.set(key, group);
}
const replacements = [];
for (const group of grouped.values()) {
const replacement = await prepareRecordsByNameType(zoneId, group, config);
if (replacement)
replacements.push(replacement);
}
for (const replacement of replacements) {
await replaceRecordsByNameType(zoneId, replacement, config);
}
}
async function deleteRecord2(zoneId, recordId, config) {
await cfFetch(`/zones/${zoneId}/dns_records/${recordId}`, { method: "DELETE", config });
}
function zoneToDomainInfo(zone) {
return {
domain: zone.name,
registrar: "Cloudflare DNS",
created: "",
expires: "",
nameservers: zone.nameservers,
status: zone.status === "active" ? "active" : "discovered",
auto_renew: false
};
}
function withCloudflareMetadata(existing, zone) {
return {
...existing,
cloudflare: {
zone_id: zone.id,
zone_status: zone.status,
source: "cloudflare:zones",
synced_at: new Date().toISOString()
}
};
}
function createCloudflareProvider(config) {
const cfg = config ?? getConfig3();
return {
name: "cloudflare",
dnsWriteScope: "changed-groups",
async listDomains() {
const zones = await listZones(cfg);
return zones.map(zoneToDomainInfo);
},
async syncToLocalDb(dbFns) {
const zones = await listZones(cfg);
let synced = 0;
let created = 0;
let updated = 0;
const errors = [];
for (const zone of zones) {
try {
const info = zoneToDomainInfo(zone);
const existing = await dbFns.getDomainByName(zone.name);
if (existing) {
await dbFns.updateDomain(existing.id, {
...existing.registrar === "Cloudflare DNS" ? { registrar: null } : {},
status: existing.status === "discovered" && info.status === "active" ? "active" : existing.status,
nameservers: zone.nameservers,
metadata: withCloudflareMetadata(existing.metadata, zone)
});
updated++;
} else {
await dbFns.createDomain({
name: zone.name,
status: info.status === "active" ? "active" : "discovered",
auto_renew: false,
nameservers: zone.nameservers,
notes: "Discovered from Cloudflare zones; registrar ownership was not inferred.",
metadata: withCloudflareMetadata({}, zone)
});
created++;
}
synced++;
} catch (err) {
errors.push(`${zone.name}: ${err instanceof Error ? err.message : String(err)}`);
}
}
return { synced, created, updated, errors };
},
async getDnsRecords(domain) {
const zone = await getZone(domain, cfg);
if (!zone)
return [];
const records = await listRecords2(zone.id, cfg);
return records.map((r) => ({
type: r.type,
name: r.name,
value: r.content,
ttl: r.ttl === 1 ? 0 : r.ttl,
priority: r.priority,
...r.proxied === undefined ? {} : { proxied: r.proxied }
}));
},
async setDnsRecords(domain, records) {
const zone = await getZone(domain, cfg);
if (!zone)
throw new Error(`No Cloudflare zone found for ${domain}`);
await reconcileRecords(zone.id, records.map((r) => ({
type: r.type,
name: r.name,
content: r.value,
ttl: r.ttl || 1,
priority: r.priority,
...r.proxied === undefined ? {} : { proxied: r.proxied }
})), cfg);
return true;
},
async deleteDnsRecords(domain, records) {
const zone = await getZone(domain, cfg);
if (!zone)
throw new Error(`No Cloudflare zone found for ${domain}`);
const grouped = new Map;
for (const record of records) {
const key = `${record.type}|${record.name}`;
const group = grouped.get(key) ?? [];
group.push(record);
grouped.set(key, group);
}
for (const group of grouped.values()) {
const { type, name } = group[0];
const existing = await listRecordsByNameType(zone.id, type, name, cfg);
for (const record of group) {
const match = existing.find((candidate) => candidate.content === record.value && (candidate.priority ?? undefined) === (record.priority ?? undefined));
if (match?.id) {
await deleteRecord2(zone.id, match.id, cfg);
}
}
}
return true;
}
};
}
// src/lib/brandsight.ts
function resolveBrandsightConfig(env = process.env) {
const apiKey = firstEnv(env, BRANDSIGHT_ENV.apiKey)?.value ?? "";
const apiSecret = firstEnv(env, BRANDSIGHT_ENV.apiSecret)?.value;
const customerId = firstEnv(env, BRANDSIGHT_ENV.customerId)?.value;
const shopperId = firstEnv(env, BRANDSIGHT_ENV.shopperId)?.value;
const accountId = firstEnv(env, BRANDSIGHT_ENV.accountId)?.value;
return {
apiKey,
apiSecret,
customerId,
shopperId,
accountId,
baseUrl: env["BRANDSIGHT_BASE_URL"]
};
}
class BrandsightApiError extends Error {
statusCode;
responseBody;
constructor(message, statusCode, responseBody) {
super(message);
this.statusCode = statusCode;
this.responseBody = responseBody;
this.name = "BrandsightApiError";
}
}
var _fetchFn = null;
function getApiKey() {
const key = resolveBrandsightConfig().apiKey;
if (!key) {
throw new BrandsightApiError("Brandsight API key is not set. Set BRANDSIGHT_API_KEY.");
}
return key;
}
function getConfig4() {
return resolveBrandsightConfig();
}
var BRANDSIGHT_BASE = "https://api.brandsight.com/v1";
var BRANDSIGHT_DOMAIN_BASE = "https://api.godaddy.com/v2";
var BRANDSIGHT_DOMAIN_MAX_RESPONSE_BYTES = 1048576;
function brandsightDomainTimeoutMs() {
const raw = process.env["DOMAINS_PROVIDER_HTTP_TIMEOUT_MS"]?.trim();
if (!raw)
return 30000;
const timeout = Number(raw);
if (!Number.isSafeInteger(timeout) || timeout < 1 || timeout > 120000) {
throw new BrandsightApiError("DOMAINS_PROVIDER_HTTP_TIMEOUT_MS must be an integer between 1 and 120000");
}
return timeout;
}
async function boundedDomainResponseText(response, signal) {
const declaredLength = response.headers.get("content-length");
if (declaredLength !== null) {
const parsed = Number(declaredLength);
if (Number.isFinite(parsed) && parsed > BRANDSIGHT_DOMAIN_MAX_RESPONSE_BYTES) {
throw new BrandsightApiError(`Brandsight Domain API response exceeds ${BRANDSIGHT_DOMAIN_MAX_RESPONSE_BYTES} bytes`, response.status);
}
}
if (!response.body)
return "";
const reader = response.body.getReader();
const abort = () => void reader.cancel("Brandsight Domain API request aborted");
if (signal.aborted)
abort();
signal.addEventListener("abort", abort, { once: true });
const chunks = [];
let total = 0;
try {
while (true) {
if (signal.aborted)
throw signal.reason;
const { done, value } = await reader.read();
if (done)
break;
if (!value)
continue;
total += value.byteLength;
if (total > BRANDSIGHT_DOMAIN_MAX_RESPONSE_BYTES) {
await reader.cancel();
throw new BrandsightApiError(`Brandsight Domain API response exceeds ${BRANDSIGHT_DOMAIN_MAX_RESPONSE_BYTES} bytes`, response.status);
}
chunks.push(value);
}
} finally {
signal.removeEventListener("abort", abort);
reader.releaseLock();
}
if (signal.aborted)
throw signal.reason;
const joined = new Uint8Array(total);
let offset = 0;
for (const chunk of chunks) {
joined.set(chunk, offset);
offset += chunk.byteLength;
}
return new TextDecoder().decode(joined);
}
function allowDemoStubs() {
return process.env["BRANDSIGHT_DEMO_STUBS"] === "1" || process.env["BRANDSIGHT_ALLOW_STUBS"] === "1";
}
async function apiGet(path, apiKey, baseUrl = BRANDSIGHT_BASE) {
const fetchFn = _fetchFn || globalThis.fetch;
const url = `${baseUrl}${path}`;
const headers = {
Authorization: `Bearer ${apiKey}`,
"Content-Type": "application/json",
Accept: "application/json",
"User-Agent": USER_AGENT
};
try {
const response = await fetchFn(url, {
method: "GET",
headers,
signal: AbortSignal.timeout(15000)
});
if (!response.ok) {
throw new BrandsightApiError(`Brandsight API GET ${path} failed with status ${response.status}`, response.status, await response.text());
}
const data = await response.json();
return { data, stub: false };
} catch (error) {
if (error instanceof BrandsightApiError)
throw error;
if (!allowDemoStubs()) {
throw new BrandsightApiError(`Brandsight API GET ${path} failed: ${error instanceof Error ? error.message : String(error)}`);
}
return { data: null, stub: true };
}
}
function requireDomainConfig(config) {
const cfg = config ?? getConfig4();
if (!cfg.apiKey || !cfg.apiSecret || !cfg.customerId) {
throw new BrandsightApiError("Brandsight Domain API credentials are not configured. Set BRANDSIGHT_API_KEY, BRANDSIGHT_API_SECRET, and BRANDSIGHT_CUSTOMER_ID.");
}
return cfg;
}
function domainBaseUrl(cfg) {
return cfg.baseUrl ?? BRANDSIGHT_DOMAIN_BASE;
}
function domainHeaders(cfg) {
return {
Authorization: `sso-key ${cfg.apiKey}:${cfg.apiSecret}`,
"Content-Type": "application/json",
Accept: "application/json",
"User-Agent": USER_AGENT
};
}
async function domainApiRequest(method, path, config, body) {
const cfg = requireDomainConfig(config);
const fetchFn = _fetchFn || globalThis.fetch;
const signal = AbortSignal.timeout(brandsightDomainTimeoutMs());
const response = await fetchFn(`${domainBaseUrl(cfg)}${path}`, {
method,
headers: domainHeaders(cfg),
body: body ? JSON.stringify(body) : undefined,
signal
});
const text = await boundedDomainResponseText(response, signal);
if (!response.ok) {
throw new BrandsightApiError(`Brandsight Domain API ${method} ${path} failed with status ${response.status}`, response.status, text);
}
if (!text.trim())
return {};
return JSON.parse(text);
}
function normalizeBrandsightDomain(raw) {
const nameServers = raw.nameServers ?? raw.nameservers ?? [];
const expiresAt = raw.expiresAt ?? raw.expires ?? "";
const createdAt = raw.createdAt ?? raw.created ?? "";
const renewAuto = raw.renewAuto ?? raw.auto_renew ?? false;
return {
...raw,
domain: String(raw.domain ?? ""),
status: String(raw.status ?? "UNKNOWN"),
created: createdAt,
expires: expiresAt,
auto_renew: renewAuto,
locked: Boolean(raw.locked),
nameservers: nameServers,
createdAt,
expiresAt,
nameServers,
renewAuto
};
}
function customerPath(cfg, path) {
return `/customers/${encodeURIComponent(cfg.customerId)}${path}`;
}
function domainTld(domain) {
const parts = domain.split(".").filter(Boolean);
if (parts.length < 2)
throw new BrandsightApiError(`Invalid domain name: ${domain}`);
return parts.slice(1).join(".");
}
function brandsightContact(contact) {
return {
addressMailing: {
address1: contact.address_line_1,
city: contact.city,
country: contact.country_code,
postalCode: contact.zip_code,
state: contact.state
},
email: contact.email,
encoding: "ASCII",
nameFirst: contact.first_name,
nameLast: contact.last_name,
organization: contact.organization_name,
phone: contact.phone
};
}
async function domainAvailability(domain, cfg, type, period = 1) {
const params = new URLSearchParams({
domain,
period: String(period),
type,
optimizeFor: "ACCURACY"
});
const result = await domainApiRequest("GET", `/domains/available?${params.toString()}`, cfg);
return {
domain: result.domain ?? domain,
available: Boolean(result.available),
price: result.price,
currency: result.currency,
registryPremiumPricing: result.registryPremiumPricing
};
}
function generateStubAlerts(brandName) {
const now = new Date().toISOString();
return [
{ domain: `${brandName}-deals.com`, type: "keyword", registered_at: now },
{ domain: `${brandName.replace(/a/gi, "4").replace(/e/gi, "3")}.com`, type: "homoglyph", registered_at: now },
{ domain: `${brandName}s.com`, type: "typosquat", registered_at: now }
];
}
function generateStubSimilarDomains(domain) {
const base = domain.replace(/\.[^.]+$/, "");
const tld = domain.slice(base.length);
return [
`${base}-online${tld}`,
`${base}s${tld}`,
`${base.replace(/a/gi, "4")}${tld}`,
`${base}-app${tld}`,
`get${base}${tld}`
];
}
function generateStubThreatAssessment(domain) {
return {
domain,
risk_level: "low",
threats: [],
recommendation: "No immediate threats detected. Continue routine monitoring."
};
}
async function monitorBrand(brandName) {
const apiKey = getApiKey();
const result = await apiGet(`/brands/${encodeURIComponent(brandName)}/monitor`, apiKey);
if (result.stub) {
return { brand: brandName, alerts: generateStubAlerts(brandName), stub: true };
}
return { brand: brandName, alerts: result.data.alerts, stub: false };
}
async function getSimilarDomains(domain) {
const apiKey = getApiKey();
const result = await apiGet(`/domains/${encodeURIComponent(domain)}/similar`, apiKey);
if (result.stub) {
return { domain, similar: generateStubSimilarDomains(domain), stub: true };
}
return { domain, similar: result.data.similar, stub: false };
}
async function getThreatAssessment(domain) {
const apiKey = getApiKey();
const result = await apiGet(`/domains/${encodeURIComponent(domain)}/threats`, apiKey);
if (result.stub) {
return { ...generateStubThreatAssessment(domain), stub: true };
}
return { ...result.data, stub: false };
}
async function listDomains2(config) {
const cfg = requireDomainConfig(config);
const domains = [];
const seenDomains = new Set;
const seenMarkers = new Set;
let marker;
while (true) {
const params = new URLSearchParams({ limit: "500" });
if (marker)
params.set("marker", marker);
const batch = await domainApiRequest("GET", customerPath(cfg, `/domains?${params.toString()}`), cfg);
if (!Array.isArray(batch) || batch.length === 0)
break;
for (const normalized of batch.map(normalizeBrandsightDomain)) {
if (!normalized.domain || seenDomains.has(normalized.domain))
continue;
seenDomains.add(normalized.domain);
domains.push(normalized);
}
if (batch.length < 500)
break;
const nextMarker = String(batch[batch.length - 1]?.domain ?? "");
if (!nextMarker || seenMarkers.has(nextMarker))
break;
seenMarkers.add(nextMarker);
marker = nextMarker;
}
return domains;
}
async function getDomainInfo3(domain, config) {
const cfg = requireDomainConfig(config);
const result = await domainApiRequest("GET", customerPath(cfg, `/domains/${encodeURIComponent(domain)}`), cfg);
return normalizeBrandsightDomain(result);
}
async function checkAvailability4(domain, config) {
const cfg = requireDomainConfig(config);
return domainAvailability(domain, cfg, "REGISTRATION", 1);
}
async function renewDomain3(domain, years = 1, config) {
const cfg = requireDomainConfig(config);
const current = await getDomainInfo3(domain, cfg);
if (!current?.expires)
throw new BrandsightApiError(`Cannot renew ${domain}: current expiry is unavailable`);
const quote = await domainAvailability(domain, cfg, "RENEWAL", years);
const price = quote.price ?? current.renewal?.price;
const currency = quote.currency ?? current.renewal?.currency;
if (price == null || !currency) {
throw new BrandsightApiError(`Cannot renew ${domain}: renewal quote did not include an exact price and currency`);
}
const result = await domainApiRequest("POST", customerPath(cfg, `/domains/${encodeURIComponent(domain)}/renew`), cfg, {
consent: {
agreedAt: new Date().toISOString(),
agreedBy: cfg.shopperId ?? "domains-cli",
currency,
price,
registryPremiumPricing: quote.registryPremiumPricing ?? false
},
expires: current.expires,
period: years
});
return { success: true, orderId: result.orderId ?? result.id };
}
async function getLegalAgreements(tld, privacy = false, config) {
const cfg = requireDomainConfig(config);
const params = new URLSearchParams({
privacy: String(privacy),
tlds: tld
});
return domainApiRequest("GET", customerPath(cfg, `/domains/agreements?${params.toString()}`), cfg);
}
async function getRegistrationSchema(tld, config) {
const cfg = requireDomainConfig(config);
return domainApiRequest("GET", customerPath(cfg, `/domains/register/schema/${encodeURIComponent(tld)}`), cfg);
}
async function validateRegistrationRequest(payload, config) {
const cfg = requireDomainConfig(config);
await domainApiRequest("POST", customerPath(cfg, "/domains/register/validate"), cfg, payload);
return true;
}
async function registerBrandsightDomain(domain, contact, options = {}, config) {
const cfg = requireDomainConfig(config);
const period = options.years ?? 1;
const availability = await domainAvailability(domain, cfg, "REGISTRATION", period);
if (!availability.available)
throw new BrandsightApiError(`${domain} is not available for registration`);
const price = options.premiumPrice ?? availability.price;
if (price == null || !availability.currency) {
throw new BrandsightApiError(`Cannot register ${domain}: availability quote did not include an exact price and currency`);
}
const tld = domainTld(domain);
const schema = await getRegistrationSchema(tld, cfg);
const required = Array.isArray(schema["required"]) ? schema["required"] : [];
if (required.includes("metadata") && !options.metadata) {
throw new BrandsightApiError(`Cannot register ${domain}: ${tld} requires TLD-specific metadata; pass registration metadata before validation`);
}
const privacy = options.privacy ?? false;
const agreements = await getLegalAgreements(tld, privacy, cfg);
const agreementKeys = agreements.map((a) => a.agreementKey).filter(Boolean);
const c = brandsightContact(contact);
const payload = {
consent: {
agreedAt: new Date().toISOString(),
agreedBy: contact.email || cfg.shopperId || "domains-cli",
agreementKeys,
currency: availability.currency,
price,
registryPremiumPricing: availability.registryPremiumPricing ?? !!options.premiumPrice
},
contacts: {
admin: c,
billing: c,
registrant: c,
tech: c
},
domain,
metadata: options.metadata ?? {},
nameServers: options.nameservers ?? [],
period,
privacy,
renewAuto: options.autoRenew ?? true
};
await validateRegistrationRequest(payload, cfg);
const result = await domainApiRequest("POST", customerPath(cfg, "/domains/register"), cfg, payload);
return {
success: true,
orderId: result.orderId ?? result.id,
operationId: result.operationId ?? result.id,
chargedAmount: String(price)
};
}
async function updateNameservers3(domain, nameservers, config) {
const cfg = requireDomainConfig(config);
const result = await domainApiRequest("PUT", customerPath(cfg, `/domains/${encodeURIComponent(domain)}/nameServers`), cfg, { nameServers: nameservers });
return { success: true, operationId: result.operationId ?? result.id };
}
async function getDnsRecords3(domain, config) {
const cfg = requireDomainConfig(config);
const records = [];
let offset = 0;
const limit = 1000;
while (true) {
const batch = await domainApiRequest("GET", customerPath(cfg, `/domains/${encodeURIComponent(domain)}/records?offset=${offset}&limit=${limit}`), cfg);
if (!Array.isArray(batch) || batch.length === 0)
break;
if (records.length + batch.length > 5000) {
throw new BrandsightApiError("Brandsight DNS record inventory exceeds the 5000-record safety bound");
}
records.push(...batch);
if (batch.length < limit)
break;
offset += limit;
}
return records;
}
function normalizeBrandsightDnsRecord(record) {
return {
...record,
ttl: Math.max(record.ttl || 600, 600)
};
}
async function setDnsRecords3(domain, records, config) {
const cfg = requireDomainConfig(config);
await domainApiRequest("PUT", customerPath(cfg, `/domains/${encodeURIComponent(domain)}/records`), cfg, records.map(normalizeBrandsightDnsRecord));
return true;
}
async function syncToLocalDb3(dbFns, config) {
const domains = await listDomains2(config);
let synced = 0, created = 0, updated = 0;
const errors = [];
const syncedAt = new Date().toISOString();
for (const d of domains) {
try {
const existing = await dbFns.getDomainByName(d.domain);
if (existing) {
await dbFns.updateDomain(existing.id, {
registrar: "Brandsight",
expires_at: d.expires || undefined,
auto_renew: d.auto_renew,
status: "active",
nameservers: d.nameservers,
expiry_synced_at: syncedAt
});
updated++;
} else {
await dbFns.createDomain({
name: d.domain,
registrar: "Brandsight",
expires_at: d.expires || undefined,
auto_renew: d.auto_renew,
status: "active",
nameservers: d.nameservers,
expiry_synced_at: syncedAt
});
created++;
}
synced++;
} catch (err) {
errors.push(`${d.domain}: ${err instanceof Error ? err.message : String(err)}`);
}
}
return { synced, created, updated, errors };
}
function createBrandsightProvider(config) {
const cfg = config ?? getConfig4();
return {
name: "brandsight",
async listDomains() {
const domains = await listDomains2(cfg);
return domains.map((d) => ({
domain: d.domain,
registrar: "Brandsight",
created: d.created ?? "",
expires: d.expires,
nameservers: d.nameservers,
status: d.status === "ACTIVE" ? "active" : d.status.toLowerCase(),
auto_renew: d.auto_renew
}));
},
async getDomainInfo(domain) {
const d = await getDomainInfo3(domain, cfg);
if (!d)
throw new Error(`Domain not found in Brandsight: ${domain}`);
return {
domain: d.domain,
registrar: "Brandsight",
created: d.created ?? "",
expires: d.expires,
nameservers: d.nameservers,
status: d.status === "ACTIVE" ? "active" : d.status.toLowerCase(),
auto_renew: d.auto_renew
};
},
async renewDomain(domain, years = 1) {
const result = await renewDomain3(domain, years, cfg);
return { domain, success: result.success, orderId: result.orderId };
},
async registerDomain(domain, contact, options) {
const result = await registerBrandsightDomain(domain, contact, options, cfg);
return {
domain,
success: result.success,
orderId: result.orderId,
operationId: result.operationId,
chargedAmount: result.chargedAmount
};
},
async updateNameservers(domain, nameservers) {
const result = await updateNameservers3(domain, nameservers, cfg);
return { domain, success: result.success, operationId: result.operationId };
},
async getDnsRecords(domain) {
const records = await getDnsRecords3(domain, cfg);
return records.map((r) => ({
type: r.type,
name: r.name,
value: r.data,
ttl: r.ttl,
priority: r.priority
}));
},
async setDnsRecords(domain, records) {
return setDnsRecords3(domain, records.map((r) => ({
type: r.type,
name: r.name,
data: r.value,
ttl: r.ttl,
priority: r.priority
})), cfg);
},
async checkAvailability(domain) {
const result = await checkAvailability4(domain, cfg);
return {
domain: result.domain,
available: result.available,
is_premium: result.registryPremiumPricing,
premium_price: result.registryPremiumPricing ? result.price : undefined,
standard_price: result.registryPremiumPricing ? undefined : result.price,
currency: result.currency
};
},
async syncToLocalDb(dbFns) {
return syncToLocalDb3(dbFns, cfg);
}
};
}
// src/lib/registrar.ts
function createNamecheapProvider() {
return {
name: "namecheap",
async listDomains() {
const config = getConfig();
const domains = await listNamecheapDomains(config);
return domains.map((d) => ({
domain: d.domain,
registrar: "Namecheap",
created: "",
expires: d.expiry,
nameservers: [],
status: "active",
auto_renew: d.autoRenew
}));
},
async getDomainInfo(domain) {
const config = getConfig();
const info = await getDomainInfo(domain, config);
return {
domain: info.domain,
registrar: info.registrar,
created: info.created,
expires: info.expires,
nameservers: info.nameservers,
status: "active",
auto_renew: true
};
},
async registerDomain(domain, contact, options = {}) {
const config = getConfig();
const result = await registerDomain(domain, contact, {
years: options.years,
premiumPrice: options.premiumPrice
}, config);
return {
domain: result.domain,
success: result.success,
orderId: result.orderId,
chargedAmount: result.chargedAmount
};
},
async updateNameservers(domain, nameservers) {
const config = getConfig();
const success = await updateNameservers(domain, nameservers, config);
return { domain, success };
},
async renewDomain(domain, years = 1) {
const config = getConfig();
const result = await renewDomain(domain, years, config);
return {
domain: result.domain,
success: result.success,
orderId: result.orderId,
chargedAmount: result.chargedAmount
};
},
async getDnsRecords(domain) {
const config = getConfig();
const { sld, tld } = splitDomain(domain);
const records = await getDnsRecords(domain, sld, tld, config);
return records.map((r) => ({
type: r.type,
name: r.name,
value: r.address,
ttl: r.ttl,
priority: r.mxPref
}));
},
async setDnsRecords(domain, records) {
const config = getConfig();
const { sld, tld } = splitDomain(domain);
const ncRecords = records.map((r) => ({
type: r.type,
name: r.name,
address: r.value,
ttl: r.ttl,
mxPref: r.priority
}));
return setDnsRecords(domain, sld, tld, ncRecords, config);
},
async checkAvailability(domain) {
const config = getConfig();
const result = await checkAvailability(domain, config);
return {
domain: result.domain,
available: result.available,
is_premium: result.premium,
premium_price: result.price
};
},
async syncToLocalDb(dbFns) {
const result = await syncToLocalDb(dbFns);
return {
synced: result.synced,
created: 0,
updated: 0,
errors: result.errors
};
}
};
}
function createGoDaddyProvider() {
return {
name: "godaddy",
async listDomains() {
const domains = await listGoDaddyDomains();
return domains.map((d) => ({
domain: d.domain,
registrar: "GoDaddy",
created: "",
expires: d.expires,
nameservers: d.nameServers || [],
status: d.status.toLowerCase(),
auto_renew: d.renewAuto
}));
},
async getDomainInfo(domain) {
const detail = await getDomainInfo2(domain);
return {
domain: detail.domain,
registrar: "GoDaddy",
created: detail.createdAt || "",
expires: detail.expires,
nameservers: detail.nameServers || [],
status: detail.status.toLowerCase(),
auto_renew: detail.renewAuto
};
},
async renewDomain(domain) {
const result = await renewDomain2(domain);
return {
domain,
success: true,
orderId: String(result.orderId),
chargedAmount: String(result.total)
};
},
async getDnsRecords(domain) {
const records = await getDnsRecords2(domain);
return records.map((r) => ({
type: r.type,
name: r.name,
value: r.data,
ttl: r.ttl,
priority: r.priority
}));
},
async setDnsRecords(domain, records) {
const gdRecords = records.map((r) => ({
type: r.type,
name: r.name,
data: r.value,
ttl: r.ttl,
priority: r.priority
}));
await setDnsRecords2(domain, gdRecords);
return true;
},
async checkAvailability(domain) {
const result = await checkAvailability2(domain);
return {
domain: result.domain,
available: result.available,
standard_price: result.price,
currency: result.currency
};
},
async syncToLocalDb(dbFns) {
const result = await syncToLocalDb2(dbFns);
return {
synced: result.synced,
created: result.created,
updated: result.updated,
errors: result.errors
};
}
};
}
var providerRegistry = new Map([
["namecheap", {
info: {
name: "namecheap",
type: "full",
configured: false,
envVars: providerEnvNames("namecheap")
},
createInventory: createNamecheapProvider,
createRegistrar: createNamecheapProvider,
createDns: createNamecheapProvider
}],
["godaddy", {
info: {
name: "godaddy",
type: "full",
configured: false,
envVars: providerEnvNames("godaddy")
},
createInventory: createGoDaddyProvider,
createRegistrar: createGoDaddyProvider,
createDns: createGoDaddyProvider
}],
["route53", {
info: {
name: "route53",
type: "full",
configured: false,
envVars: providerEnvNames("route53")
},
createInventory: () => createRoute53Provider(),
createRegistrar: () => createRoute53Provider(),
createDns: () => createRoute53Provider()
}],
["cloudflare", {
info: {
name: "cloudflare",
type: "dns",
configured: false,
envVars: providerEnvNames("cloudflare")
},
createInventory: () => createCloudflareProvider(),
createDns: createCloudflareProvider
}],
["brandsight", {
info: {
name: "brandsight",
type: "full",
configured: false,
envVars: providerEnvNames("brandsight")
},
createInventory: createBrandsightProvider,
createRegistrar: createBrandsightProvider,
createDns: createBrandsightProvider
}],
["sedo", {
info: {
name: "sedo",
type: "marketplace",
configured: false,
envVars: providerEnvNames("sedo")
}
}]
]);
function isConfigured(providerName) {
return hasProviderCredentials(providerName);
}
function getAvailableProviders() {
return Array.from(providerRegistry.values()).map((e) => ({
...e.info,
configured: isConfigured(e.info.name),
inventory: !!e.createInventory
}));
}
function providerHasInventory(name) {
return !!providerRegistry.get(name.toLowerCase())?.createInventory;
}
function getDomainInventoryProvider(name) {
const entry = providerRegistry.get(name.toLowerCase());
if (!entry?.createInventory)
throw new Error(`No domain inventory provider: ${name}`);
return entry.createInventory();
}
function getRegistrarProvider(name) {
const entry = providerRegistry.get(name.toLowerCase());
if (!entry?.createRegistrar)
throw new Error(`No registrar provider: ${name}`);
return entry.createRegistrar();
}
function getDnsProvider(name) {
const entry = providerRegistry.get(name.toLowerCase());
if (!entry?.createDns)
throw new Error(`No DNS provider: ${name}`);
return entry.createDns();
}
async function syncAll(dbFns) {
const available = getAvailableProviders().filter((p) => p.configured && providerHasInventory(p.name));
const result = { providers: [], totalSynced: 0, totalErrors: [] };
for (const info of available) {
try {
const provider = getDomainInventoryProvider(info.name);
const syncResult = await provider.syncToLocalDb(dbFns);
result.providers.push({ name: info.name, result: syncResult });
result.totalSynced += syncResult.synced;
result.totalErrors.push(...syncResult.errors.map((e) => `[${info.name}] ${e}`));
} catch (error) {
const msg = `[${info.name}] Sync failed: ${error instanceof Error ? error.message : String(error)}`;
result.totalErrors.push(msg);
result.providers.push({ name: info.name, result: { synced: 0, created: 0, updated: 0, errors: [msg] } });
}
}
return result;
}
// src/lib/config.ts
import { existsSync, mkdirSync, readFileSync as readFileSync5, writeFileSync } from "fs";
import { dirname as dirname4, join as join5 } from "path";
function getConfigPath(env = process.env) {
if (env["HASNA_DOMAINS_CONFIG_PATH"])
return env["HASNA_DOMAINS_CONFIG_PATH"];
if (env["DOMAINS_CONFIG_PATH"])
return env["DOMAINS_CONFIG_PATH"];
const dir = env["DOMAINS_CONFIG_DIR"];
if (dir)
return join5(dir, "config.json");
return getDefaultConfigPath(env);
}
function loadConfig4(env = process.env) {
const path = getConfigPath(env);
if (!existsSync(path))
return {};
try {
return JSON.parse(readFileSync5(path, "utf-8"));
} catch {
return {};
}
}
function resolveContact(opts) {
const cfg = loadConfig4().contact ?? {};
const get = (opt, cfgKey) => opt || cfg[cfgKey] || "";
const first_name = get(opts.firstName, "first_name");
const last_name = get(opts.lastName, "last_name");
const email = get(opts.email, "email");
const phone = get(opts.phone, "phone");
const address_line_1 = get(opts.address, "address_line_1");
const city = get(opts.city, "city");
const state = get(opts.state, "state");
const country_code = get(opts.country, "country_code");
const zip_code = get(opts.zip, "zip_code");
const organization_name = opts.org || cfg.organization_name;
const missing = ["first_name", "last_name", "email", "phone", "address_line_1", "city", "state", "country_code", "zip_code"].filter((k) => !{ first_name, last_name, email, phone, address_line_1, city, state, country_code, zip_code }[k]);
if (missing.length > 0) {
throw new Error(`Missing registrant contact fields: ${missing.join(", ")}.
` + `Set defaults with: domains config set contact.<field> <value>`);
}
return { first_name, last_name, email, phone, address_line_1, city, state, country_code, zip_code, organization_name };
}
// src/db/domain-owners.ts
function parseWhoisOwner(whoisData) {
let name = null;
let email = null;
let phone = null;
let org = null;
if (whoisData.trim().startsWith("{")) {
try {
const rdap = JSON.parse(whoisData);
const registrant = extractRegistrantFromRdapEntities(rdap);
name = registrant.name;
email = registrant.email;
phone = registrant.phone;
org = registrant.organization;
} catch {}
}
if (!name && !email && !org) {
const nameMatch = whoisData.match(/Registrant Name:\s*(.+)/i);
const emailMatch = whoisData.match(/Registrant Email:\s*(.+)/i);
const phoneMatch = whoisData.match(/Registrant Phone:\s*(.+)/i);
const orgMatch = whoisData.match(/Registrant Organization:\s*(.+)/i);
name = nameMatch?.[1]?.trim() ?? null;
email = emailMatch?.[1]?.trim() ?? null;
phone = phoneMatch?.[1]?.trim() ?? null;
org = orgMatch?.[1]?.trim() ?? null;
}
if (!name && !email && !org)
return null;
return { name, email, phone, organization: org };
}
function extractRegistrantFromRdapEntities(rdap) {
const result = { name: null, email: null, phone: null, organization: null };
const entities = rdap.entities;
if (!entities)
return result;
const findRegistrant = (ents) => {
for (const entity of ents) {
if (entity.roles?.some((r) => r === "registrant"))
return entity;
if (entity.entities) {
const found = findRegistrant(entity.entities);
if (found)
return found;
}
}
return null;
};
const registrant = findRegistrant(entities);
if (!registrant?.vcardArray)
return result;
const vcard = registrant.vcardArray[1];
if (!vcard || !Array.isArray(vcard))
return result;
for (const entry of vcard) {
if (!Array.isArray(entry) || entry.length < 3)
continue;
const [prop, _params, type] = entry;
if (prop === "fn")
result.name = type ?? null;
else if (prop === "email")
result.email = type ?? null;
else if (prop === "tel")
result.phone = type ?? null;
else if (prop === "org") {
result.organization = Array.isArray(type) ? type[0] ?? null : type ?? null;
} else if (prop === "n" && !result.name) {
const parts = Array.isArray(type) ? type.filter(Boolean) : [type];
result.name = parts.reverse().join(" ").trim() || null;
}
}
if (!result.name && registrant.handle) {
result.name = registrant.handle;
}
return result;
}
// src/db/owners.ts
function createDomainOwner(input) {
return getStore().createDomainOwner(input);
}
function getDomainOwner(id) {
return getStore().getDomainOwner(id);
}
function getDomainOwnerByDomain(domainId) {
return getStore().getDomainOwnerByDomain(domainId);
}
function listDomainOwners(options = {}) {
return getStore().listDomainOwners(options);
}
function updateDomainOwner(id, input) {
return getStore().updateDomainOwner(id, input);
}
function deleteDomainOwner(id) {
return getStore().deleteDomainOwner(id);
}
function listDomainsWithOwners() {
return getStore().listDomainsWithOwners();
}
async function extractOwnerFromWhois(domainName, whoisData) {
const store = getStore();
const domain = await store.getDomainByIdentifier(domainName);
if (!domain)
return null;
const parsed = parseWhoisOwner(whoisData);
if (!parsed)
return null;
const existing = await store.getDomainOwnerByDomain(domain.id);
if (existing) {
return store.updateDomainOwner(existing.id, {
owner_name: parsed.name ?? existing.owner_name ?? undefined,
owner_email: parsed.email ?? existing.owner_email ?? undefined,
owner_phone: parsed.phone ?? existing.owner_phone ?? undefined,
owner_organization: parsed.organization ?? existing.owner_organization ?? undefined,
source: "whois"
});
}
return store.createDomainOwner({
domain_id: domain.id,
owner_name: parsed.name ?? undefined,
owner_email: parsed.email ?? undefined,
owner_phone: parsed.phone ?? undefined,
owner_organization: parsed.organization ?? undefined,
source: "whois"
});
}
// src/mcp/tool-filter.ts
var READ_ONLY_TOOLS = new Set([
"get_domain",
"list_domains",
"list_domain_offers",
"get_domain_emails",
"search_domains",
"count_domains",
"list_expiring_domains",
"list_ssl_expiring",
"get_domains_by_registrar",
"get_domain_stats",
"list_dns_records",
"list_alerts",
"whois_lookup",
"check_dns_propagation",
"check_ssl",
"export_zone_file",
"discover_subdomains",
"validate_dns",
"export_portfolio",
"check_all_domains",
"check_availability_namecheap",
"list_providers",
"monitor_brand",
"similar_domains",
"domain_threats",
"r53_check_availability",
"r53_registration_status",
"r53_list_registered_domains",
"r53_get_domain_detail",
"r53_list_hosted_zones",
"r53_get_hosted_zone",
"r53_list_records",
"domain_check",
"dns_list",
"list_domain_owners",
"get_domain_owner"
]);
function isReadOnlyMcpTool(name) {
return READ_ONLY_TOOLS.has(name);
}
function applySafeModeToolFilter(server, env = process.env) {
if (env["DOMAINS_MCP_SAFE_MODE"] !== "1")
return;
const originalRegisterTool = server.registerTool.bind(server);
server.registerTool = (name, ...args) => {
if (!isReadOnlyMcpTool(name)) {
return {
enabled: false,
handler: async () => ({ content: [], isError: true }),
disable() {},
enable() {},
remove() {},
update() {
return this;
}
};
}
return originalRegisterTool(name, ...args);
};
}
// src/lib/compact-output.ts
var DEFAULT_LIST_LIMIT = 20;
var MAX_LIST_LIMIT = 200;
function parseLimit(value, fallback = DEFAULT_LIST_LIMIT, maxLimit = MAX_LIST_LIMIT) {
if (value === undefined || value === null || value === "")
return fallback;
const parsed = typeof value === "number" ? value : Number(value);
if (!Number.isInteger(parsed) || parsed <= 0) {
throw new Error("--limit must be a positive integer");
}
return Math.min(parsed, maxLimit);
}
function parseOffset(value) {
if (value === undefined || value === null || value === "")
return 0;
const parsed = typeof value === "number" ? value : Number(value);
if (!Number.isInteger(parsed) || parsed < 0) {
throw new Error("--offset must be a non-negative integer");
}
return parsed;
}
function pageItems(items, options = {}) {
const offset = parseOffset(options.offset);
const limit = options.all ? Math.max(items.length - offset, 0) : parseLimit(options.limit, options.fallbackLimit, options.maxLimit);
const page = items.slice(offset, offset + limit);
return {
items: page,
total: items.length,
shown: page.length,
limit,
offset,
hasMore: offset + page.length < items.length
};
}
function truncateText(value, max = 96) {
const text = String(value ?? "").replace(/\s+/g, " ").trim();
if (text.length <= max)
return text;
return `${text.slice(0, Math.max(0, max - 1))}\u2026`;
}
function formatDate(value) {
if (!value)
return "-";
return value.split("T")[0]?.split(" ")[0] || value;
}
// src/mcp/index.ts
var listControls = {
limit: numberType().int().positive().max(200).optional().describe("Maximum number of items to return in compact output (default 20, max 200)."),
offset: numberType().int().nonnegative().optional().describe("Number of matching items to skip."),
all: booleanType().optional().describe("Return all matching items instead of the compact default page."),
verbose: booleanType().optional().describe("Return full records instead of compact summaries.")
};
function json(data) {
return { content: [{ type: "text", text: JSON.stringify(data, null, 2) }] };
}
function mcpHint(page, noun, detailHint) {
const paging = page.hasMore ? `; set limit=${page.limit} and offset=${page.offset + page.shown} for more` : "";
return `Showing ${page.shown}/${page.total} ${noun}${paging}. ${detailHint}`;
}
function pagedJson(key, items, params, summarize, noun, detailHint, extra = {}) {
const page = pageItems(items, {
limit: params?.limit,
offset: params?.offset,
all: params?.all
});
return json({
...extra,
[key]: params?.verbose ? page.items : page.items.map(summarize),
count: page.shown,
total: page.total,
limit: page.limit,
offset: page.offset,
has_more: page.hasMore,
next_offset: page.hasMore ? page.offset + page.shown : null,
compact: !params?.verbose,
hint: mcpHint(page, noun, detailHint)
});
}
function compactDomain(domain) {
return {
id: domain.id,
name: domain.name,
status: domain.status,
registrar: domain.registrar ?? undefined,
expires_at: domain.expires_at ? formatDate(domain.expires_at) : undefined,
ssl_expires_at: domain.ssl_expires_at ? formatDate(domain.ssl_expires_at) : undefined,
auto_renew: domain.auto_renew,
premium: domain.is_premium || undefined,
notes: domain.notes ? truncateText(domain.notes, 90) : undefined
};
}
function compactDnsRecord(record) {
return {
id: record.id,
type: record.type,
name: record.name,
value: truncateText(record.value, 90),
ttl: record.ttl,
priority: record.priority ?? undefined
};
}
function compactOffer(offer) {
return {
id: offer.id,
status: offer.status,
our_offer: offer.our_offer ?? undefined,
their_ask: offer.their_ask ?? undefined,
created_at: formatDate(offer.created_at),
notes: offer.notes ? truncateText(offer.notes, 100) : undefined
};
}
function compactEmailLink(email) {
return {
id: email.id,
type: email.type,
email_id: email.email_id,
thread_id: email.thread_id ?? undefined,
created_at: formatDate(email.created_at)
};
}
function compactAlert(alert) {
return {
id: alert.id,
type: alert.type,
trigger_days_before: alert.trigger_days_before ?? undefined,
sent_at: alert.sent_at ? formatDate(alert.sent_at) : undefined
};
}
function compactOwner(owner) {
return {
id: owner.id,
domain_id: owner.domain_id,
owner: truncateText(owner.owner_name ?? owner.owner_email ?? "unknown", 80),
organization: owner.owner_organization ? truncateText(owner.owner_organization, 80) : undefined,
source: owner.source,
verified: owner.verified,
notes: owner.notes ? truncateText(owner.notes, 100) : undefined
};
}
function compactDomainOwner(owner) {
return {
domain_name: owner.domain_name,
domain_status: owner.domain_status,
premium: owner.is_premium || undefined,
premium_price: owner.premium_price ?? undefined,
owner: truncateText(owner.owner_name ?? owner.owner_email ?? "unknown", 80),
organization: owner.owner_organization ? truncateText(owner.owner_organization, 80) : undefined,
source: owner.source ?? undefined,
verified: Boolean(owner.verified)
};
}
function compactRegisteredDomain(domain) {
return {
domain: domain.domain,
expiry: domain.expiry ? formatDate(domain.expiry) : undefined,
auto_renew: domain.auto_renew,
transfer_lock: domain.transfer_lock
};
}
function compactHostedZone(zone) {
return {
id: zone.id,
name: zone.name,
record_count: zone.record_count,
private_zone: zone.private_zone || undefined,
comment: zone.comment ? truncateText(zone.comment, 90) : undefined
};
}
function compactRoute53Record(record) {
return {
name: record.name,
type: record.type,
ttl: record.alias_target ? undefined : record.ttl,
value: record.alias_target ? `ALIAS ${truncateText(record.alias_target.dns_name, 90)}` : truncateText(record.values.join(", "), 120)
};
}
function compactBulkCheck(result) {
return {
domain: result.domain,
domain_id: result.domain_id,
whois_error: result.whois?.error ? truncateText(result.whois.error, 100) : undefined,
ssl_error: result.ssl?.error ? truncateText(result.ssl.error, 100) : undefined,
dns_valid: result.dns_validation?.valid,
dns_issue_count: result.dns_validation?.issue_count
};
}
function compactAvailabilityResult(result) {
const record = result && typeof result === "object" ? result : {};
return {
domain: record.domain,
available: record.available,
premium: record.premium ?? record.registryPremiumPricing,
price: record.price ?? record.registration_price,
currency: record.currency,
error: record.error ? truncateText(String(record.error), 140) : undefined
};
}
function compactSyncResult(result) {
const record = result && typeof result === "object" ? result : {};
if (Array.isArray(record.providers)) {
const providers = record.providers.map((entry) => {
const provider = entry && typeof entry === "object" ? entry : {};
const providerResult = provider.result && typeof provider.result === "object" ? provider.result : {};
const errors = Array.isArray(providerResult.errors) ? providerResult.errors.map(String) : [];
return {
name: provider.name,
synced: providerResult.synced ?? 0,
created: providerResult.created ?? 0,
updated: providerResult.updated ?? 0,
error_count: errors.length,
errors: errors.slice(0, 5).map((error) => truncateText(error, 160))
};
});
const totalErrors = Array.isArray(record.totalErrors) ? record.totalErrors.map(String) : [];
return {
total_synced: record.totalSynced ?? 0,
provider_count: providers.length,
providers,
total_error_count: totalErrors.length,
total_errors: totalErrors.slice(0, 10).map((error) => truncateText(error, 160)),
compact: true,
hint: "Set verbose=true for full provider-specific sync details."
};
}
const errors = Array.isArray(record.errors) ? record.errors.map(String) : [];
const domains = Array.isArray(record.domains) ? record.domains.map(String) : [];
return {
synced: record.synced ?? 0,
created: record.created ?? undefined,
updated: record.updated ?? undefined,
domain_count: domains.length || undefined,
sample_domains: domains.slice(0, 10),
error_count: errors.length,
errors: errors.slice(0, 10).map((error) => truncateText(error, 160)),
compact: true,
hint: "Set verbose=true for full provider-specific sync details."
};
}
function compactGenericRecord(item) {
const record = item && typeof item === "object" ? item : {};
const value = "value" in record ? record.value : ("data" in record) ? record.data : ("values" in record) ? record.values : undefined;
return {
type: record.type,
name: record.name,
value: value === undefined ? undefined : truncateText(Array.isArray(value) ? value.join(", ") : String(value), 120),
ttl: record.ttl,
priority: record.priority
};
}
function buildServer() {
const server = new McpServer({
name: "domains",
version: getPackageVersion()
});
applySafeModeToolFilter(server);
server.registerTool("create_domain", {
title: "Create Domain",
description: "Add a new domain to the portfolio.",
inputSchema: {
name: stringType(),
registrar: stringType().optional(),
status: enumType(DOMAIN_STATUSES).optional(),
registered_at: stringType().optional(),
expires_at: stringType().optional(),
auto_renew: booleanType().optional(),
is_premium: booleanType().optional(),
premium_price: numberType().optional(),
standard_price: numberType().optional(),
purchase_price: numberType().optional(),
purchase_date: stringType().optional(),
nameservers: arrayType(stringType()).optional(),
ssl_expires_at: stringType().optional(),
ssl_issuer: stringType().optional(),
notes: stringType().optional()
}
}, async (params) => {
const domain = await createDomain(params);
return { content: [{ type: "text", text: JSON.stringify(domain, null, 2) }] };
});
server.registerTool("get_domain", {
title: "Get Domain",
description: "Get a domain by ID or name, including linked offers and emails.",
inputSchema: { id: stringType() }
}, async ({ id }) => {
const details = await getDomainDetails(id);
if (!details) {
return { content: [{ type: "text", text: `Domain '${id}' not found.` }], isError: true };
}
return { content: [{ type: "text", text: JSON.stringify(details, null, 2) }] };
});
server.registerTool("list_domains", {
title: "List Domains",
description: "List domains with optional filters.",
inputSchema: {
search: stringType().optional(),
status: enumType(DOMAIN_STATUSES).optional(),
registrar: stringType().optional(),
is_premium: booleanType().optional(),
...listControls
}
}, async (params) => {
const { limit, offset, all, verbose, ...filters } = params;
const domains = await listDomains(filters);
return pagedJson("domains", domains, { limit, offset, all, verbose }, compactDomain, "domain(s)", "Set verbose=true or call get_domain for full details.");
});
server.registerTool("update_domain", {
title: "Update Domain",
description: "Update an existing domain.",
inputSchema: {
id: stringType(),
name: stringType().optional(),
registrar: stringType().optional(),
status: enumType(DOMAIN_STATUSES).optional(),
registered_at: stringType().optional(),
expires_at: stringType().optional(),
auto_renew: booleanType().optional(),
is_premium: booleanType().optional(),
premium_price: numberType().nullable().optional(),
standard_price: numberType().nullable().optional(),
purchase_price: numberType().nullable().optional(),
purchase_date: stringType().nullable().optional(),
nameservers: arrayType(stringType()).optional(),
ssl_expires_at: stringType().optional(),
ssl_issuer: stringType().optional(),
notes: stringType().optional()
}
}, async ({ id, ...input }) => {
const domain = await updateDomain(id, input);
if (!domain) {
return { content: [{ type: "text", text: `Domain '${id}' not found.` }], isError: true };
}
return { content: [{ type: "text", text: JSON.stringify(domain, null, 2) }] };
});
server.registerTool("mark_domain_premium", {
title: "Mark Domain Premium",
description: "Mark a tracked domain as premium-priced.",
inputSchema: {
domain: stringType().describe("Domain ID or name"),
price: numberType().describe("Premium asking price"),
standard_price: numberType().optional().describe("Optional standard registration price")
}
}, async ({ domain, price, standard_price }) => {
const updated = await markDomainPremium(domain, price, standard_price);
if (!updated) {
return { content: [{ type: "text", text: `Domain '${domain}' not found.` }], isError: true };
}
return { content: [{ type: "text", text: JSON.stringify(updated, null, 2) }] };
});
server.registerTool("add_domain_offer", {
title: "Add Domain Offer",
description: "Log a negotiation step for a tracked domain.",
inputSchema: {
domain: stringType().describe("Domain ID or name"),
our_offer: numberType().optional(),
their_ask: numberType().optional(),
status: enumType(DOMAIN_OFFER_STATUSES).optional(),
notes: stringType().optional()
}
}, async ({ domain, ...input }) => {
const existing = await getDomainByIdentifier(domain);
if (!existing) {
return { content: [{ type: "text", text: `Domain '${domain}' not found.` }], isError: true };
}
const offer = await createDomainOffer({ domain_id: existing.id, ...input });
if (existing.status === "discovered" || existing.status === "researching" || existing.status === "offered") {
await updateDomainLifecycleStatus(existing.id, input.our_offer !== undefined || input.their_ask !== undefined ? "negotiating" : "offered");
}
return { content: [{ type: "text", text: JSON.stringify(offer, null, 2) }] };
});
server.registerTool("list_domain_offers", {
title: "List Domain Offers",
description: "Get negotiation history for a tracked domain.",
inputSchema: {
domain: stringType().describe("Domain ID or name"),
...listControls
}
}, async ({ domain, ...params }) => {
const existing = await getDomainByIdentifier(domain);
if (!existing) {
return { content: [{ type: "text", text: `Domain '${domain}' not found.` }], isError: true };
}
const offers = await listDomainOffers(existing.id);
return pagedJson("offers", offers, params, compactOffer, "offer(s)", "Set verbose=true for full offer records.", { domain: existing.name });
});
server.registerTool("update_domain_status", {
title: "Update Domain Status",
description: "Move a tracked domain through its acquisition lifecycle.",
inputSchema: {
domain: stringType().describe("Domain ID or name"),
status: enumType(DOMAIN_STATUSES),
notes: stringType().optional()
}
}, async ({ domain, status, notes }) => {
const updated = await updateDomainLifecycleStatus(domain, status, notes);
if (!updated) {
return { content: [{ type: "text", text: `Domain '${domain}' not found.` }], isError: true };
}
return { content: [{ type: "text", text: JSON.stringify(updated, null, 2) }] };
});
server.registerTool("record_domain_purchase", {
title: "Record Domain Purchase",
description: "Record a completed domain acquisition without performing the registrar checkout.",
inputSchema: {
domain: stringType().describe("Domain ID or name"),
price: numberType().describe("Purchase price"),
registrar: stringType().describe("Registrar or seller"),
purchase_date: stringType().optional(),
expires_at: stringType().optional(),
auto_renew: booleanType().optional(),
notes: stringType().optional(),
standard_price: numberType().optional()
}
}, async ({ domain, ...input }) => {
const updated = await recordDomainPurchase(domain, input);
if (!updated) {
return { content: [{ type: "text", text: `Domain '${domain}' not found.` }], isError: true };
}
return { content: [{ type: "text", text: JSON.stringify(updated, null, 2) }] };
});
server.registerTool("link_domain_email", {
title: "Link Domain Email",
description: "Link an email or email thread to a tracked domain.",
inputSchema: {
domain: stringType().describe("Domain ID or name"),
email_id: stringType().describe("Email ID from the connected email system"),
thread_id: stringType().optional().describe("Optional email thread ID"),
type: enumType(DOMAIN_EMAIL_TYPES)
}
}, async ({ domain, email_id, thread_id, type }) => {
const existing = await getDomainByIdentifier(domain);
if (!existing) {
return { content: [{ type: "text", text: `Domain '${domain}' not found.` }], isError: true };
}
const link = await linkDomainEmail({ domain_id: existing.id, email_id, thread_id, type });
return { content: [{ type: "text", text: JSON.stringify(link, null, 2) }] };
});
server.registerTool("get_domain_emails", {
title: "Get Domain Emails",
description: "Retrieve all email threads linked to a tracked domain.",
inputSchema: {
domain: stringType().describe("Domain ID or name"),
...listControls
}
}, async ({ domain, ...params }) => {
const existing = await getDomainByIdentifier(domain);
if (!existing) {
return { content: [{ type: "text", text: `Domain '${domain}' not found.` }], isError: true };
}
const emails = await listDomainEmailLinks(existing.id);
return pagedJson("emails", emails, params, compactEmailLink, "email link(s)", "Set verbose=true for full email link records.", { domain: existing.name });
});
server.registerTool("delete_domain", {
title: "Delete Domain",
description: "Delete a domain by ID.",
inputSchema: { id: stringType() }
}, async ({ id }) => {
const deleted = await deleteDomain(id);
return { content: [{ type: "text", text: JSON.stringify({ id, deleted }) }] };
});
server.registerTool("search_domains", {
title: "Search Domains",
description: "Search domains by name, registrar, or notes.",
inputSchema: { query: stringType(), ...listControls }
}, async ({ query, ...params }) => {
const results = await searchDomains(query);
return pagedJson("results", results, params, compactDomain, "result(s)", "Set verbose=true or call get_domain for full details.", { query });
});
server.registerTool("count_domains", {
title: "Count Domains",
description: "Get the total number of domains.",
inputSchema: {}
}, async () => {
const count = await countDomains();
return { content: [{ type: "text", text: JSON.stringify({ count }) }] };
});
server.registerTool("list_expiring_domains", {
title: "List Expiring Domains",
description: "List domains expiring within N days.",
inputSchema: { days: numberType().default(30), ...listControls }
}, async ({ days, ...params }) => {
const domains = await listExpiring(days);
return pagedJson("domains", domains, params, compactDomain, "domain(s)", "Set verbose=true or call get_domain for full details.", { days });
});
server.registerTool("list_ssl_expiring", {
title: "List SSL Expiring",
description: "List domains with SSL certificates expiring within N days.",
inputSchema: { days: numberType().default(30), ...listControls }
}, async ({ days, ...params }) => {
const domains = await listSslExpiring(days);
return pagedJson("domains", domains, params, compactDomain, "domain(s)", "Set verbose=true or call get_domain for full details.", { days });
});
server.registerTool("get_domains_by_registrar", {
title: "Get Domains by Registrar",
description: "List all domains from a specific registrar.",
inputSchema: { registrar: stringType(), ...listControls }
}, async ({ registrar, ...params }) => {
const domains = await getByRegistrar(registrar);
return pagedJson("domains", domains, params, compactDomain, "domain(s)", "Set verbose=true or call get_domain for full details.", { registrar });
});
server.registerTool("get_domain_stats", {
title: "Get Domain Stats",
description: "Get domain portfolio statistics.",
inputSchema: {}
}, async () => {
const stats = await getDomainStats();
return { content: [{ type: "text", text: JSON.stringify(stats, null, 2) }] };
});
server.registerTool("create_dns_record", {
title: "Create DNS Record",
description: "Create a new DNS record for a domain.",
inputSchema: {
domain_id: stringType(),
type: enumType(["A", "AAAA", "CNAME", "MX", "TXT", "NS", "SRV"]),
name: stringType(),
value: stringType(),
ttl: numberType().optional(),
priority: numberType().optional()
}
}, async (params) => {
const record = await createDnsRecord(params);
return { content: [{ type: "text", text: JSON.stringify(record, null, 2) }] };
});
server.registerTool("list_dns_records", {
title: "List DNS Records",
description: "List DNS records for a domain.",
inputSchema: {
domain_id: stringType(),
type: enumType(["A", "AAAA", "CNAME", "MX", "TXT", "NS", "SRV"]).optional(),
...listControls
}
}, async ({ domain_id, type, ...params }) => {
const records = await listDnsRecords(domain_id, type);
return pagedJson("records", records, params, compactDnsRecord, "record(s)", "Set verbose=true for full DNS record values.", { domain_id, type });
});
server.registerTool("update_dns_record", {
title: "Update DNS Record",
description: "Update a DNS record.",
inputSchema: {
id: stringType(),
type: enumType(["A", "AAAA", "CNAME", "MX", "TXT", "NS", "SRV"]).optional(),
name: stringType().optional(),
value: stringType().optional(),
ttl: numberType().optional(),
priority: numberType().optional()
}
}, async ({ id, ...input }) => {
const record = await updateDnsRecord(id, input);
if (!record) {
return { content: [{ type: "text", text: `DNS record '${id}' not found.` }], isError: true };
}
return { content: [{ type: "text", text: JSON.stringify(record, null, 2) }] };
});
server.registerTool("delete_dns_record", {
title: "Delete DNS Record",
description: "Delete a DNS record by ID.",
inputSchema: { id: stringType() }
}, async ({ id }) => {
const deleted = await deleteDnsRecord(id);
return { content: [{ type: "text", text: JSON.stringify({ id, deleted }) }] };
});
server.registerTool("create_alert", {
title: "Create Alert",
description: "Set an alert for a domain (expiry, SSL expiry, or DNS change).",
inputSchema: {
domain_id: stringType(),
type: enumType(["expiry", "ssl_expiry", "dns_change"]),
trigger_days_before: numberType().optional()
}
}, async (params) => {
const alert = await createAlert(params);
return { content: [{ type: "text", text: JSON.stringify(alert, null, 2) }] };
});
server.registerTool("list_alerts", {
title: "List Alerts",
description: "List alerts for a domain.",
inputSchema: { domain_id: stringType(), ...listControls }
}, async ({ domain_id, ...params }) => {
const alerts = await listAlerts(domain_id);
return pagedJson("alerts", alerts, params, compactAlert, "alert(s)", "Set verbose=true for full alert records.", { domain_id });
});
server.registerTool("delete_alert", {
title: "Delete Alert",
description: "Delete an alert by ID.",
inputSchema: { id: stringType() }
}, async ({ id }) => {
const deleted = await deleteAlert(id);
return { content: [{ type: "text", text: JSON.stringify({ id, deleted }) }] };
});
server.registerTool("whois_lookup", {
title: "WHOIS Lookup",
description: "Run a WHOIS lookup for a domain. Parses registrar, expiry, nameservers. Updates DB record if found.",
inputSchema: { domain: stringType().describe("Domain name (e.g. example.com)") }
}, async ({ domain }) => {
try {
const result = await whoisLookup(domain);
return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
} catch (error) {
return {
content: [{ type: "text", text: `WHOIS lookup failed: ${error instanceof Error ? error.message : String(error)}` }],
isError: true
};
}
});
server.registerTool("check_dns_propagation", {
title: "Check DNS Propagation",
description: "Check DNS propagation by querying multiple DNS servers (Google, Cloudflare, Quad9, OpenDNS).",
inputSchema: {
domain: stringType().describe("Domain name to check"),
record_type: stringType().default("A").describe("DNS record type (A, AAAA, CNAME, MX, TXT, NS)")
}
}, async ({ domain, record_type }) => {
try {
const result = await checkDnsPropagation(domain, record_type);
return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
} catch (error) {
return {
content: [{ type: "text", text: `DNS propagation check failed: ${error instanceof Error ? error.message : String(error)}` }],
isError: true
};
}
});
server.registerTool("check_ssl", {
title: "Check SSL Certificate",
description: "Check SSL certificate for a domain. Extracts issuer and expiry. Updates DB record if found.",
inputSchema: { domain: stringType().describe("Domain name (e.g. example.com)") }
}, async ({ domain }) => {
try {
const result = await checkSsl(domain);
return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
} catch (error) {
return {
content: [{ type: "text", text: `SSL check failed: ${error instanceof Error ? error.message : String(error)}` }],
isError: true
};
}
});
server.registerTool("export_zone_file", {
title: "Export Zone File",
description: "Export DNS records for a domain as a BIND-format zone file.",
inputSchema: { domain_id: stringType().describe("Domain ID") }
}, async ({ domain_id }) => {
const zone = await exportZoneFile(domain_id);
if (!zone) {
return { content: [{ type: "text", text: `Domain '${domain_id}' not found.` }], isError: true };
}
return { content: [{ type: "text", text: zone }] };
});
server.registerTool("import_zone_file", {
title: "Import Zone File",
description: "Import DNS records from BIND zone file content into a domain.",
inputSchema: {
domain_id: stringType().describe("Domain ID"),
content: stringType().describe("Zone file content")
}
}, async ({ domain_id, content }) => {
const result = await importZoneFile(domain_id, content);
if (!result) {
return { content: [{ type: "text", text: `Domain '${domain_id}' not found.` }], isError: true };
}
return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
});
server.registerTool("discover_subdomains", {
title: "Discover Subdomains",
description: "Discover subdomains via certificate transparency logs (crt.sh).",
inputSchema: { domain: stringType().describe("Domain name"), ...listControls }
}, async ({ domain, ...params }) => {
const result = await discoverSubdomains(domain);
return pagedJson("subdomains", result.subdomains, params, (name) => name, "subdomain(s)", "Set all=true for every discovered name or verbose=true for the same list with pagination metadata.", {
domain: result.domain,
source: result.source,
error: result.error ? truncateText(result.error, 160) : undefined
});
});
server.registerTool("validate_dns", {
title: "Validate DNS",
description: "Validate DNS records for common issues (CNAME conflicts, missing MX, orphan records).",
inputSchema: { domain_id: stringType().describe("Domain ID") }
}, async ({ domain_id }) => {
const result = await validateDns(domain_id);
if (!result) {
return { content: [{ type: "text", text: `Domain '${domain_id}' not found.` }], isError: true };
}
return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
});
server.registerTool("export_portfolio", {
title: "Export Portfolio",
description: "Export all domains as CSV or JSON with expiry, SSL, registrar, and auto-renew info.",
inputSchema: {
format: enumType(["csv", "json"]).default("json").describe("Export format")
}
}, async ({ format }) => {
const output = await exportPortfolio(format);
return { content: [{ type: "text", text: output }] };
});
server.registerTool("check_all_domains", {
title: "Check All Domains",
description: "Run WHOIS + SSL + DNS validation on all domains. Returns a summary of issues found.",
inputSchema: { ...listControls }
}, async (params) => {
const results = await checkAllDomains();
return pagedJson("results", results, params, compactBulkCheck, "domain check result(s)", "Set verbose=true for full WHOIS/SSL/DNS validation details.");
});
server.registerTool("sync_namecheap", {
title: "Sync Namecheap Domains",
description: "Sync all domains from Namecheap account to the portfolio. Requires NAMECHEAP_API_KEY, NAMECHEAP_USERNAME, and NAMECHEAP_CLIENT_IP env vars.",
inputSchema: {
verbose: booleanType().optional().describe("Return full sync details including provider-specific arrays.")
}
}, async ({ verbose }) => {
try {
const result = await syncToLocalDb({
getDomainByName,
createDomain,
updateDomain
});
return json(verbose ? result : compactSyncResult(result));
} catch (error) {
return {
content: [{ type: "text", text: `Sync failed: ${error instanceof Error ? error.message : String(error)}` }],
isError: true
};
}
});
server.registerTool("renew_via_namecheap", {
title: "Renew Domain via Namecheap",
description: "Renew a domain through the Namecheap API.",
inputSchema: {
domain: stringType().describe("Domain name to renew (e.g. example.com)"),
years: numberType().default(1).describe("Number of years to renew")
}
}, async ({ domain, years }) => {
try {
const result = await renewDomain(domain, years);
return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
} catch (error) {
return {
content: [{ type: "text", text: `Renewal failed: ${error instanceof Error ? error.message : String(error)}` }],
isError: true
};
}
});
server.registerTool("check_availability_namecheap", {
title: "Check Domain Availability",
description: "Check if a domain name is available for registration via Namecheap.",
inputSchema: {
domain: stringType().describe("Domain name to check (e.g. example.com)")
}
}, async ({ domain }) => {
try {
const result = await checkAvailability(domain);
return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
} catch (error) {
return {
content: [{ type: "text", text: `Check failed: ${error instanceof Error ? error.message : String(error)}` }],
isError: true
};
}
});
server.registerTool("sync_godaddy", {
title: "Sync GoDaddy Domains",
description: "Sync all domains from GoDaddy account to the portfolio. Requires GODADDY_API_KEY and GODADDY_API_SECRET env vars.",
inputSchema: {
verbose: booleanType().optional().describe("Return full sync details including provider-specific arrays.")
}
}, async ({ verbose }) => {
try {
const result = await syncToLocalDb2({
getDomainByName,
createDomain,
updateDomain
});
return json(verbose ? result : compactSyncResult(result));
} catch (error) {
return {
content: [{ type: "text", text: `Sync failed: ${error instanceof Error ? error.message : String(error)}` }],
isError: true
};
}
});
server.registerTool("renew_via_godaddy", {
title: "Renew Domain via GoDaddy",
description: "Renew a domain through the GoDaddy API for 1 year.",
inputSchema: {
domain: stringType().describe("Domain name to renew (e.g. example.com)")
}
}, async ({ domain }) => {
try {
const result = await renewDomain2(domain);
return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
} catch (error) {
return {
content: [{ type: "text", text: `Renewal failed: ${error instanceof Error ? error.message : String(error)}` }],
isError: true
};
}
});
server.registerTool("sync_all_providers", {
title: "Sync All Providers",
description: "Sync domains from all configured domain inventory providers (Route 53, Cloudflare zones, Namecheap, GoDaddy, Brandsight) to the portfolio.",
inputSchema: {
verbose: booleanType().optional().describe("Return full sync details for each provider.")
}
}, async ({ verbose }) => {
try {
const result = await syncAll({
getDomainByName,
createDomain,
updateDomain
});
return json(verbose ? result : compactSyncResult(result));
} catch (error) {
return {
content: [{ type: "text", text: `Sync failed: ${error instanceof Error ? error.message : String(error)}` }],
isError: true
};
}
});
server.registerTool("list_providers", {
title: "List Providers",
description: "Show which registrar providers are configured (have API keys set).",
inputSchema: { ...listControls }
}, async (params) => {
const providers = getAvailableProviders();
return pagedJson("providers", providers, params, (provider) => ({
name: provider.name,
type: provider.type,
configured: provider.configured,
inventory: provider.inventory || undefined
}), "provider(s)", "Set verbose=true to include provider environment variable names.");
});
server.registerTool("monitor_brand", {
title: "Monitor Brand",
description: "Monitor a brand name for new domain registrations that are similar (typosquats, homoglyphs, keyword matches).",
inputSchema: {
brand: stringType().describe("Brand name to monitor"),
...listControls
}
}, async ({ brand, ...params }) => {
try {
const result = await monitorBrand(brand);
return pagedJson("alerts", result.alerts, params, (alert) => ({
domain: alert.domain,
type: alert.type,
registered_at: formatDate(alert.registered_at)
}), "alert(s)", "Set all=true for every alert or verbose=true for full alert records.", { brand: result.brand, stub: result.stub });
} catch (error) {
return {
content: [{ type: "text", text: `Monitor failed: ${error instanceof Error ? error.message : String(error)}` }],
isError: true
};
}
});
server.registerTool("similar_domains", {
title: "Similar Domains",
description: "Find typosquat/competing domains similar to the given domain.",
inputSchema: {
domain: stringType().describe("Domain to find similar domains for"),
...listControls
}
}, async ({ domain, ...params }) => {
try {
const result = await getSimilarDomains(domain);
return pagedJson("similar", result.similar, params, (name) => name, "domain(s)", "Set all=true for every similar domain.", { domain: result.domain, stub: result.stub });
} catch (error) {
return {
content: [{ type: "text", text: `Similar domains check failed: ${error instanceof Error ? error.message : String(error)}` }],
isError: true
};
}
});
server.registerTool("domain_threats", {
title: "Domain Threats",
description: "Get a threat assessment for a domain including risk level, threats, and recommendation.",
inputSchema: {
domain: stringType().describe("Domain to assess threats for"),
...listControls
}
}, async ({ domain, ...params }) => {
try {
const result = await getThreatAssessment(domain);
return pagedJson("threats", result.threats, params, (threat) => truncateText(threat, 120), "threat(s)", "Set all=true for every threat or verbose=true for untruncated threat strings.", {
domain: result.domain,
risk_level: result.risk_level,
recommendation: truncateText(result.recommendation, 180),
stub: result.stub
});
} catch (error) {
return {
content: [{ type: "text", text: `Threat assessment failed: ${error instanceof Error ? error.message : String(error)}` }],
isError: true
};
}
});
server.registerTool("r53_check_availability", {
title: "Check Domain Availability (Route 53)",
description: "Check if one or more domains are available for purchase via AWS Route 53. Returns availability, registration, renewal, and transfer pricing.",
inputSchema: {
domains: arrayType(stringType()).describe('One or more domains to check (e.g. ["example.com", "example.io"])'),
...listControls
}
}, async ({ domains, ...params }) => {
try {
const results = await Promise.allSettled(domains.map((d) => checkAvailability3(d)));
const output = results.map((r, i) => r.status === "fulfilled" ? r.value : { domain: domains[i], error: r.reason instanceof Error ? r.reason.message : String(r.reason) });
return pagedJson("results", output, params, compactAvailabilityResult, "availability result(s)", "Set verbose=true for full pricing and transfer fields.");
} catch (error) {
return { content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
}
});
server.registerTool("r53_register_domain", {
title: "Register Domain (Route 53)",
description: "Purchase and register a domain via AWS Route 53. Returns an operation ID to track progress.",
inputSchema: {
domain: stringType().describe("Domain to register"),
first_name: stringType(),
last_name: stringType(),
email: stringType(),
phone: stringType().describe("E.164 format, e.g. +1.5551234567"),
address_line_1: stringType(),
city: stringType(),
state: stringType(),
country_code: stringType().describe("Two-letter country code, e.g. US"),
zip_code: stringType(),
organization_name: stringType().optional(),
duration_years: numberType().min(1).max(10).optional().describe("Registration years (default: 1)"),
auto_renew: booleanType().optional().describe("Auto-renew (default: true)")
}
}, async (params) => {
try {
const result = await registerDomain2(params.domain, {
first_name: params.first_name,
last_name: params.last_name,
email: params.email,
phone: params.phone,
address_line_1: params.address_line_1,
city: params.city,
state: params.state,
country_code: params.country_code,
zip_code: params.zip_code,
organization_name: params.organization_name
}, params.duration_years ?? 1, params.auto_renew ?? true);
return { content: [{ type: "text", text: JSON.stringify({ domain: params.domain, ...result }, null, 2) }] };
} catch (error) {
return { content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
}
});
server.registerTool("r53_registration_status", {
title: "Registration Status (Route 53)",
description: "Check the status of a domain registration operation.",
inputSchema: {
operation_id: stringType().describe("Operation ID from r53_register_domain")
}
}, async ({ operation_id }) => {
try {
const result = await getRegistrationStatus(operation_id);
return { content: [{ type: "text", text: JSON.stringify(result, null, 2) }] };
} catch (error) {
return { content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
}
});
server.registerTool("r53_list_registered_domains", {
title: "List Registered Domains (Route 53)",
description: "List all domains registered via AWS Route 53.",
inputSchema: { ...listControls }
}, async (params) => {
try {
const domains = await listRegisteredDomains();
return pagedJson("domains", domains, params, compactRegisteredDomain, "domain(s)", "Set all=true for every Route 53 domain or call r53_get_domain_detail.");
} catch (error) {
return { content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
}
});
server.registerTool("r53_get_domain_detail", {
title: "Get Domain Detail (Route 53)",
description: "Get full details for a Route 53 registered domain: nameservers, created/expiry dates, auto-renew, transfer lock.",
inputSchema: {
domain: stringType().describe("Domain name (e.g. example.com)")
}
}, async ({ domain }) => {
try {
const detail = await getDomainDetail(domain);
return { content: [{ type: "text", text: JSON.stringify(detail, null, 2) }] };
} catch (error) {
return { content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
}
});
server.registerTool("r53_create_hosted_zone", {
title: "Create Hosted Zone (Route 53)",
description: "Create a Route 53 hosted zone for a domain. Returns zone ID and name servers.",
inputSchema: {
domain: stringType().describe("Domain name"),
comment: stringType().optional().describe("Zone comment")
}
}, async ({ domain, comment }) => {
try {
const zone = await createHostedZone(domain, comment);
return { content: [{ type: "text", text: JSON.stringify(zone, null, 2) }] };
} catch (error) {
return { content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
}
});
server.registerTool("r53_list_hosted_zones", {
title: "List Hosted Zones (Route 53)",
description: "List all Route 53 hosted zones.",
inputSchema: { ...listControls }
}, async (params) => {
try {
const zones = await listHostedZones();
return pagedJson("zones", zones, params, compactHostedZone, "zone(s)", "Set all=true for every zone or call r53_get_hosted_zone.");
} catch (error) {
return { content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
}
});
server.registerTool("r53_get_hosted_zone", {
title: "Get Hosted Zone (Route 53)",
description: "Get details of a Route 53 hosted zone including name servers.",
inputSchema: {
hosted_zone_id: stringType().describe("Hosted zone ID")
}
}, async ({ hosted_zone_id }) => {
try {
const zone = await getHostedZone(hosted_zone_id);
return { content: [{ type: "text", text: JSON.stringify(zone, null, 2) }] };
} catch (error) {
return { content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
}
});
server.registerTool("r53_delete_hosted_zone", {
title: "Delete Hosted Zone (Route 53)",
description: "Delete a Route 53 hosted zone.",
inputSchema: {
hosted_zone_id: stringType().describe("Hosted zone ID")
}
}, async ({ hosted_zone_id }) => {
try {
await deleteHostedZone(hosted_zone_id);
return { content: [{ type: "text", text: `Hosted zone ${hosted_zone_id} deleted.` }] };
} catch (error) {
return { content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
}
});
server.registerTool("r53_list_records", {
title: "List DNS Records (Route 53)",
description: "List all DNS records in a Route 53 hosted zone for a domain.",
inputSchema: {
domain: stringType().describe("Domain name (will find the hosted zone automatically)"),
...listControls
}
}, async ({ domain, ...params }) => {
try {
const zone = await findHostedZoneByDomain(domain);
if (!zone)
throw new Error(`No hosted zone found for ${domain}`);
const records = await listRecords(zone.id);
return pagedJson("records", records, params, compactRoute53Record, "record(s)", "Set all=true for every DNS record or verbose=true for full Route 53 record values.", { domain, zone_id: zone.id });
} catch (error) {
return { content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
}
});
server.registerTool("r53_upsert_record", {
title: "Upsert DNS Record (Route 53)",
description: "Create or update a DNS record in a Route 53 hosted zone.",
inputSchema: {
domain: stringType().describe("Domain name (hosted zone)"),
record_type: stringType().describe("Record type (A, AAAA, CNAME, TXT, MX, NS)"),
record_name: stringType().describe("Record name (FQDN)"),
record_values: arrayType(stringType()).optional().describe("Record values (one or more). Omit when using alias_target."),
ttl: numberType().optional().describe("TTL in seconds (default: 300). Ignored for alias records."),
alias_hosted_zone_id: stringType().optional().describe("For alias records: hosted zone ID of the target (e.g. Z2FDTNDATAQYW2 for CloudFront)"),
alias_dns_name: stringType().optional().describe("For alias records: DNS name of the alias target (e.g. d1234.cloudfront.net)")
}
}, async ({ domain, record_type, record_name, record_values, ttl, alias_hosted_zone_id, alias_dns_name }) => {
try {
if (!record_values?.length && !(alias_hosted_zone_id && alias_dns_name)) {
throw new Error("Provide either record_values or both alias_hosted_zone_id and alias_dns_name.");
}
const zone = await findHostedZoneByDomain(domain);
if (!zone)
throw new Error(`No hosted zone found for ${domain}`);
const aliasTarget = alias_hosted_zone_id && alias_dns_name ? { hosted_zone_id: alias_hosted_zone_id, dns_name: alias_dns_name } : undefined;
await upsertRecord(zone.id, { name: record_name, type: record_type, ttl: ttl ?? 300, values: record_values ?? [], alias_target: aliasTarget });
const desc = aliasTarget ? `alias \u2192 ${aliasTarget.dns_name}` : `${record_values.length} value(s)`;
return { content: [{ type: "text", text: `Record upserted: ${record_type} ${record_name} (${desc})` }] };
} catch (error) {
return { content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
}
});
server.registerTool("r53_delete_record", {
title: "Delete DNS Record (Route 53)",
description: "Delete a DNS record from a Route 53 hosted zone. Fetches the existing record set automatically to ensure an exact match (required by AWS).",
inputSchema: {
domain: stringType().describe("Domain name (hosted zone)"),
record_type: stringType().describe("Record type (A, AAAA, CNAME, TXT, MX, NS)"),
record_name: stringType().describe("Record name (FQDN)")
}
}, async ({ domain, record_type, record_name }) => {
try {
const zone = await findHostedZoneByDomain(domain);
if (!zone)
throw new Error(`No hosted zone found for ${domain}`);
const records = await listRecords(zone.id);
const normName = record_name.endsWith(".") ? record_name : `${record_name}.`;
const existing = records.find((r) => r.type === record_type.toUpperCase() && (r.name === record_name || r.name === normName));
if (!existing)
throw new Error(`No ${record_type} record found for ${record_name}`);
await deleteRecord(zone.id, {
name: existing.name,
type: existing.type,
ttl: existing.ttl,
values: existing.values,
alias_target: existing.alias_target
});
return { content: [{ type: "text", text: `Record deleted: ${existing.type} ${existing.name}` }] };
} catch (error) {
return { content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
}
});
server.registerTool("r53_upsert_records", {
title: "Batch Upsert DNS Records (Route 53)",
description: "Create or update multiple DNS records in a single Route 53 API call. More efficient than calling r53_upsert_record repeatedly.",
inputSchema: {
domain: stringType().describe("Domain name (hosted zone)"),
records: arrayType(objectType({
record_type: stringType().describe("Record type (A, AAAA, CNAME, TXT, MX, NS)"),
record_name: stringType().describe("Record name (FQDN)"),
record_values: arrayType(stringType()).describe("Record values"),
ttl: numberType().optional().describe("TTL in seconds (default: 300)"),
alias_hosted_zone_id: stringType().optional().describe("Alias target hosted zone ID"),
alias_dns_name: stringType().optional().describe("Alias target DNS name")
})).describe("Records to upsert")
}
}, async ({ domain, records }) => {
try {
const zone = await findHostedZoneByDomain(domain);
if (!zone)
throw new Error(`No hosted zone found for ${domain}`);
const r53Records = records.map((r) => ({
name: r.record_name,
type: r.record_type,
ttl: r.ttl ?? 300,
values: r.record_values,
alias_target: r.alias_hosted_zone_id && r.alias_dns_name ? { hosted_zone_id: r.alias_hosted_zone_id, dns_name: r.alias_dns_name } : undefined
}));
await upsertRecords(zone.id, r53Records);
return { content: [{ type: "text", text: `Upserted ${records.length} record(s) in ${domain}` }] };
} catch (error) {
return { content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
}
});
server.registerTool("domain_check", {
title: "Check Domain Availability",
description: "Check if one or more domains are available via the configured registrar provider.",
inputSchema: {
domains: arrayType(stringType()).describe("Domain names to check"),
provider: stringType().optional().describe("Registrar provider name (default: config default-registrar or route53)"),
...listControls
}
}, async ({ domains, provider, ...params }) => {
try {
const providerName = provider ?? loadConfig4().default_registrar ?? "route53";
const reg = getRegistrarProvider(providerName);
const results = await Promise.allSettled(domains.map((d) => reg.checkAvailability(d)));
const output = results.map((r, i) => r.status === "fulfilled" ? r.value : { domain: domains[i], error: r.reason instanceof Error ? r.reason.message : String(r.reason) });
return pagedJson("results", output, params, compactAvailabilityResult, "availability result(s)", "Set verbose=true for full provider-specific availability details.", { provider: providerName });
} catch (error) {
return { content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
}
});
server.registerTool("domain_setup", {
title: "Buy + Setup Domain",
description: "Full setup: buy domain via registrar, create/reuse DNS zone, and delegate nameservers when registration is complete. Uses contact info from config.",
inputSchema: {
domain: stringType().describe("Domain to purchase and set up"),
registrar: stringType().optional().describe("Registrar provider (default: config default-registrar or route53)"),
dns: stringType().optional().describe("DNS provider for zone creation (default: config default-dns or cloudflare)"),
years: numberType().optional().describe("Registration years (default: 1)"),
wait: booleanType().optional().describe("Poll until registration completes before creating zone")
}
}, async ({ domain, registrar, dns, years, wait }) => {
try {
const cfg = loadConfig4();
const registrarName = registrar ?? cfg.default_registrar ?? "route53";
const dnsName = dns ?? cfg.default_dns ?? "cloudflare";
if (registrarName !== "route53")
throw new Error("Direct purchase currently only supported via route53");
const contact = resolveContact({});
const avail = await checkAvailability3(domain);
if (!avail.available)
throw new Error(`${domain} is not available`);
const reg = await registerDomain2(domain, contact, years ?? 1);
if (wait) {
let status = "IN_PROGRESS";
while (status === "IN_PROGRESS" || status === "SUBMITTED") {
await new Promise((r) => setTimeout(r, 1e4));
status = (await getRegistrationStatus(reg.operationId)).status;
}
if (status !== "SUCCESSFUL")
throw new Error(`Registration ${status}`);
}
let nameservers = [];
let zoneId;
if (dnsName === "cloudflare") {
const zone = await ensureZone(domain);
zoneId = zone.id;
nameservers = zone.nameservers ?? [];
} else {
const zone = await createHostedZone(domain, "Managed by domains MCP");
zoneId = zone.id;
nameservers = zone.name_servers ?? [];
}
let delegationOperationId;
if (wait && nameservers.length > 0) {
const nsUpdate = await updateNameservers2(domain, nameservers);
delegationOperationId = nsUpdate.operationId;
}
const existing = await getDomainByName(domain);
const dbInput = { registrar: "AWS Route 53", status: "active", auto_renew: true, nameservers };
if (existing)
await updateDomain(existing.id, dbInput);
else
await createDomain({ name: domain, ...dbInput });
return {
content: [
{
type: "text",
text: JSON.stringify({
domain,
operationId: reg.operationId,
nameservers,
dns_provider: dnsName,
zone_id: zoneId,
nameservers_delegated: Boolean(delegationOperationId),
delegation_operation_id: delegationOperationId
}, null, 2)
}
]
};
} catch (error) {
return { content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
}
});
server.registerTool("dns_list", {
title: "List DNS Records",
description: "List live DNS records for a domain from a DNS provider.",
inputSchema: {
domain: stringType().describe("Domain name"),
provider: stringType().optional().describe("DNS provider (route53, cloudflare \u2014 default: config default-dns)"),
...listControls
}
}, async ({ domain, provider, ...params }) => {
try {
const providerName = provider ?? loadConfig4().default_dns ?? "route53";
const dns = getDnsProvider(providerName);
const records = await dns.getDnsRecords(domain);
return pagedJson("records", records, params, compactGenericRecord, "record(s)", "Set all=true for every live DNS record or verbose=true for full provider-specific records.", { domain, provider: providerName });
} catch (error) {
return { content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
}
});
server.registerTool("dns_set", {
title: "Set DNS Records",
description: "Create or update DNS records via a DNS provider.",
inputSchema: {
domain: stringType().describe("Domain name"),
records: arrayType(objectType({
type: stringType(),
name: stringType(),
value: stringType(),
ttl: numberType().optional(),
priority: numberType().optional()
})),
provider: stringType().optional().describe("DNS provider (default: config default-dns)")
}
}, async ({ domain, records, provider }) => {
try {
const providerName = provider ?? loadConfig4().default_dns ?? "route53";
const dns = getDnsProvider(providerName);
await dns.setDnsRecords(domain, records.map((r) => ({ ...r, ttl: r.ttl ?? 300 })));
return { content: [{ type: "text", text: `Set ${records.length} record(s) on ${domain} via ${providerName}` }] };
} catch (error) {
return { content: [{ type: "text", text: `Error: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
}
});
server.registerTool("sync_route53", {
title: "Sync Route 53",
description: "Sync domains registered in AWS Route 53 to the portfolio.",
inputSchema: {
verbose: booleanType().optional().describe("Return full sync details including provider-specific arrays.")
}
}, async ({ verbose }) => {
try {
const provider = createRoute53Provider();
const result = await provider.syncToLocalDb({
getDomainByName,
createDomain,
updateDomain
});
return json(verbose ? result : compactSyncResult(result));
} catch (error) {
return { content: [{ type: "text", text: `Sync failed: ${error instanceof Error ? error.message : String(error)}` }], isError: true };
}
});
server.registerTool("list_domain_owners", {
title: "List Domain Owners",
description: "List all premium domain owners with optional search and filters.",
inputSchema: {
search: stringType().optional(),
source: enumType(["whois", "manual", "brandsight", "import"]).optional(),
verified_only: booleanType().optional(),
with_domains: booleanType().optional(),
...listControls
}
}, async (params) => {
const { limit, offset, all, verbose } = params;
if (params.with_domains) {
const results = await listDomainsWithOwners();
return pagedJson("owners", results, { limit, offset, all, verbose }, compactDomainOwner, "owner/domain row(s)", "Set verbose=true for full joined owner fields.");
}
const owners = await listDomainOwners({
search: params.search,
source: params.source,
verified: params.verified_only ? true : undefined
});
return pagedJson("owners", owners, { limit, offset, all, verbose }, compactOwner, "owner(s)", "Set verbose=true or call get_domain_owner for full contact fields.");
});
server.registerTool("get_domain_owner", {
title: "Get Domain Owner",
description: "Get owner info for a domain or by owner ID.",
inputSchema: {
identifier: stringType().optional(),
owner_id: stringType().optional()
}
}, async ({ identifier, owner_id }) => {
if (owner_id) {
const o = await getDomainOwner(owner_id);
if (!o)
return { content: [{ type: "text", text: `Owner '${owner_id}' not found.` }], isError: true };
return { content: [{ type: "text", text: JSON.stringify(o, null, 2) }] };
}
if (identifier) {
const domain = await getDomainByIdentifier(identifier);
if (!domain)
return { content: [{ type: "text", text: `Domain '${identifier}' not found.` }], isError: true };
const o = await getDomainOwnerByDomain(domain.id);
if (!o)
return { content: [{ type: "text", text: `No owner info for ${domain.name}.` }] };
return { content: [{ type: "text", text: JSON.stringify(o, null, 2) }] };
}
return { content: [{ type: "text", text: "Provide identifier or owner_id." }], isError: true };
});
server.registerTool("create_domain_owner", {
title: "Create Domain Owner",
description: "Add owner info for a tracked domain.",
inputSchema: {
domain_id: stringType(),
contact_id: stringType().optional(),
owner_name: stringType().optional(),
owner_email: stringType().optional(),
owner_phone: stringType().optional(),
owner_organization: stringType().optional(),
source: enumType(["whois", "manual", "brandsight", "import"]).optional(),
verified: booleanType().optional(),
notes: stringType().optional()
}
}, async (params) => {
if (!params.owner_name && !params.owner_email && !params.owner_organization && !params.contact_id) {
return { content: [{ type: "text", text: "At least one of owner_name, owner_email, owner_organization, or contact_id is required." }], isError: true };
}
const o = await createDomainOwner(params);
return { content: [{ type: "text", text: JSON.stringify(o, null, 2) }] };
});
server.registerTool("update_domain_owner", {
title: "Update Domain Owner",
description: "Update an existing domain owner record.",
inputSchema: {
owner_id: stringType(),
contact_id: stringType().optional(),
owner_name: stringType().optional(),
owner_email: stringType().optional(),
owner_phone: stringType().optional(),
owner_organization: stringType().optional(),
verified: booleanType().optional(),
notes: stringType().optional()
}
}, async ({ owner_id, ...rest }) => {
const o = await updateDomainOwner(owner_id, rest);
if (!o)
return { content: [{ type: "text", text: `Owner '${owner_id}' not found.` }], isError: true };
return { content: [{ type: "text", text: JSON.stringify(o, null, 2) }] };
});
server.registerTool("delete_domain_owner", {
title: "Delete Domain Owner",
description: "Delete a domain owner record.",
inputSchema: { owner_id: stringType() }
}, async ({ owner_id }) => {
const deleted = await deleteDomainOwner(owner_id);
if (!deleted)
return { content: [{ type: "text", text: `Owner '${owner_id}' not found.` }], isError: true };
return { content: [{ type: "text", text: `Deleted owner ${owner_id}` }] };
});
server.registerTool("extract_domain_owner_from_whois", {
title: "Extract Owner from WHOIS",
description: "Run WHOIS lookup and extract owner info, saving it to the database.",
inputSchema: { domain_name: stringType() }
}, async ({ domain_name }) => {
try {
const whois = await whoisLookup(domain_name);
if (!whois.raw)
return { content: [{ type: "text", text: "WHOIS returned no data." }], isError: true };
const o = await extractOwnerFromWhois(domain_name, whois.raw);
if (!o)
return { content: [{ type: "text", text: "No owner information found in WHOIS data." }] };
return { content: [{ type: "text", text: JSON.stringify(o, null, 2) }] };
} catch (error) {
return {
content: [{ type: "text", text: `WHOIS owner extraction failed: ${error instanceof Error ? error.message : String(error)}` }],
isError: true
};
}
});
return server;
}
function printHelp() {
console.log(`Usage: domains-mcp [options]
MCP server for @hasna/domains (Streamable HTTP by default, stdio with --stdio)
Options:
--stdio Serve MCP over stdio (env: MCP_STDIO=1)
--http Serve MCP over Streamable HTTP (127.0.0.1; env: MCP_HTTP=1)
--port <number> HTTP port (default: 8859, env: MCP_HTTP_PORT)
-V, --version output the version number
-h, --help display help for command`);
}
async function main() {
const argv = process.argv.slice(2);
if (argv.includes("--help") || argv.includes("-h")) {
printHelp();
process.exit(0);
}
if (argv.includes("--version") || argv.includes("-V")) {
console.log(getPackageVersion());
process.exit(0);
}
try {
getStoreResolution();
} catch (error) {
console.error(error instanceof Error ? error.message : String(error));
process.exit(1);
}
await Promise.resolve().then(() => init_http());
if (isStdioMode2(argv)) {
const transport = new StdioServerTransport;
await buildServer().connect(transport);
console.error("domains MCP server running on stdio");
return;
}
await Promise.resolve().then(() => init_http());
const port = resolveMcpHttpPort2(argv);
await startHttpServer(buildServer, port);
await new Promise(() => {});
}
if (import.meta.main) {
main().catch((error) => {
console.error("Fatal error:", error);
process.exit(1);
});
}
export {
buildServer
};