@hasna/domains
Version:
Domain portfolio, registrar, marketplace, and DNS management for AI agents — CLI + MCP + HTTP API + SDK, shared account API and PostgreSQL
36,849 lines • 1.33 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/@aws-sdk+credential-provider-env@3.972.70/node_modules/@aws-sdk/credential-provider-env/dist-es/fromEnv.js
var import_client3, 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_client3.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_client3 = __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_cjs3 = __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 getCredentials(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_client4, 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 getCredentials(result.response).then((creds) => import_client4.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_client4 = __toESM(require_client2());
import_config9 = __toESM(require_config());
import_node_http_handler = __toESM(require_dist_cjs3());
});
// ../../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-node@3.972.82/node_modules/@aws-sdk/credential-provider-node/dist-es/remoteProvider.js
var import_config10, ENV_IMDS_DISABLED = "AWS_EC2_METADATA_DISABLED", 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);
};
var init_remoteProvider = __esm(() => {
import_config10 = __toESM(require_config());
});
// ../../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-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+signature-v4@5.7.3/node_modules/@smithy/signature-v4/dist-cjs/index.js
var require_dist_cjs4 = __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_cjs4();
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/@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_cjs3();
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 createAwsAuthSigv4HttpAuthOption(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, normalizeProvider, getSmithyContext, 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, resolveAwsSdkSigV4Config, AwsSdkSigV4Signer, NODE_AUTH_SCHEME_PREFERENCE_OPTIONS, toUtf8, fromUtf8, toBase64, fromBase64, calculateBodyLength, streamCollector, NodeHttpHandler2, AwsRestJsonProtocol, Sha256, defaultSSOHttpAuthSchemeParametersProvider = 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`");
})()
};
}, defaultSSOHttpAuthSchemeProvider = (authParameters) => {
const options = [];
switch (authParameters.operation) {
case "GetRoleCredentials": {
options.push(createSmithyApiNoAuthHttpAuthOption());
break;
}
default: {
options.push(createAwsAuthSigv4HttpAuthOption(authParameters));
}
}
return options;
}, resolveHttpAuthSchemeConfig = (config) => {
const config_0 = resolveAwsSdkSigV4Config(config);
return Object.assign(config_0, {
authSchemePreference: normalizeProvider(config.authSchemePreference ?? [])
});
}, resolveClientEndpointParameters = (options) => {
return Object.assign(options, {
useDualstackEndpoint: options.useDualstackEndpoint ?? false,
useFipsEndpoint: options.useFipsEndpoint ?? false,
defaultSigningName: "awsssoportal"
});
}, commonParams, version = "3.997.43", packageInfo, k = "ref", a = -1, b = true, c = "isSet", d = "PartitionResult", e = "booleanEquals", f = "getAttr", g, h, i, j, _data, root = 2, r = 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, getSmithyContext, 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, AwsSdkSigV4Signer, NODE_AUTH_SCHEME_PREFERENCE_OPTIONS } = require_httpAuthSchemes());
({ toUtf8, fromUtf8, toBase64, fromBase64, calculateBodyLength } = require_serde());
({ streamCollector, NodeHttpHandler: NodeHttpHandler2 } = require_dist_cjs3());
({ AwsRestJsonProtocol } = require_protocols2());
({ Sha256 } = require_checksum());
commonParams = {
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],
[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://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,
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
]);
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 = 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: defaultSSOHttpAuthSchemeParametersProvider,
identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
"aws.auth#sigv4": config.credentials
})
}));
this.middlewareStack.use(getHttpSigningPlugin(this.config));
}
destroy() {
super.destroy();
}
};
command = makeBuilder(commonParams, "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_client5, 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_client5.setCredentialFeature(credentials, "CREDENTIALS_SSO", "s");
} else {
import_client5.setCredentialFeature(credentials, "CREDENTIALS_SSO_LEGACY", "u");
}
return credentials;
};
var init_resolveSSOCredentials = __esm(() => {
init_dist_es4();
import_client5 = __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_client6, 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_client6.setCredentialFeature(creds, "CREDENTIALS_PROFILE_NAMED_PROVIDER", "p");
var init_resolveCredentialSource = __esm(() => {
import_client6 = __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_cjs4();
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_cjs3();
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_client7, 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_client7.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_client7.setCredentialFeature(creds, "CREDENTIALS_PROFILE_SOURCE_PROFILE", "o"));
}
}, isCredentialSourceWithoutRoleArn = (section) => {
return !section.role_arn && !!section.credential_source;
};
var init_resolveAssumeRoleCredentials = __esm(() => {
init_resolveCredentialSource();
import_client7 = __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_cjs3();
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 as createHash5, createPrivateKey, createPublicKey, sign } from "crypto";
import { promises as fs2 } from "fs";
import { homedir } from "os";
import { dirname as dirname2, join } 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 = dirname2(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 ?? join(homedir(), ".aws", "login", "cache");
const loginSessionBytes = Buffer.from(this.loginSession, "utf8");
const loginSessionSha256 = createHash5("sha256").update(loginSessionBytes).digest("hex");
return join(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_client8, 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_client8.setCredentialFeature(credentials, "CREDENTIALS_LOGIN", "AD");
};
var init_fromLoginCredentials = __esm(() => {
init_LoginCredentialsFetcher();
import_client8 = __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_client9, 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_client9.setCredentialFeature(credentials, "CREDENTIALS_PROFILE_LOGIN", "AC");
};
var init_resolveLoginCredentials = __esm(() => {
import_client9 = __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_client10, 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_client10.setCredentialFeature(credentials, "CREDENTIALS_PROCESS", "w");
return credentials;
};
var init_getValidatedProcessCredentials = __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/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_client11, 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_client11.setCredentialFeature(credentials, "CREDENTIALS_PROFILE_PROCESS", "v");
};
var init_resolveProcessCredentials2 = __esm(() => {
import_client11 = __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_client12, 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_client12.setCredentialFeature(creds, "CREDENTIALS_PROFILE_SSO", "r");
} else {
return import_client12.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_client12 = __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_client13, 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_client13.setCredentialFeature(credentials, "CREDENTIALS_PROFILE", "n");
};
var init_resolveStaticCredentials = __esm(() => {
import_client13 = __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 readFileSync3 } from "fs";
var import_client14, 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] ?? readFileSync3(webIdentityTokenFile, { encoding: "ascii" }),
roleArn,
roleSessionName
})(awsIdentityProperties);
if (webIdentityTokenFile === process.env[ENV_TOKEN_FILE]) {
import_client14.setCredentialFeature(credentials, "CREDENTIALS_ENV_VARS_STS_WEB_ID_TOKEN", "h");
}
return credentials;
};
var init_fromTokenFile = __esm(() => {
import_client14 = __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_client15, 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_client15.setCredentialFeature(credentials, "CREDENTIALS_PROFILE_STS_WEB_ID_TOKEN", "q");
};
var init_resolveWebIdentityCredentials = __esm(() => {
import_client15 = __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();
});
// ../../node_modules/.bun/@aws-sdk+credential-provider-node@3.972.82/node_modules/@aws-sdk/credential-provider-node/dist-es/defaultProvider.js
var import_config27, multipleCredentialSourceWarningEmitted = false, 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), credentialsTreatedAsExpired = (credentials) => credentials?.expiration !== undefined && credentials.expiration.getTime() - Date.now() < 300000;
var init_defaultProvider = __esm(() => {
init_dist_es();
init_remoteProvider();
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/index.js
var init_dist_es10 = __esm(() => {
init_defaultProvider();
});
// ../../node_modules/.bun/@aws-sdk+credential-providers@3.1127.0/node_modules/@aws-sdk/credential-providers/dist-es/loadSts.js
var exports_loadSts = {};
__export(exports_loadSts, {
AssumeRoleCommand: () => import_sts.AssumeRoleCommand,
STSClient: () => import_sts.STSClient
});
var import_sts;
var init_loadSts = __esm(() => {
import_sts = __toESM(require_sts());
});
// ../contracts/dist/auth/index.js
import { createHash, createHmac, randomBytes, timingSafeEqual } from "crypto";
var MAX_TENANT_ID_LENGTH = 64;
var TENANT_ID_PATTERN = new RegExp(`^[A-Za-z0-9][A-Za-z0-9._-]{0,${MAX_TENANT_ID_LENGTH - 1}}$`);
var UUID_HEX = "[0-9a-fA-F]";
var UUID_PATTERN = new RegExp(`^\\{?(?:${UUID_HEX}{8}-${UUID_HEX}{4}-${UUID_HEX}{4}-${UUID_HEX}{4}-${UUID_HEX}{12}|${UUID_HEX}{32})\\}?$`);
function isValidTenantId(value) {
return typeof value === "string" && TENANT_ID_PATTERN.test(value);
}
function isUuidTenantId(value) {
return typeof value === "string" && UUID_PATTERN.test(value);
}
function canonicalizeTenantId(value) {
if (!isUuidTenantId(value))
return value;
const hex = value.replace(/[{}-]/g, "").toLowerCase();
return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
}
function normalizeTenantId(value) {
const trimmed = typeof value === "string" ? value.trim() : "";
const canonical = canonicalizeTenantId(trimmed);
if (!isValidTenantId(canonical)) {
throw new Error(`Invalid tenant id '${value}'. Expected 1-${MAX_TENANT_ID_LENGTH} characters matching ${TENANT_ID_PATTERN} (a UUID, ULID, slug, or prefixed id).`);
}
return canonical;
}
function tenantIdsEqual(left, right) {
const canonical = (value) => {
if (typeof value !== "string")
return null;
const folded = canonicalizeTenantId(value.trim());
return isValidTenantId(folded) ? folded : null;
};
const a = canonical(left);
const b = canonical(right);
return a !== null && b !== null && a === b;
}
function ownTenantId(source) {
return Object.hasOwn(source, "tid") ? source.tid : undefined;
}
var API_KEY_TOKEN_VERSION = 1;
var API_KEY_NAMESPACE = "hasna";
var API_KEY_TOKEN_PATTERN = /^hasna_([a-z][a-z0-9-]*)_([A-Za-z0-9_-]+)\.([A-Za-z0-9_-]+)$/;
var TOKEN_PATTERN = API_KEY_TOKEN_PATTERN;
var DEFAULT_API_KEY_TTL_SECONDS = 90 * 24 * 60 * 60;
function ownAgentClaim(source) {
return Object.hasOwn(source, "agent") && typeof source.agent === "string" ? source.agent : null;
}
function ownScopesClaim(source) {
return Object.hasOwn(source, "scopes") && Array.isArray(source.scopes) ? source.scopes : null;
}
function ownOption(options, name) {
return Object.hasOwn(options, name) ? options[name] : undefined;
}
var typedArrayPrototype = Object.getPrototypeOf(Uint8Array.prototype);
var intrinsicViewBuffer = Object.getOwnPropertyDescriptor(typedArrayPrototype, "buffer").get;
var intrinsicViewByteOffset = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteOffset").get;
var intrinsicViewByteLength = Object.getOwnPropertyDescriptor(typedArrayPrototype, "byteLength").get;
var intrinsicDataViewBuffer = Object.getOwnPropertyDescriptor(DataView.prototype, "buffer").get;
var intrinsicDataViewByteOffset = Object.getOwnPropertyDescriptor(DataView.prototype, "byteOffset").get;
var intrinsicDataViewByteLength = Object.getOwnPropertyDescriptor(DataView.prototype, "byteLength").get;
function viewWindow(view) {
try {
return [
intrinsicViewBuffer.call(view),
intrinsicViewByteOffset.call(view),
intrinsicViewByteLength.call(view)
];
} catch {
return [
intrinsicDataViewBuffer.call(view),
intrinsicDataViewByteOffset.call(view),
intrinsicDataViewByteLength.call(view)
];
}
}
function toBuffer(secret) {
if (typeof secret === "string")
return Buffer.from(secret.trim(), "utf8");
if (ArrayBuffer.isView(secret)) {
const [store, byteOffset, byteLength] = viewWindow(secret);
return Buffer.from(store, byteOffset, byteLength);
}
return Buffer.from(secret);
}
function hmac(signingSecret, message) {
return createHmac("sha256", toBuffer(signingSecret)).update(message, "utf8").digest();
}
function apiKeyPrefix(app) {
return `${API_KEY_NAMESPACE}_${app}_`;
}
function parseApiKey(token) {
if (typeof token !== "string")
return null;
const match = TOKEN_PATTERN.exec(token);
if (!match)
return null;
const [, app, body, sig] = match;
if (!app || !body || !sig)
return null;
let claims;
try {
claims = JSON.parse(Buffer.from(body, "base64url").toString("utf8"));
} catch {
return null;
}
if (typeof claims !== "object" || claims === null || typeof claims.kid !== "string" || typeof claims.app !== "string" || ownScopesClaim(claims) === null) {
return null;
}
const claimedTid = ownTenantId(claims);
if (claimedTid !== undefined && !isValidTenantId(claimedTid)) {
return null;
}
return { app, body, sig, claims };
}
function verifyApiKeyToken(token, options) {
const optSigningSecret = ownOption(options, "signingSecret");
const optExpectedApp = ownOption(options, "expectedApp");
const optNowMs = ownOption(options, "nowMs");
const optLeewaySeconds = ownOption(options, "leewaySeconds");
const optRequiredScopes = ownOption(options, "requiredScopes");
const optRequireTenant = ownOption(options, "requireTenant");
const optExpectedTid = ownOption(options, "expectedTid");
const parsed = parseApiKey(token);
if (!parsed) {
return { ok: false, reason: "malformed", message: "Token is malformed." };
}
const { app, body, sig, claims } = parsed;
if (claims.v !== API_KEY_TOKEN_VERSION) {
return { ok: false, reason: "unsupported_version", message: `Unsupported token version ${claims.v}.` };
}
if (claims.app !== app) {
return { ok: false, reason: "app_mismatch", message: "Token prefix app does not match claims." };
}
if (optExpectedApp !== undefined && app !== optExpectedApp) {
return { ok: false, reason: "app_mismatch", message: `Token is for app '${app}', expected '${optExpectedApp}'.` };
}
const expected = hmac(optSigningSecret, `${apiKeyPrefix(app)}${body}`);
let provided;
try {
provided = Buffer.from(sig, "base64url");
} catch {
return { ok: false, reason: "bad_signature", message: "Signature is not valid base64url." };
}
if (provided.length !== expected.length || !timingSafeEqual(provided, expected)) {
return { ok: false, reason: "bad_signature", message: "Signature verification failed." };
}
const agent = ownAgentClaim(claims);
const now = Math.floor((optNowMs ?? Date.now()) / 1000);
const leeway = optLeewaySeconds ?? 0;
if (typeof claims.iat === "number" && now + leeway < claims.iat) {
return { ok: false, reason: "not_yet_valid", message: "Token is not yet valid.", agent };
}
if (claims.exp !== null && typeof claims.exp === "number" && now - leeway >= claims.exp) {
return { ok: false, reason: "expired", message: "Token has expired.", agent };
}
const verifiedTid = ownTenantId(claims);
const tid = verifiedTid === undefined ? null : canonicalizeTenantId(verifiedTid);
const tenantRequired = Boolean(optRequireTenant) || optExpectedTid !== undefined;
if (tenantRequired && tid === null) {
return {
ok: false,
reason: "tenant_required",
message: "Token carries no tenant id ('tid') and this service requires one.",
kid: claims.kid,
tid: null,
agent
};
}
if (optExpectedTid !== undefined && !tenantIdsEqual(tid, optExpectedTid)) {
const expectationIsWellFormed = typeof optExpectedTid === "string" && isValidTenantId(optExpectedTid.trim());
return {
ok: false,
reason: "tenant_mismatch",
message: expectationIsWellFormed ? "Token is for a different tenant than the one this service accepts." : "Token tenant cannot be checked: the expected tenant id is not a valid tenant id.",
kid: claims.kid,
tid,
agent
};
}
if (optRequiredScopes && optRequiredScopes.length > 0) {
const granted = ownScopesClaim(claims) ?? [];
const satisfies = (required) => granted.some((g) => {
if (g === "*")
return true;
const gi = g.indexOf(":");
const ri = required.indexOf(":");
if (gi < 0 || ri < 0)
return false;
const gApp = g.slice(0, gi);
const gAction = g.slice(gi + 1);
const rApp = required.slice(0, ri);
const rAction = required.slice(ri + 1);
return (gApp === "*" || gApp === rApp) && (gAction === "*" || gAction === rAction);
});
for (const required of optRequiredScopes) {
if (!satisfies(required)) {
return { ok: false, reason: "insufficient_scope", message: `Missing required scope '${required}'.`, agent };
}
}
}
return { ok: true, claims, kid: claims.kid, app, tid, agent };
}
var DEFAULT_API_KEYS_TABLE = "api_keys";
var API_KEY_ISSUANCE_PENDING_REASON = "credential_delivery_pending";
function createTableSql(table) {
return `CREATE TABLE IF NOT EXISTS ${table} (
kid TEXT PRIMARY KEY,
app TEXT NOT NULL,
agent TEXT,
scopes JSONB NOT NULL,
token_hash TEXT NOT NULL UNIQUE,
issued_at TIMESTAMPTZ NOT NULL,
expires_at TIMESTAMPTZ,
revoked_at TIMESTAMPTZ,
revoked_reason TEXT,
last_used_at TIMESTAMPTZ,
created_by TEXT,
created_at TIMESTAMPTZ NOT NULL DEFAULT now()
)`;
}
function apiKeyMigrations(table = DEFAULT_API_KEYS_TABLE) {
return [
{ id: `hasna_auth_0001_${table}`, sql: createTableSql(table) },
{
id: `hasna_auth_0002_${table}_indexes`,
sql: `CREATE INDEX IF NOT EXISTS ${table}_app_idx ON ${table} (app);
CREATE INDEX IF NOT EXISTS ${table}_token_hash_idx ON ${table} (token_hash);`
},
{
id: `hasna_auth_0003_${table}_tenant`,
sql: `ALTER TABLE ${table} ADD COLUMN IF NOT EXISTS tid TEXT;
CREATE INDEX IF NOT EXISTS ${table}_tid_idx ON ${table} (tid);`
}
];
}
function toIso(value) {
if (value === null || value === undefined)
return null;
if (value instanceof Date)
return value.toISOString();
return new Date(String(value)).toISOString();
}
function parseScopes(value) {
if (Array.isArray(value))
return value.map((v) => String(v));
if (typeof value === "string") {
try {
const parsed = JSON.parse(value);
return Array.isArray(parsed) ? parsed.map((v) => String(v)) : [];
} catch {
return [];
}
}
return [];
}
function rowToRecord(row) {
const tid = ownTenantId(row);
const agentValue = Object.hasOwn(row, "agent") ? row.agent : null;
return {
kid: String(row.kid),
app: String(row.app),
agent: agentValue === null || agentValue === undefined ? null : String(agentValue),
tid: tid === null || tid === undefined ? null : String(tid),
scopes: parseScopes(row.scopes),
tokenHash: String(row.token_hash),
issuedAt: toIso(row.issued_at) ?? new Date(0).toISOString(),
expiresAt: toIso(row.expires_at),
revokedAt: toIso(row.revoked_at),
revokedReason: row.revoked_reason === null || row.revoked_reason === undefined ? null : String(row.revoked_reason),
lastUsedAt: toIso(row.last_used_at),
createdBy: row.created_by === null || row.created_by === undefined ? null : String(row.created_by)
};
}
class ApiKeyStore {
client;
table;
constructor(client, options = {}) {
this.client = client;
this.table = options.table ?? DEFAULT_API_KEYS_TABLE;
if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(this.table)) {
throw new Error(`Invalid api-keys table name '${this.table}'.`);
}
}
migrations() {
return apiKeyMigrations(this.table);
}
async ensureSchema() {
for (const migration of this.migrations()) {
await this.client.execute(migration.sql);
}
}
async insert(input) {
await this.insertWithLifecycle(input, null, null);
}
async insertWithLifecycle(input, revokedAt, revokedReason) {
const tid = ownTenantId(input);
const agent = ownAgentClaim(input);
await this.client.execute(`INSERT INTO ${this.table}
(kid, app, agent, tid, scopes, token_hash, issued_at, expires_at, created_by, revoked_at, revoked_reason)
VALUES ($1, $2, $3, $4, $5::jsonb, $6, $7, $8, $9, $10, $11)`, [
input.kid,
input.app,
agent,
tid === undefined || tid === null ? null : normalizeTenantId(tid),
JSON.stringify(input.scopes),
input.tokenHash,
input.issuedAt.toISOString(),
input.expiresAt ? input.expiresAt.toISOString() : null,
input.createdBy ?? null,
revokedAt,
revokedReason
]);
}
mintedInput(minted, createdBy) {
const claims = minted.claims;
return {
kid: minted.kid,
app: claims.app,
agent: ownAgentClaim(claims),
tid: ownTenantId(claims) ?? null,
scopes: claims.scopes,
tokenHash: minted.tokenHash,
issuedAt: new Date(claims.iat * 1000),
expiresAt: claims.exp === null ? null : new Date(claims.exp * 1000),
createdBy: createdBy ?? null
};
}
async insertMinted(minted, createdBy) {
await this.insert(this.mintedInput(minted, createdBy));
}
async insertMintedPending(minted, createdBy, atMs = Date.now()) {
await this.insertWithLifecycle(this.mintedInput(minted, createdBy), new Date(atMs).toISOString(), API_KEY_ISSUANCE_PENDING_REASON);
}
async activatePending(kid, tokenHash) {
const row = await this.client.get(`UPDATE ${this.table}
SET revoked_at = NULL, revoked_reason = NULL
WHERE kid = $1
AND revoked_at IS NOT NULL
AND revoked_reason = $2
AND token_hash = $3
RETURNING kid`, [kid, API_KEY_ISSUANCE_PENDING_REASON, tokenHash]);
if (row)
return true;
const active = await this.client.get(`SELECT kid FROM ${this.table}
WHERE kid = $1
AND token_hash = $2
AND revoked_at IS NULL
AND revoked_reason IS NULL`, [kid, tokenHash]);
return active !== null;
}
async findByKid(kid) {
const row = await this.client.get(`SELECT * FROM ${this.table} WHERE kid = $1`, [kid]);
return row ? rowToRecord(row) : null;
}
async findByTokenHash(tokenHash) {
const row = await this.client.get(`SELECT * FROM ${this.table} WHERE token_hash = $1`, [tokenHash]);
return row ? rowToRecord(row) : null;
}
isRevoked = async (kid) => {
const row = await this.client.get(`SELECT revoked_at FROM ${this.table} WHERE kid = $1`, [kid]);
if (!row)
return false;
return row.revoked_at !== null && row.revoked_at !== undefined;
};
async status(kid, nowMs = Date.now()) {
const record = await this.findByKid(kid);
if (!record)
return "unknown";
if (record.revokedAt)
return "revoked";
if (record.expiresAt && new Date(record.expiresAt).getTime() <= nowMs)
return "expired";
return "active";
}
keyStatus = async (kid) => {
return this.status(kid);
};
statusChecker() {
return async (kid) => {
const status = await this.status(kid);
return status !== "active";
};
}
async revoke(kid, reason, atMs = Date.now(), options = {}) {
const params = [kid, new Date(atMs).toISOString(), reason ?? null];
let scope = "";
if (options.app !== undefined) {
params.push(options.app);
scope = ` AND app = $${params.length}`;
}
const row = await this.client.get(`UPDATE ${this.table}
SET revoked_at = COALESCE(revoked_at, $2), revoked_reason = COALESCE(revoked_reason, $3)
WHERE kid = $1${scope}
RETURNING kid`, params);
return row !== null;
}
async touchLastUsed(kid, atMs = Date.now()) {
await this.client.execute(`UPDATE ${this.table} SET last_used_at = $2 WHERE kid = $1`, [
kid,
new Date(atMs).toISOString()
]);
}
async list(options = {}) {
const clauses = [];
const params = [];
if (options.app) {
params.push(options.app);
clauses.push(`app = $${params.length}`);
}
const tid = ownTenantId(options);
if (tid !== undefined) {
params.push(normalizeTenantId(tid));
clauses.push(`tid = $${params.length}`);
}
if (!options.includeRevoked) {
clauses.push("revoked_at IS NULL");
}
const where = clauses.length > 0 ? `WHERE ${clauses.join(" AND ")}` : "";
const rows = await this.client.many(`SELECT * FROM ${this.table} ${where} ORDER BY issued_at DESC`, params);
return rows.map(rowToRecord);
}
async revokedKids() {
const rows = await this.client.many(`SELECT kid FROM ${this.table} WHERE revoked_at IS NOT NULL`);
return rows.map((row) => String(row.kid));
}
}
function readHeader(source, name) {
const lower = name.toLowerCase();
if (typeof source === "function") {
return source(name) ?? source(lower) ?? null;
}
if (typeof Headers !== "undefined" && source instanceof Headers) {
return source.get(name);
}
const record = source;
const value = record[name] ?? record[lower] ?? record[name.toUpperCase()];
if (Array.isArray(value))
return value[0] ?? null;
return value ?? null;
}
function extractToken(source, headerName = "x-api-key", scheme = "Bearer") {
const direct = readHeader(source, headerName);
if (direct && direct.trim().length > 0)
return direct.trim();
const authz = readHeader(source, "authorization");
if (authz) {
const prefix = `${scheme} `;
if (authz.toLowerCase().startsWith(prefix.toLowerCase())) {
const token = authz.slice(prefix.length).trim();
if (token.length > 0)
return token;
}
}
return null;
}
function ownOption2(bag, name) {
return Object.hasOwn(bag, name) ? bag[name] : undefined;
}
function verifyApiKey(options) {
const optionApp = ownOption2(options, "app");
const optionSigningSecret = ownOption2(options, "signingSecret");
const optionExpectedTid = ownOption2(options, "expectedTid");
const optionRequiredScopes = ownOption2(options, "requiredScopes");
const optionRequireTenant = ownOption2(options, "requireTenant");
const optionLeewaySeconds = ownOption2(options, "leewaySeconds");
const audit = ownOption2(options, "audit");
const headerName = ownOption2(options, "headerName") ?? "x-api-key";
const scheme = ownOption2(options, "scheme") ?? "Bearer";
const clock = ownOption2(options, "nowMs") ?? (() => Date.now());
if (!optionApp)
throw new Error("verifyApiKey requires an 'app' slug.");
if (!optionSigningSecret) {
throw new Error("verifyApiKey requires a 'signingSecret'. Set it from HASNA_<APP>_API_SIGNING_KEY.");
}
if (optionExpectedTid !== undefined && !isValidTenantId(optionExpectedTid)) {
throw new Error(`verifyApiKey received an invalid 'expectedTid': '${optionExpectedTid}'.`);
}
const app = optionApp;
const signingSecret = optionSigningSecret;
const ownKeyStatus = ownOption2(options, "keyStatus");
const ownIsRevoked = ownOption2(options, "isRevoked");
const allowUnregistered = ownOption2(options, "allowUnregisteredKeys") === true;
if (ownKeyStatus && ownIsRevoked) {
throw new Error("verifyApiKey received both 'keyStatus' and 'isRevoked'. Supply exactly one \u2014 " + "letting one silently win would hide which check is actually guarding the service. " + "Use 'keyStatus' (store.keyStatus); drop 'isRevoked'.");
}
if (!ownKeyStatus && !allowUnregistered) {
throw new Error(ownIsRevoked ? "verifyApiKey was given only 'isRevoked', which cannot refuse a key this service has " + "no record of: it returns false both for an active key and for one that was never " + "registered, so an unregistered key is irrevocable. Wire 'keyStatus: store.keyStatus' " + "(or 'isRevoked: store.statusChecker()'), or set 'allowUnregisteredKeys: true' to " + "accept that risk explicitly." : "verifyApiKey requires a key-status hook. Without one this service performs NO " + "revocation check and cannot turn any of its keys off. Wire " + "'keyStatus: store.keyStatus', or set 'allowUnregisteredKeys: true' to declare that " + "this service intentionally cannot revoke keys.");
}
async function emit(event) {
if (!audit)
return;
try {
await audit(event);
} catch {}
}
async function authenticate(headers, context = {}) {
const method = ownOption2(context, "method") ?? null;
const path = ownOption2(context, "path") ?? null;
const requiredScopes = [
...optionRequiredScopes ?? [],
...ownOption2(context, "requiredScopes") ?? []
];
const at = new Date(clock()).toISOString();
const perCallTid = ownOption2(context, "expectedTid");
const expectedTid = perCallTid !== undefined ? perCallTid : optionExpectedTid;
if (perCallTid !== undefined && optionExpectedTid !== undefined && !tenantIdsEqual(perCallTid, optionExpectedTid)) {
await emit({ outcome: "deny", app, kid: null, tid: null, reason: "tenant_mismatch", scopesRequired: requiredScopes, method, path, status: 403, at });
return {
ok: false,
status: 403,
reason: "tenant_mismatch",
message: "This route addresses a tenant other than the one this service is pinned to."
};
}
const token = extractToken(headers, headerName, scheme);
if (!token) {
const decision = {
ok: false,
status: 401,
reason: "missing_token",
message: `Missing API key. Send it as '${headerName}: <key>' or 'Authorization: ${scheme} <key>'.`
};
await emit({ outcome: "deny", app, kid: null, tid: null, reason: "missing_token", scopesRequired: requiredScopes, method, path, status: 401, at });
return decision;
}
const verified = verifyApiKeyToken(token, {
signingSecret,
expectedApp: app,
nowMs: clock(),
...optionLeewaySeconds !== undefined ? { leewaySeconds: optionLeewaySeconds } : {},
...optionRequireTenant !== undefined ? { requireTenant: optionRequireTenant } : {},
...expectedTid !== undefined ? { expectedTid } : {},
requiredScopes
});
if (!verified.ok) {
const status = verified.reason === "insufficient_scope" || verified.reason === "tenant_mismatch" || verified.reason === "tenant_required" ? 403 : 401;
await emit({
outcome: "deny",
app,
kid: ownOption2(verified, "kid") ?? null,
tid: ownTenantId(verified) ?? null,
...Object.hasOwn(verified, "agent") ? { agent: verified.agent } : {},
reason: verified.reason,
scopesRequired: requiredScopes,
method,
path,
status,
at
});
return { ok: false, status, reason: verified.reason, message: verified.message };
}
if (ownKeyStatus) {
let status;
try {
status = await ownKeyStatus(verified.kid);
} catch {
await emit({ outcome: "deny", app, kid: verified.kid, tid: verified.tid, agent: verified.agent, reason: "status_unavailable", scopesRequired: requiredScopes, method, path, status: 503, at });
return {
ok: false,
status: 503,
reason: "status_unavailable",
message: "Could not verify API key status. Try again shortly."
};
}
if (status !== "active") {
const known = status === "revoked" || status === "expired" || status === "unknown";
if (!(status === "unknown" && allowUnregistered)) {
const reason = status === "revoked" || status === "expired" ? status : "unknown_key";
const message = reason === "unknown_key" ? known ? "API key is not registered with this service." : "API key status could not be recognized." : status === "expired" ? "API key has expired." : "API key has been revoked.";
await emit({ outcome: "deny", app, kid: verified.kid, tid: verified.tid, agent: verified.agent, reason, scopesRequired: requiredScopes, method, path, status: 401, at });
return { ok: false, status: 401, reason, message };
}
}
} else if (ownIsRevoked) {
let revoked;
try {
revoked = await ownIsRevoked(verified.kid);
} catch {
await emit({ outcome: "deny", app, kid: verified.kid, tid: verified.tid, agent: verified.agent, reason: "status_unavailable", scopesRequired: requiredScopes, method, path, status: 503, at });
return {
ok: false,
status: 503,
reason: "status_unavailable",
message: "Could not verify API key status. Try again shortly."
};
}
if (revoked) {
await emit({ outcome: "deny", app, kid: verified.kid, tid: verified.tid, agent: verified.agent, reason: "revoked", scopesRequired: requiredScopes, method, path, status: 401, at });
return { ok: false, status: 401, reason: "revoked", message: "API key has been revoked." };
}
}
const principal = {
kid: verified.kid,
app: verified.app,
scopes: verified.claims.scopes,
agent: verified.agent,
tid: verified.tid,
claims: verified.claims
};
await emit({ outcome: "allow", app, kid: verified.kid, tid: verified.tid, agent: verified.agent, reason: null, scopesRequired: requiredScopes, method, path, status: 200, at });
return { ok: true, status: 200, principal };
}
return { authenticate, app };
}
var MAX_FLEET_TOKEN_TTL_SECONDS = 24 * 60 * 60;
// src/generated/storage-kit/own.ts
function ownProp(source, key) {
if (source === null || source === undefined)
return;
const kind = typeof source;
if (kind !== "object" && kind !== "function")
return;
if (!Object.hasOwn(source, key))
return;
return source[key];
}
function ownString(source, key) {
const value = ownProp(source, key);
return typeof value === "string" ? value : undefined;
}
// src/generated/storage-kit/backend.ts
function envToken(name) {
return name.toUpperCase().replace(/-/g, "_");
}
function serverDataBackendEnvKeys(name) {
const token = envToken(name);
return {
databaseUrlKeys: [`HASNA_${token}_DATABASE_URL`, `${token}_DATABASE_URL`]
};
}
function definedDatabaseUrlEntries(env, keys) {
return keys.map((key) => ({ key, value: ownString(env, key) })).filter((entry) => entry.value !== undefined);
}
function assertPostgresqlDatabaseUrl(name, entries) {
const canonicalKey = serverDataBackendEnvKeys(name).databaseUrlKeys[0];
if (entries.length === 0) {
throw new Error(`${canonicalKey} is required; servers use PostgreSQL and never default to SQLite.`);
}
const blank = entries.filter((entry) => entry.value.trim().length === 0);
if (blank.length > 0) {
throw new Error(`${blank.map((entry) => entry.key).join(" and ")} is set but blank; a PostgreSQL database URL is required.`);
}
const controlled = entries.find((entry) => /[\u0000-\u001f\u007f]/.test(entry.value));
if (controlled)
throw new Error(`${controlled.key} must not contain ASCII control characters.`);
const normalized = entries.map((entry) => ({ key: entry.key, value: entry.value.trim() }));
if (normalized.length > 1 && new Set(normalized.map((entry) => entry.value)).size > 1) {
throw new Error(`${normalized.map((entry) => entry.key).join(" and ")} disagree; database URL aliases must be identical or only one may be set.`);
}
const selected = normalized[0];
let parsed;
try {
parsed = new URL(selected.value);
} catch {
throw new Error(`${selected.key} must be an absolute PostgreSQL connection URL.`);
}
if (parsed.protocol !== "postgres:" && parsed.protocol !== "postgresql:") {
throw new Error(`${selected.key} must use the postgres or postgresql scheme.`);
}
if (!parsed.hostname || parsed.pathname.length <= 1) {
throw new Error(`${selected.key} must name a PostgreSQL host and database.`);
}
return selected;
}
function resolveServerDataBackend(name, env = process.env) {
const keys = serverDataBackendEnvKeys(name).databaseUrlKeys;
const databaseUrl = assertPostgresqlDatabaseUrl(name, definedDatabaseUrlEntries(env, keys));
return {
backend: "postgresql",
source: databaseUrl.key,
databaseUrlPresent: true,
databaseUrlSource: databaseUrl.key
};
}
function resolveDatabaseUrl(name, env = process.env) {
const keys = serverDataBackendEnvKeys(name).databaseUrlKeys;
return assertPostgresqlDatabaseUrl(name, definedDatabaseUrlEntries(env, keys)).value;
}
// src/generated/storage-kit/tls.ts
import { readFileSync } from "fs";
var PG_TLS_QUERY_PARAMETERS = new Set([
"ssl",
"sslmode",
"sslrootcert",
"sslcert",
"sslkey",
"sslpassword",
"sslnegotiation",
"uselibpqcompat"
]);
var EXPLICIT_SSL_ON_VALUES = new Set(["1", "true", "yes", "on", "require"]);
var EXPLICIT_SSL_OFF_VALUES = new Set(["0", "false", "no", "off", "disable"]);
var SSLMODE_VALUES = new Map([
["disable", "disable"],
["allow", "prefer"],
["prefer", "prefer"],
["require", "require"],
["verify-ca", "verify-ca"],
["verify-full", "verify-full"]
]);
function connectionStringParts(connectionString) {
const queryStart = connectionString.indexOf("?");
if (queryStart === -1) {
return { base: connectionString, fragment: "", params: new URLSearchParams };
}
const base = connectionString.slice(0, queryStart);
const queryAndFragment = connectionString.slice(queryStart + 1);
const fragmentStart = queryAndFragment.indexOf("#");
const query = fragmentStart === -1 ? queryAndFragment : queryAndFragment.slice(0, fragmentStart);
const fragment = fragmentStart === -1 ? "" : queryAndFragment.slice(fragmentStart);
return { base, fragment, params: new URLSearchParams(query) };
}
function tlsQueryValues(connectionString) {
const values = new Map;
for (const [key, value] of connectionStringParts(connectionString).params) {
const normalized = key.toLowerCase();
if (PG_TLS_QUERY_PARAMETERS.has(normalized))
values.set(normalized, value);
}
return values;
}
function connectionStringWithoutTlsParameters(connectionString) {
const { base, fragment, params } = connectionStringParts(connectionString);
for (const key of [...params.keys()]) {
if (PG_TLS_QUERY_PARAMETERS.has(key.toLowerCase()))
params.delete(key);
}
const query = params.toString();
return `${base}${query ? `?${query}` : ""}${fragment}`;
}
function rawSslMode(values) {
const raw = values.get("sslmode");
return raw === undefined ? undefined : raw.trim().toLowerCase();
}
function sslNegotiationFromConnectionString(connectionString) {
const value = tlsQueryValues(connectionString).get("sslnegotiation")?.trim().toLowerCase();
if (!value)
return;
if (value === "postgres" || value === "direct")
return value;
throw new Error(`Unknown sslnegotiation '${value}' in connection string; expected postgres or direct.`);
}
function sslModeFromConnectionString(connectionString) {
const values = tlsQueryValues(connectionString);
const sslmode = rawSslMode(values);
if (sslmode !== undefined) {
const resolved = SSLMODE_VALUES.get(sslmode);
if (resolved)
return resolved;
throw new Error(`Unknown sslmode '${sslmode}' in connection string; expected one of ` + `${[...SSLMODE_VALUES.keys()].join(", ")}. Remove the parameter entirely to defer to ` + `PGSSLMODE \u2014 an empty value is not how that is spelled.`);
}
if (values.has("ssl")) {
const ssl = values.get("ssl")?.trim().toLowerCase() ?? "";
if (EXPLICIT_SSL_ON_VALUES.has(ssl))
return "require";
if (!EXPLICIT_SSL_OFF_VALUES.has(ssl)) {
throw new Error(`Unknown ssl value '${ssl}' in connection string.`);
}
return "disable";
}
const sslnegotiation = values.get("sslnegotiation")?.trim().toLowerCase();
if (sslnegotiation === "direct")
return "require";
return "disable";
}
function loadCaBundle(connectionString, options) {
const env = ownProp(options, "env") ?? process.env;
const ca = ownString(options, "ca");
if (ca && ca.trim())
return ca;
const sslRootCert = tlsQueryValues(connectionString).get("sslrootcert")?.trim();
const path = ownString(options, "caCertPath") ?? (sslRootCert ? sslRootCert : undefined) ?? ownString(env, "PGSSLROOTCERT") ?? ownString(env, "NODE_EXTRA_CA_CERTS");
if (path && path.trim())
return readFileSync(path.trim(), "utf8");
return null;
}
function loadClientCertificate(connectionString) {
const values = tlsQueryValues(connectionString);
const material = {};
const certPath = values.get("sslcert")?.trim();
if (certPath)
material.cert = readFileSync(certPath, "utf8");
const keyPath = values.get("sslkey")?.trim();
if (keyPath)
material.key = readFileSync(keyPath, "utf8");
const passphrase = values.get("sslpassword");
if (passphrase)
material.passphrase = passphrase;
return material;
}
function resolveTlsConfig(connectionString, options = {}) {
const mode = sslModeFromConnectionString(connectionString);
if (mode === "disable") {
const values = tlsQueryValues(connectionString);
const sslmode = rawSslMode(values);
const ssl = values.get("ssl")?.trim().toLowerCase();
const explicitlyOff = sslmode === "disable" || ssl !== undefined && EXPLICIT_SSL_OFF_VALUES.has(ssl);
return explicitlyOff ? false : undefined;
}
const ca = loadCaBundle(connectionString, options);
const clientCertificate = loadClientCertificate(connectionString);
if (mode === "prefer" || mode === "require") {
return { rejectUnauthorized: true, ...ca ? { ca } : {}, ...clientCertificate };
}
if (!ca) {
throw new Error(`sslmode=${mode} requires a CA bundle. Set PGSSLROOTCERT (or pass caCertPath/ca) to the ` + `Amazon RDS global bundle: https://truststore.pki.rds.amazonaws.com/global/global-bundle.pem`);
}
return { rejectUnauthorized: true, ca, ...clientCertificate };
}
// src/generated/storage-kit/query.ts
function wrapExecutor(executor) {
return {
async query(sql, params) {
const result = await executor.query(sql, params);
return { rows: result.rows, rowCount: result.rowCount ?? result.rows.length };
},
async many(sql, params) {
const result = await executor.query(sql, params);
return result.rows;
},
async get(sql, params) {
const result = await executor.query(sql, params);
return result.rows[0] ?? null;
},
async one(sql, params) {
const result = await executor.query(sql, params);
if (result.rows.length !== 1) {
throw new Error(`Expected exactly one row, got ${result.rows.length}.`);
}
return result.rows[0];
},
async execute(sql, params) {
await executor.query(sql, params);
}
};
}
function createQueryClient(pool) {
const base = wrapExecutor(pool);
return {
...base,
pool,
async transaction(fn) {
const client = await pool.connect();
try {
await client.query("BEGIN");
const result = await fn(wrapExecutor(client));
await client.query("COMMIT");
return result;
} catch (error) {
try {
await client.query("ROLLBACK");
} catch {}
throw error;
} finally {
client.release();
}
},
async close() {
await pool.end();
}
};
}
// src/generated/storage-kit/pool.ts
import pg from "pg";
function ownPoolOptions(options) {
const own = Object.create(null);
const ca = ownString(options, "ca");
if (ca !== undefined)
own.ca = ca;
const caCertPath = ownString(options, "caCertPath");
if (caCertPath !== undefined)
own.caCertPath = caCertPath;
const env = ownProp(options, "env");
if (env !== undefined)
own.env = env;
const max = ownProp(options, "max");
if (max !== undefined)
own.max = max;
const idleTimeoutMillis = ownProp(options, "idleTimeoutMillis");
if (idleTimeoutMillis !== undefined)
own.idleTimeoutMillis = idleTimeoutMillis;
const connectionTimeoutMillis = ownProp(options, "connectionTimeoutMillis");
if (connectionTimeoutMillis !== undefined)
own.connectionTimeoutMillis = connectionTimeoutMillis;
const applicationName = ownString(options, "applicationName");
if (applicationName !== undefined)
own.applicationName = applicationName;
return own;
}
function createPgPool(options) {
const connectionString = ownString(options, "connectionString");
if (!connectionString || !connectionString.trim()) {
throw new Error("createPgPool requires an own `connectionString` on the options object.");
}
const own = ownPoolOptions(options);
const ssl = resolveTlsConfig(connectionString, {
...own.ca !== undefined ? { ca: own.ca } : {},
...own.caCertPath !== undefined ? { caCertPath: own.caCertPath } : {},
...own.env !== undefined ? { env: own.env } : {}
});
const config = {
connectionString: connectionStringWithoutTlsParameters(connectionString)
};
if (ssl !== undefined)
config.ssl = ssl;
const sslnegotiation = sslNegotiationFromConnectionString(connectionString);
if (sslnegotiation !== undefined)
config.sslnegotiation = sslnegotiation;
if (own.max !== undefined)
config.max = own.max;
if (own.idleTimeoutMillis !== undefined)
config.idleTimeoutMillis = own.idleTimeoutMillis;
if (own.connectionTimeoutMillis !== undefined)
config.connectionTimeoutMillis = own.connectionTimeoutMillis;
if (own.applicationName !== undefined)
config.application_name = own.applicationName;
return new pg.Pool(config);
}
function createServerPoolFromEnv(appName, options = {}) {
const own = ownPoolOptions(options);
const env = own.env ?? process.env;
const resolution = resolveServerDataBackend(appName, env);
const connectionString = resolveDatabaseUrl(appName, env);
const pool = createPgPool({
...own,
connectionString,
env
});
return {
client: createQueryClient(pool),
connectionSource: resolution.databaseUrlSource
};
}
// src/generated/storage-kit/migrations.ts
import { createHash as createHash2 } from "crypto";
function checksumSql(sql) {
const normalized = sql.trim().replace(/\r\n/g, `
`);
return `sha256:${createHash2("sha256").update(normalized).digest("hex")}`;
}
function defineMigration(id, sql) {
return Object.freeze({ id, sql: sql.trim(), checksum: checksumSql(sql) });
}
// src/generated/storage-kit/health.ts
async function checkHealth(client) {
const start = Date.now();
try {
await client.get("SELECT 1 AS ok");
return { ok: true, latencyMs: Date.now() - start };
} catch (error) {
return {
ok: false,
latencyMs: Date.now() - start,
error: error instanceof Error ? error.message : String(error)
};
}
}
// src/lib/version.ts
import { readFileSync as readFileSync2 } from "fs";
import { dirname, resolve } from "path";
import { fileURLToPath } from "url";
var cachedVersion = null;
function getPackageVersion() {
if (cachedVersion)
return cachedVersion;
try {
const moduleDir = dirname(fileURLToPath(import.meta.url));
const packageJsonPath = resolve(moduleDir, "../../package.json");
const pkg = JSON.parse(readFileSync2(packageJsonPath, "utf8"));
cachedVersion = pkg.version ?? "0.0.0";
} catch {
cachedVersion = "0.0.0";
}
return cachedVersion;
}
var USER_AGENT = `open-domains/${getPackageVersion()}`;
// 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/domain-owners.ts
var DOMAIN_OWNER_SOURCES = ["whois", "manual", "brandsight", "import"];
// src/db/domain-history.ts
var HISTORY_TYPES = [
"whois",
"rdap",
"dns",
"ssl",
"reputation",
"exa_research",
"purchase",
"renewal"
];
// src/server/repo.ts
function parseJson(value, fallback) {
if (value === null || value === undefined)
return fallback;
try {
return JSON.parse(value);
} catch {
return fallback;
}
}
function rowToDomain(row) {
return {
id: row.id,
name: row.name,
registrar: row.registrar,
status: row.status,
registered_at: row.registered_at,
expires_at: row.expires_at,
auto_renew: Boolean(row.auto_renew),
is_premium: Boolean(row.is_premium),
premium_price: row.premium_price,
standard_price: row.standard_price,
purchase_price: row.purchase_price,
purchase_date: row.purchase_date,
nameservers: parseJson(row.nameservers, []),
whois: parseJson(row.whois, {}),
ssl_expires_at: row.ssl_expires_at,
ssl_issuer: row.ssl_issuer,
notes: row.notes,
metadata: parseJson(row.metadata, {}),
created_at: row.created_at,
updated_at: row.updated_at,
expiry_synced_at: row.expiry_synced_at ?? null
};
}
function rowToDnsRecord(row) {
return {
id: row.id,
domain_id: row.domain_id,
type: row.type,
name: row.name,
value: row.value,
ttl: row.ttl,
priority: row.priority,
created_at: row.created_at
};
}
class HttpError extends Error {
status;
constructor(status, message) {
super(message);
this.status = status;
this.name = "HttpError";
}
}
var DNS_TYPES = ["A", "AAAA", "CNAME", "MX", "TXT", "NS", "SRV"];
class DomainsRepo {
db;
constructor(db) {
this.db = db;
}
async createDomain(input) {
if (!input || typeof input.name !== "string" || input.name.trim() === "") {
throw new HttpError(400, "domain 'name' is required");
}
const status = input.status ?? "active";
if (!DOMAIN_STATUSES.includes(status)) {
throw new HttpError(400, `invalid status '${status}'`);
}
const id = crypto.randomUUID();
const nowIso = new Date().toISOString();
try {
const row = await this.db.get(`INSERT INTO domains (
id, name, registrar, status, registered_at, expires_at, auto_renew,
is_premium, premium_price, standard_price, purchase_price, purchase_date,
nameservers, whois, ssl_expires_at, ssl_issuer, notes, metadata,
created_at, updated_at, expiry_synced_at
) VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,$16,$17,$18,$19,$20,$21)
RETURNING *`, [
id,
input.name.trim(),
input.registrar ?? null,
status,
input.registered_at ?? null,
input.expires_at ?? null,
input.auto_renew !== undefined ? input.auto_renew : true,
input.is_premium ?? false,
input.premium_price ?? null,
input.standard_price ?? null,
input.purchase_price ?? null,
input.purchase_date ?? null,
JSON.stringify(input.nameservers ?? []),
JSON.stringify(input.whois ?? {}),
input.ssl_expires_at ?? null,
input.ssl_issuer ?? null,
input.notes ?? null,
JSON.stringify(input.metadata ?? {}),
nowIso,
nowIso,
input.expiry_synced_at ?? null
]);
return rowToDomain(row);
} catch (e) {
const msg = e instanceof Error ? e.message : String(e);
if (/duplicate key|unique constraint/i.test(msg)) {
throw new HttpError(409, `domain '${input.name}' already exists`);
}
throw e;
}
}
async getDomain(id) {
const row = await this.db.get("SELECT * FROM domains WHERE id = $1", [id]);
return row ? rowToDomain(row) : null;
}
async getDomainByName(name) {
const row = await this.db.get("SELECT * FROM domains WHERE name = $1", [name]);
return row ? rowToDomain(row) : null;
}
async listDomains(opts) {
const clauses = [];
const params = [];
if (opts.search) {
params.push(`%${opts.search}%`);
clauses.push(`name ILIKE $${params.length}`);
}
if (opts.status) {
if (!DOMAIN_STATUSES.includes(opts.status)) {
throw new HttpError(400, `invalid status filter '${opts.status}'`);
}
params.push(opts.status);
clauses.push(`status = $${params.length}`);
}
const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
const limit = Math.min(Math.max(opts.limit ?? 100, 1), 1000);
const offset = Math.max(opts.offset ?? 0, 0);
params.push(limit, offset);
const rows = await this.db.many(`SELECT * FROM domains ${where} ORDER BY name ASC LIMIT $${params.length - 1} OFFSET $${params.length}`, params);
return rows.map(rowToDomain);
}
async updateDomain(id, patch) {
const existing = await this.getDomain(id);
if (!existing)
return null;
const sets = [];
const params = [];
const setCol = (col, val) => {
params.push(val);
sets.push(`${col} = $${params.length}`);
};
const p = patch;
if ("name" in p)
setCol("name", p["name"]);
if ("registrar" in p)
setCol("registrar", p["registrar"] ?? null);
if ("status" in p) {
if (!DOMAIN_STATUSES.includes(p["status"])) {
throw new HttpError(400, `invalid status '${String(p["status"])}'`);
}
setCol("status", p["status"]);
}
if ("registered_at" in p)
setCol("registered_at", p["registered_at"] ?? null);
if ("expires_at" in p)
setCol("expires_at", p["expires_at"] ?? null);
if ("auto_renew" in p)
setCol("auto_renew", Boolean(p["auto_renew"]));
if ("is_premium" in p)
setCol("is_premium", Boolean(p["is_premium"]));
if ("premium_price" in p)
setCol("premium_price", p["premium_price"] ?? null);
if ("standard_price" in p)
setCol("standard_price", p["standard_price"] ?? null);
if ("purchase_price" in p)
setCol("purchase_price", p["purchase_price"] ?? null);
if ("purchase_date" in p)
setCol("purchase_date", p["purchase_date"] ?? null);
if ("nameservers" in p)
setCol("nameservers", JSON.stringify(p["nameservers"] ?? []));
if ("whois" in p)
setCol("whois", JSON.stringify(p["whois"] ?? {}));
if ("ssl_expires_at" in p)
setCol("ssl_expires_at", p["ssl_expires_at"] ?? null);
if ("ssl_issuer" in p)
setCol("ssl_issuer", p["ssl_issuer"] ?? null);
if ("notes" in p)
setCol("notes", p["notes"] ?? null);
if ("metadata" in p)
setCol("metadata", JSON.stringify(p["metadata"] ?? {}));
if ("expiry_synced_at" in p)
setCol("expiry_synced_at", p["expiry_synced_at"] ?? null);
if (sets.length === 0)
return existing;
setCol("updated_at", new Date().toISOString());
params.push(id);
const row = await this.db.get(`UPDATE domains SET ${sets.join(", ")} WHERE id = $${params.length} RETURNING *`, params);
return row ? rowToDomain(row) : null;
}
async deleteDomain(id) {
const result = await this.db.query("DELETE FROM domains WHERE id = $1", [id]);
return result.rowCount > 0;
}
async countDomains() {
const row = await this.db.get("SELECT count(*)::text AS n FROM domains");
return row ? parseInt(row.n, 10) : 0;
}
async getStats() {
const row = await this.db.get(`SELECT
count(*)::text AS total,
count(*) FILTER (WHERE status = 'active')::text AS active,
count(*) FILTER (WHERE status = 'expired')::text AS expired,
count(*) FILTER (WHERE status = 'transferring')::text AS transferring,
count(*) FILTER (WHERE status = 'redemption')::text AS redemption,
count(*) FILTER (WHERE auto_renew = true)::text AS auto_renew_enabled,
count(*) FILTER (
WHERE NULLIF(expires_at, '')::timestamptz
BETWEEN now() AND now() + interval '30 days'
)::text AS expiring_30_days,
count(*) FILTER (
WHERE NULLIF(ssl_expires_at, '')::timestamptz
BETWEEN now() AND now() + interval '30 days'
)::text AS ssl_expiring_30_days,
count(*) FILTER (
WHERE status = 'active'
AND NULLIF(expires_at, '')::timestamptz < now()
)::text AS past_expiry,
count(*) FILTER (
WHERE NULLIF(ssl_expires_at, '')::timestamptz < now()
)::text AS ssl_past_expiry,
count(*) FILTER (WHERE expiry_synced_at IS NULL)::text AS never_synced
FROM domains`);
const n = (k) => row && row[k] ? parseInt(row[k], 10) : 0;
return {
total: n("total"),
active: n("active"),
expired: n("expired"),
transferring: n("transferring"),
redemption: n("redemption"),
auto_renew_enabled: n("auto_renew_enabled"),
expiring_30_days: n("expiring_30_days"),
ssl_expiring_30_days: n("ssl_expiring_30_days"),
past_expiry: n("past_expiry"),
ssl_past_expiry: n("ssl_past_expiry"),
never_synced: n("never_synced")
};
}
async listDnsRecords(domainId) {
const rows = await this.db.many("SELECT * FROM dns_records WHERE domain_id = $1 ORDER BY type, name", [domainId]);
return rows.map(rowToDnsRecord);
}
async createDnsRecord(domainId, input) {
if (!input || typeof input.type !== "string" || !DNS_TYPES.includes(input.type)) {
throw new HttpError(400, `dns record 'type' must be one of ${DNS_TYPES.join(", ")}`);
}
if (typeof input.name !== "string" || typeof input.value !== "string") {
throw new HttpError(400, "dns record 'name' and 'value' are required");
}
const domain = await this.getDomain(domainId);
if (!domain)
throw new HttpError(404, `domain '${domainId}' not found`);
const id = crypto.randomUUID();
const row = await this.db.get(`INSERT INTO dns_records (id, domain_id, type, name, value, ttl, priority, created_at)
VALUES ($1,$2,$3,$4,$5,$6,$7,$8) RETURNING *`, [
id,
domainId,
input.type,
input.name,
input.value,
input.ttl ?? 3600,
input.priority ?? null,
new Date().toISOString()
]);
return rowToDnsRecord(row);
}
async getDnsRecord(id) {
const row = await this.db.get("SELECT * FROM dns_records WHERE id = $1", [id]);
return row ? rowToDnsRecord(row) : null;
}
async deleteDnsRecord(id) {
const result = await this.db.query("DELETE FROM dns_records WHERE id = $1", [id]);
return result.rowCount > 0;
}
async listOffers(domainId) {
const rows = await this.db.many("SELECT * FROM domain_offers WHERE domain_id = $1 ORDER BY created_at DESC", [domainId]);
return rows;
}
async createOffer(domainId, input) {
const domain = await this.getDomain(domainId);
if (!domain)
throw new HttpError(404, `domain '${domainId}' not found`);
const status = input.status ?? "pending";
if (!DOMAIN_OFFER_STATUSES.includes(status)) {
throw new HttpError(400, `invalid offer status '${status}'`);
}
const id = crypto.randomUUID();
const row = await this.db.get(`INSERT INTO domain_offers (id, domain_id, our_offer, their_ask, status, notes, created_at)
VALUES ($1,$2,$3,$4,$5,$6,$7) RETURNING *`, [
id,
domainId,
input.our_offer ?? null,
input.their_ask ?? null,
status,
input.notes ?? null,
new Date().toISOString()
]);
return row;
}
async getOffer(id) {
const row = await this.db.get("SELECT * FROM domain_offers WHERE id = $1", [id]);
return row ? row : null;
}
async updateDnsRecord(id, patch) {
const existing = await this.getDnsRecord(id);
if (!existing)
return null;
const sets = [];
const params = [];
const setCol = (col, val) => {
params.push(val);
sets.push(`${col} = $${params.length}`);
};
if (patch.type !== undefined) {
if (!DNS_TYPES.includes(patch.type)) {
throw new HttpError(400, `dns record 'type' must be one of ${DNS_TYPES.join(", ")}`);
}
setCol("type", patch.type);
}
if (patch.name !== undefined)
setCol("name", patch.name);
if (patch.value !== undefined)
setCol("value", patch.value);
if (patch.ttl !== undefined)
setCol("ttl", patch.ttl);
if (patch.priority !== undefined)
setCol("priority", patch.priority ?? null);
if (sets.length === 0)
return existing;
params.push(id);
const row = await this.db.get(`UPDATE dns_records SET ${sets.join(", ")} WHERE id = $${params.length} RETURNING *`, params);
return row ? rowToDnsRecord(row) : null;
}
async listEmailLinks(domainId) {
const rows = await this.db.many("SELECT * FROM domain_emails WHERE domain_id = $1 ORDER BY created_at ASC", [domainId]);
return rows;
}
async getEmailLink(id) {
const row = await this.db.get("SELECT * FROM domain_emails WHERE id = $1", [id]);
return row ? row : null;
}
async linkEmail(domainId, input) {
if (!DOMAIN_EMAIL_TYPES.includes(input.type)) {
throw new HttpError(400, `invalid email link type '${input.type}'`);
}
const domain = await this.getDomain(domainId);
if (!domain)
throw new HttpError(404, `domain '${domainId}' not found`);
const existing = await this.db.get("SELECT id, thread_id FROM domain_emails WHERE domain_id = $1 AND email_id = $2", [domainId, input.email_id]);
if (existing) {
const row = await this.db.get("UPDATE domain_emails SET thread_id = $1, type = $2 WHERE id = $3 RETURNING *", [input.thread_id ?? existing.thread_id ?? null, input.type, existing.id]);
return row;
}
const id = crypto.randomUUID();
const row = await this.db.get(`INSERT INTO domain_emails (id, domain_id, email_id, thread_id, type, created_at)
VALUES ($1,$2,$3,$4,$5,$6) RETURNING *`, [id, domainId, input.email_id, input.thread_id ?? null, input.type, new Date().toISOString()]);
return row;
}
async listAlerts(domainId) {
const rows = await this.db.many("SELECT * FROM alerts WHERE domain_id = $1 ORDER BY type, trigger_days_before", [domainId]);
return rows;
}
async getAlert(id) {
const row = await this.db.get("SELECT * FROM alerts WHERE id = $1", [id]);
return row ? row : null;
}
async createAlert(domainId, input) {
const domain = await this.getDomain(domainId);
if (!domain)
throw new HttpError(404, `domain '${domainId}' not found`);
if (!["expiry", "ssl_expiry", "dns_change"].includes(input.type)) {
throw new HttpError(400, `invalid alert type '${input.type}'`);
}
const id = crypto.randomUUID();
const row = await this.db.get(`INSERT INTO alerts (id, domain_id, type, trigger_days_before, created_at)
VALUES ($1,$2,$3,$4,$5) RETURNING *`, [id, domainId, input.type, input.trigger_days_before ?? null, new Date().toISOString()]);
return row;
}
async deleteAlert(id) {
const result = await this.db.query("DELETE FROM alerts WHERE id = $1", [id]);
return result.rowCount > 0;
}
ownerRow(row) {
return {
id: row["id"],
domain_id: row["domain_id"],
contact_id: row["contact_id"] ?? null,
owner_name: row["owner_name"] ?? null,
owner_email: row["owner_email"] ?? null,
owner_phone: row["owner_phone"] ?? null,
owner_organization: row["owner_organization"] ?? null,
source: row["source"],
verified: Boolean(row["verified"]),
notes: row["notes"] ?? null,
created_at: row["created_at"],
updated_at: row["updated_at"]
};
}
async listOwnersForDomain(domainId) {
const rows = await this.db.many("SELECT * FROM domain_owners WHERE domain_id = $1 ORDER BY created_at DESC", [domainId]);
return rows.map((r) => this.ownerRow(r));
}
async listOwners(opts) {
const clauses = [];
const params = [];
if (opts.search) {
params.push(`%${opts.search}%`);
const p = `$${params.length}`;
clauses.push(`(owner_name ILIKE ${p} OR owner_email ILIKE ${p} OR owner_organization ILIKE ${p} OR notes ILIKE ${p})`);
}
if (opts.source) {
params.push(opts.source);
clauses.push(`source = $${params.length}`);
}
if (opts.verified !== undefined) {
params.push(opts.verified);
clauses.push(`verified = $${params.length}`);
}
const where = clauses.length ? `WHERE ${clauses.join(" AND ")}` : "";
const rows = await this.db.many(`SELECT * FROM domain_owners ${where} ORDER BY created_at DESC`, params);
return rows.map((r) => this.ownerRow(r));
}
async getOwner(id) {
const row = await this.db.get("SELECT * FROM domain_owners WHERE id = $1", [id]);
return row ? this.ownerRow(row) : null;
}
async createOwner(domainId, input) {
const domain = await this.getDomain(domainId);
if (!domain)
throw new HttpError(404, `domain '${domainId}' not found`);
const source = input.source ?? "manual";
if (!DOMAIN_OWNER_SOURCES.includes(source))
throw new HttpError(400, `invalid owner source '${source}'`);
const id = crypto.randomUUID();
const now = new Date().toISOString();
const row = await this.db.get(`INSERT INTO domain_owners (id, domain_id, contact_id, owner_name, owner_email, owner_phone, owner_organization, source, verified, notes, created_at, updated_at)
VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12) RETURNING *`, [
id,
domainId,
input.contact_id ?? null,
input.owner_name ?? null,
input.owner_email ?? null,
input.owner_phone ?? null,
input.owner_organization ?? null,
source,
input.verified ?? false,
input.notes ?? null,
now,
now
]);
return this.ownerRow(row);
}
async updateOwner(id, patch) {
const existing = await this.getOwner(id);
if (!existing)
return null;
const sets = [];
const params = [];
const setCol = (col, val) => {
params.push(val);
sets.push(`${col} = $${params.length}`);
};
if (patch.contact_id !== undefined)
setCol("contact_id", patch.contact_id ?? null);
if (patch.owner_name !== undefined)
setCol("owner_name", patch.owner_name ?? null);
if (patch.owner_email !== undefined)
setCol("owner_email", patch.owner_email ?? null);
if (patch.owner_phone !== undefined)
setCol("owner_phone", patch.owner_phone ?? null);
if (patch.owner_organization !== undefined)
setCol("owner_organization", patch.owner_organization ?? null);
if (patch.source !== undefined)
setCol("source", patch.source);
if (patch.verified !== undefined)
setCol("verified", Boolean(patch.verified));
if (patch.notes !== undefined)
setCol("notes", patch.notes ?? null);
if (sets.length === 0)
return existing;
setCol("updated_at", new Date().toISOString());
params.push(id);
const row = await this.db.get(`UPDATE domain_owners SET ${sets.join(", ")} WHERE id = $${params.length} RETURNING *`, params);
return row ? this.ownerRow(row) : null;
}
async deleteOwner(id) {
const result = await this.db.query("DELETE FROM domain_owners WHERE id = $1", [id]);
return result.rowCount > 0;
}
async listDomainsWithOwners() {
const rows = await this.db.many(`SELECT d.name as domain_name, d.status as domain_status, d.is_premium, d.premium_price,
o.owner_name, o.owner_email, o.owner_organization, o.contact_id, o.source, o.verified
FROM domains d
LEFT JOIN domain_owners o ON d.id = o.domain_id
WHERE o.id IS NOT NULL OR d.is_premium = true
OR d.status IN ('premium_only','not_available','negotiating','offered','researching')
ORDER BY d.name`);
return rows.map((r) => ({
domain_name: r["domain_name"],
domain_status: r["domain_status"],
is_premium: Boolean(r["is_premium"]),
premium_price: r["premium_price"] ?? null,
owner_name: r["owner_name"] ?? null,
owner_email: r["owner_email"] ?? null,
owner_organization: r["owner_organization"] ?? null,
contact_id: r["contact_id"] ?? null,
source: r["source"] ?? null,
verified: Boolean(r["verified"])
}));
}
historyRow(row) {
return {
id: row["id"],
domain_id: row["domain_id"],
snapshot_type: row["snapshot_type"],
raw_data: parseJson(row["raw_data"], {}),
registrant_name: row["registrant_name"] ?? null,
registrant_email: row["registrant_email"] ?? null,
registrant_org: row["registrant_org"] ?? null,
nameservers: parseJson(row["nameservers"], []),
registrar: row["registrar"] ?? null,
status: row["status"] ?? null,
notes: row["notes"] ?? null,
created_at: row["created_at"]
};
}
async createHistory(domainId, input) {
const domain = await this.getDomain(domainId);
if (!domain)
throw new HttpError(404, `domain '${domainId}' not found`);
if (!HISTORY_TYPES.includes(input.snapshot_type))
throw new HttpError(400, `invalid snapshot_type '${input.snapshot_type}'`);
const id = crypto.randomUUID();
const row = await this.db.get(`INSERT INTO domain_history (id, domain_id, snapshot_type, raw_data, registrant_name, registrant_email, registrant_org, nameservers, registrar, status, notes, created_at)
VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12) RETURNING *`, [
id,
domainId,
input.snapshot_type,
JSON.stringify(input.raw_data ?? {}),
input.registrant_name ?? null,
input.registrant_email ?? null,
input.registrant_org ?? null,
JSON.stringify(input.nameservers ?? []),
input.registrar ?? null,
input.status ?? null,
input.notes ?? null,
new Date().toISOString()
]);
return this.historyRow(row);
}
async getHistory(id) {
const row = await this.db.get("SELECT * FROM domain_history WHERE id = $1", [id]);
return row ? this.historyRow(row) : null;
}
async listHistory(domainId, opts) {
const clauses = ["domain_id = $1"];
const params = [domainId];
if (opts.type) {
params.push(opts.type);
clauses.push(`snapshot_type = $${params.length}`);
}
let sql = `SELECT * FROM domain_history WHERE ${clauses.join(" AND ")} ORDER BY created_at DESC`;
if (opts.limit) {
params.push(Math.min(Math.max(opts.limit, 1), 1000));
sql += ` LIMIT $${params.length}`;
}
const rows = await this.db.many(sql, params);
return rows.map((r) => this.historyRow(r));
}
async listHistoryByDateRange(start, end, domainId) {
const clauses = ["created_at BETWEEN $1 AND $2"];
const params = [start, end];
if (domainId) {
params.push(domainId);
clauses.push(`domain_id = $${params.length}`);
}
const rows = await this.db.many(`SELECT * FROM domain_history WHERE ${clauses.join(" AND ")} ORDER BY created_at DESC`, params);
return rows.map((r) => this.historyRow(r));
}
async deleteHistory(id) {
const result = await this.db.query("DELETE FROM domain_history WHERE id = $1", [id]);
return result.rowCount > 0;
}
async deleteHistoryByDomain(domainId) {
const result = await this.db.query("DELETE FROM domain_history WHERE domain_id = $1", [domainId]);
return result.rowCount > 0;
}
async listHistoryChanges() {
const rows = await this.db.many(`SELECT d.id as domain_id, d.name as domain_name,
(SELECT snapshot_type FROM domain_history h2 WHERE h2.domain_id = d.id ORDER BY created_at DESC LIMIT 1) as latest_snapshot_type,
MAX(h.created_at) as latest_snapshot_at,
COUNT(h.id)::text as snapshot_count
FROM domains d JOIN domain_history h ON d.id = h.domain_id
GROUP BY d.id ORDER BY latest_snapshot_at DESC`);
return rows.map((r) => ({
domain_id: r["domain_id"],
domain_name: r["domain_name"],
latest_snapshot_type: r["latest_snapshot_type"],
latest_snapshot_at: r["latest_snapshot_at"],
snapshot_count: parseInt(r["snapshot_count"] ?? "0", 10)
}));
}
reputationRow(row) {
return {
id: row["id"],
domain_id: row["domain_id"],
is_blacklisted: Boolean(row["is_blacklisted"]),
blacklist_sources: parseJson(row["blacklist_sources"], []),
threat_score: row["threat_score"] ?? null,
spam_score: row["spam_score"] ?? null,
malware_detected: Boolean(row["malware_detected"]),
phishing_detected: Boolean(row["phishing_detected"]),
reputation_sources: parseJson(row["reputation_sources"], []),
last_checked_at: row["last_checked_at"] ?? null,
notes: row["notes"] ?? null,
created_at: row["created_at"],
updated_at: row["updated_at"]
};
}
async getReputation(domainId) {
const row = await this.db.get("SELECT * FROM domain_reputation WHERE domain_id = $1", [domainId]);
return row ? this.reputationRow(row) : null;
}
async upsertReputation(domainId, input) {
const domain = await this.getDomain(domainId);
if (!domain)
throw new HttpError(404, `domain '${domainId}' not found`);
const existing = await this.getReputation(domainId);
const now = new Date().toISOString();
if (existing) {
const sets = [];
const params = [];
const setCol = (col, val) => {
params.push(val);
sets.push(`${col} = $${params.length}`);
};
if (input.is_blacklisted !== undefined)
setCol("is_blacklisted", Boolean(input.is_blacklisted));
if (input.blacklist_sources !== undefined)
setCol("blacklist_sources", JSON.stringify(input.blacklist_sources));
if (input.threat_score !== undefined)
setCol("threat_score", input.threat_score);
if (input.spam_score !== undefined)
setCol("spam_score", input.spam_score);
if (input.malware_detected !== undefined)
setCol("malware_detected", Boolean(input.malware_detected));
if (input.phishing_detected !== undefined)
setCol("phishing_detected", Boolean(input.phishing_detected));
if (input.reputation_sources !== undefined)
setCol("reputation_sources", JSON.stringify(input.reputation_sources));
if (input.last_checked_at !== undefined)
setCol("last_checked_at", input.last_checked_at);
if (input.notes !== undefined)
setCol("notes", input.notes);
setCol("updated_at", now);
params.push(existing.id);
const row = await this.db.get(`UPDATE domain_reputation SET ${sets.join(", ")} WHERE id = $${params.length} RETURNING *`, params);
return this.reputationRow(row);
}
const id = crypto.randomUUID();
const row = await this.db.get(`INSERT INTO domain_reputation (id, domain_id, is_blacklisted, blacklist_sources, threat_score, spam_score, malware_detected, phishing_detected, reputation_sources, last_checked_at, notes, created_at, updated_at)
VALUES ($1,$2,$3,$4,$5,$6,$7,$8,$9,$10,$11,$12,$13) RETURNING *`, [
id,
domainId,
input.is_blacklisted ?? false,
JSON.stringify(input.blacklist_sources ?? []),
input.threat_score ?? null,
input.spam_score ?? null,
input.malware_detected ?? false,
input.phishing_detected ?? false,
JSON.stringify(input.reputation_sources ?? []),
input.last_checked_at ?? null,
input.notes ?? null,
now,
now
]);
return this.reputationRow(row);
}
async updateReputation(id, patch) {
const existing = await this.db.get("SELECT * FROM domain_reputation WHERE id = $1", [id]);
if (!existing)
return null;
return this.upsertReputation(existing["domain_id"], patch);
}
async deleteReputation(id) {
const result = await this.db.query("DELETE FROM domain_reputation WHERE id = $1", [id]);
return result.rowCount > 0;
}
async listReputation(opts) {
if (opts.blacklisted) {
const rows = await this.db.many("SELECT * FROM domain_reputation WHERE is_blacklisted = true ORDER BY updated_at DESC");
return rows.map((r) => this.reputationRow(r));
}
const threshold = opts.threshold ?? 70;
const rows = await this.db.many("SELECT * FROM domain_reputation WHERE threat_score >= $1 ORDER BY threat_score DESC", [threshold]);
return rows.map((r) => this.reputationRow(r));
}
}
// src/db/pg-migrations.ts
var PG_MIGRATIONS = [
`CREATE TABLE IF NOT EXISTS domains (
id TEXT PRIMARY KEY,
name TEXT NOT NULL UNIQUE,
registrar TEXT,
status TEXT NOT NULL DEFAULT 'active' CHECK (status IN ('discovered', 'researching', 'offered', 'negotiating', 'purchased', 'active', 'not_available', 'premium_only', 'declined', 'expired', 'transferring', 'redemption')),
registered_at TEXT,
expires_at TEXT,
auto_renew BOOLEAN NOT NULL DEFAULT TRUE,
is_premium BOOLEAN NOT NULL DEFAULT FALSE,
premium_price DOUBLE PRECISION,
standard_price DOUBLE PRECISION,
purchase_price DOUBLE PRECISION,
purchase_date TEXT,
nameservers TEXT NOT NULL DEFAULT '[]',
whois TEXT NOT NULL DEFAULT '{}',
ssl_expires_at TEXT,
ssl_issuer TEXT,
notes TEXT,
metadata TEXT NOT NULL DEFAULT '{}',
created_at TEXT NOT NULL DEFAULT NOW()::text,
updated_at TEXT NOT NULL DEFAULT NOW()::text
)`,
`CREATE TABLE IF NOT EXISTS dns_records (
id TEXT PRIMARY KEY,
domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
type TEXT NOT NULL CHECK (type IN ('A', 'AAAA', 'CNAME', 'MX', 'TXT', 'NS', 'SRV')),
name TEXT NOT NULL,
value TEXT NOT NULL,
ttl INTEGER NOT NULL DEFAULT 3600,
priority INTEGER,
created_at TEXT NOT NULL DEFAULT NOW()::text
)`,
`CREATE TABLE IF NOT EXISTS alerts (
id TEXT PRIMARY KEY,
domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
type TEXT NOT NULL CHECK (type IN ('expiry', 'ssl_expiry', 'dns_change')),
trigger_days_before INTEGER,
sent_at TEXT,
created_at TEXT NOT NULL DEFAULT NOW()::text
)`,
`CREATE TABLE IF NOT EXISTS domain_offers (
id TEXT PRIMARY KEY,
domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
our_offer DOUBLE PRECISION,
their_ask DOUBLE PRECISION,
status TEXT NOT NULL DEFAULT 'pending' CHECK (status IN ('pending', 'accepted', 'rejected', 'countered')),
notes TEXT,
created_at TEXT NOT NULL DEFAULT NOW()::text,
owner_contact_id TEXT
)`,
`CREATE TABLE IF NOT EXISTS domain_emails (
id TEXT PRIMARY KEY,
domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
email_id TEXT NOT NULL,
thread_id TEXT,
type TEXT NOT NULL CHECK (type IN ('inquiry', 'offer', 'counter_offer', 'confirmation', 'renewal_notice', 'transfer')),
created_at TEXT NOT NULL DEFAULT NOW()::text,
UNIQUE(domain_id, email_id)
)`,
`CREATE TABLE IF NOT EXISTS domain_owners (
id TEXT PRIMARY KEY,
domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
contact_id TEXT,
owner_name TEXT,
owner_email TEXT,
owner_phone TEXT,
owner_organization TEXT,
source TEXT NOT NULL DEFAULT 'manual' CHECK (source IN ('whois', 'manual', 'brandsight', 'import')),
verified BOOLEAN NOT NULL DEFAULT FALSE,
notes TEXT,
created_at TEXT NOT NULL DEFAULT NOW()::text,
updated_at TEXT NOT NULL DEFAULT NOW()::text
)`,
`CREATE TABLE IF NOT EXISTS domain_history (
id TEXT PRIMARY KEY,
domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
snapshot_type TEXT NOT NULL CHECK (snapshot_type IN ('whois', 'rdap', 'dns', 'ssl', 'reputation', 'exa_research', 'purchase', 'renewal')),
raw_data TEXT NOT NULL DEFAULT '{}',
registrant_name TEXT,
registrant_email TEXT,
registrant_org TEXT,
nameservers TEXT NOT NULL DEFAULT '[]',
registrar TEXT,
status TEXT,
notes TEXT,
created_at TEXT NOT NULL DEFAULT NOW()::text
)`,
`CREATE TABLE IF NOT EXISTS domain_reputation (
id TEXT PRIMARY KEY,
domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
is_blacklisted BOOLEAN NOT NULL DEFAULT FALSE,
blacklist_sources TEXT NOT NULL DEFAULT '[]',
threat_score INTEGER,
spam_score INTEGER,
malware_detected BOOLEAN NOT NULL DEFAULT FALSE,
phishing_detected BOOLEAN NOT NULL DEFAULT FALSE,
reputation_sources TEXT NOT NULL DEFAULT '[]',
last_checked_at TEXT,
notes TEXT,
created_at TEXT NOT NULL DEFAULT NOW()::text,
updated_at TEXT NOT NULL DEFAULT NOW()::text
)`,
`CREATE INDEX IF NOT EXISTS idx_domains_name ON domains(name)`,
`CREATE INDEX IF NOT EXISTS idx_domains_registrar ON domains(registrar)`,
`CREATE INDEX IF NOT EXISTS idx_domains_status ON domains(status)`,
`CREATE INDEX IF NOT EXISTS idx_domains_expires_at ON domains(expires_at)`,
`CREATE INDEX IF NOT EXISTS idx_domains_is_premium ON domains(is_premium)`,
`CREATE INDEX IF NOT EXISTS idx_dns_records_domain ON dns_records(domain_id)`,
`CREATE INDEX IF NOT EXISTS idx_dns_records_type ON dns_records(type)`,
`CREATE INDEX IF NOT EXISTS idx_alerts_domain ON alerts(domain_id)`,
`CREATE INDEX IF NOT EXISTS idx_alerts_type ON alerts(type)`,
`CREATE INDEX IF NOT EXISTS idx_domain_offers_domain ON domain_offers(domain_id)`,
`CREATE INDEX IF NOT EXISTS idx_domain_offers_owner ON domain_offers(owner_contact_id)`,
`CREATE INDEX IF NOT EXISTS idx_domain_emails_domain ON domain_emails(domain_id)`,
`CREATE UNIQUE INDEX IF NOT EXISTS idx_domain_emails_unique ON domain_emails(domain_id, email_id)`,
`CREATE INDEX IF NOT EXISTS idx_domain_owners_domain ON domain_owners(domain_id)`,
`CREATE INDEX IF NOT EXISTS idx_domain_owners_contact ON domain_owners(contact_id)`,
`CREATE INDEX IF NOT EXISTS idx_domain_owners_email ON domain_owners(owner_email)`,
`CREATE INDEX IF NOT EXISTS idx_domain_history_domain ON domain_history(domain_id)`,
`CREATE INDEX IF NOT EXISTS idx_domain_history_type ON domain_history(snapshot_type)`,
`CREATE INDEX IF NOT EXISTS idx_domain_history_created ON domain_history(created_at)`,
`CREATE INDEX IF NOT EXISTS idx_domain_history_email ON domain_history(registrant_email)`,
`CREATE INDEX IF NOT EXISTS idx_domain_reputation_domain ON domain_reputation(domain_id)`,
`CREATE INDEX IF NOT EXISTS idx_domain_reputation_blacklisted ON domain_reputation(is_blacklisted)`,
`ALTER TABLE domains ADD COLUMN IF NOT EXISTS expiry_synced_at TEXT`,
`CREATE INDEX IF NOT EXISTS idx_domains_expiry_synced_at ON domains(expiry_synced_at)`,
`CREATE TABLE IF NOT EXISTS domain_provisioning_jobs (
id TEXT PRIMARY KEY,
domain_id TEXT NOT NULL REFERENCES domains(id) ON DELETE CASCADE,
domain_name TEXT NOT NULL UNIQUE,
idempotency_key TEXT NOT NULL UNIQUE,
request_hash TEXT NOT NULL,
status TEXT NOT NULL CHECK (status IN ('requested','quoted','registration_submitting','registration_submitted','registered','zone_ready','nameservers_submitted','delegated','worker_bound','ready','manual_review','failed')),
max_price_usd DOUBLE PRECISION NOT NULL CHECK (max_price_usd > 0),
years INTEGER NOT NULL CHECK (years BETWEEN 1 AND 10),
auto_renew BOOLEAN NOT NULL,
registrar TEXT NOT NULL CHECK (registrar = 'route53'),
dns_provider TEXT NOT NULL CHECK (dns_provider = 'cloudflare'),
target TEXT NOT NULL CHECK (target = 'shortlinks'),
worker_name TEXT NOT NULL,
provider_state TEXT NOT NULL DEFAULT '{}',
attempts INTEGER NOT NULL DEFAULT 0,
error TEXT,
lease_token TEXT,
lease_until TEXT,
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL
)`,
`CREATE INDEX IF NOT EXISTS idx_domain_provisioning_status ON domain_provisioning_jobs(status, updated_at)`,
`CREATE INDEX IF NOT EXISTS idx_domain_provisioning_lease ON domain_provisioning_jobs(lease_until)`,
`ALTER TABLE domain_provisioning_jobs
DROP CONSTRAINT IF EXISTS domain_provisioning_jobs_target_check,
DROP CONSTRAINT IF EXISTS domain_provisioning_jobs_target_shape_check,
ALTER COLUMN worker_name DROP NOT NULL,
ADD COLUMN IF NOT EXISTS origin_hostname TEXT,
ADD CONSTRAINT domain_provisioning_jobs_target_check
CHECK (target IN ('shortlinks', 'website_origin')),
ADD CONSTRAINT domain_provisioning_jobs_target_shape_check
CHECK (
(target = 'shortlinks' AND worker_name IS NOT NULL AND origin_hostname IS NULL)
OR
(target = 'website_origin' AND worker_name IS NULL AND origin_hostname IS NOT NULL)
)`,
`CREATE TABLE IF NOT EXISTS domain_dns_reconciliations (
id TEXT PRIMARY KEY,
provisioning_job_id TEXT NOT NULL REFERENCES domain_provisioning_jobs(id) ON DELETE CASCADE,
domain_name TEXT NOT NULL,
idempotency_key TEXT NOT NULL UNIQUE,
request_hash TEXT NOT NULL,
status TEXT NOT NULL CHECK (status IN ('requested','applying','ready','manual_review')),
records TEXT NOT NULL,
result TEXT,
error TEXT,
lease_token TEXT,
lease_until TEXT,
created_at TEXT NOT NULL,
updated_at TEXT NOT NULL
)`,
`CREATE INDEX IF NOT EXISTS idx_domain_dns_reconciliation_job
ON domain_dns_reconciliations(provisioning_job_id, updated_at)`,
`ALTER TABLE domain_provisioning_jobs
DROP CONSTRAINT IF EXISTS domain_provisioning_jobs_max_price_usd_check,
ADD COLUMN IF NOT EXISTS acquisition_mode TEXT NOT NULL DEFAULT 'purchase',
ADD CONSTRAINT domain_provisioning_jobs_acquisition_mode_check
CHECK (acquisition_mode IN ('purchase', 'adopt')),
ADD CONSTRAINT domain_provisioning_jobs_price_mode_check
CHECK (
(acquisition_mode = 'purchase' AND max_price_usd > 0)
OR (acquisition_mode = 'adopt' AND max_price_usd = 0)
)`,
`ALTER TABLE domain_provisioning_jobs
ADD COLUMN IF NOT EXISTS origin_tls_mode TEXT`,
`UPDATE domain_provisioning_jobs
SET origin_tls_mode = 'strict'
WHERE target = 'website_origin' AND origin_tls_mode IS NULL`,
`ALTER TABLE domain_provisioning_jobs
DROP CONSTRAINT IF EXISTS domain_provisioning_jobs_target_shape_check,
ADD CONSTRAINT domain_provisioning_jobs_target_shape_check
CHECK (
(target = 'shortlinks' AND worker_name IS NOT NULL AND origin_hostname IS NULL AND origin_tls_mode IS NULL)
OR
(target = 'website_origin' AND worker_name IS NULL AND origin_hostname IS NOT NULL AND origin_tls_mode IN ('strict', 'full'))
)`,
`ALTER TABLE domain_provisioning_jobs
DROP CONSTRAINT IF EXISTS domain_provisioning_jobs_registrar_check,
ADD CONSTRAINT domain_provisioning_jobs_registrar_check
CHECK (registrar IN ('route53', 'brandsight'))`
];
// src/server/migrations.ts
function buildMigrations() {
const migrations = [];
PG_MIGRATIONS.forEach((sql, i) => {
const id = `domains_${String(i + 1).padStart(4, "0")}`;
migrations.push(defineMigration(id, sql));
});
for (const m of apiKeyMigrations("api_keys")) {
migrations.push(defineMigration(m.id, m.sql));
}
return migrations;
}
// src/server/openapi.ts
var ref = (name) => ({ $ref: `#/components/schemas/${name}` });
function jsonResponse(schema, description) {
return { description, content: { "application/json": { schema } } };
}
function jsonBody(schema) {
return { required: true, content: { "application/json": { schema } } };
}
function buildOpenApiSpec(version) {
const dnsRecordSchema = {
type: "object",
additionalProperties: false,
properties: {
type: { type: "string", enum: ["TXT", "CNAME", "MX"] },
name: { type: "string" },
value: { type: "string" },
ttl: { type: "integer", minimum: 60, maximum: 86400 },
priority: { anyOf: [{ type: "integer", minimum: 0, maximum: 65535 }, { type: "null" }] }
},
required: ["type", "name", "value", "ttl"]
};
const idParam = {
name: "id",
in: "path",
required: true,
schema: { type: "string" },
description: "Resource identifier (UUID)."
};
return {
openapi: "3.1.0",
info: {
title: "domains",
version,
description: "Domain portfolio, registrar, marketplace, and DNS management HTTP API. API-key authenticated."
},
security: [{ apiKey: [] }],
paths: {
"/health": {
get: {
operationId: "getHealth",
summary: "Liveness probe (DB reachable).",
responses: { "200": jsonResponse(ref("HealthResponse"), "Service healthy") }
}
},
"/ready": {
get: {
operationId: "getReady",
summary: "Readiness probe (DB reachable and schema migrated).",
responses: {
"200": jsonResponse(ref("ReadyResponse"), "Service ready"),
"503": jsonResponse(ref("ReadyResponse"), "Not ready")
}
}
},
"/version": {
get: {
operationId: "getVersion",
summary: "Service version and mode.",
responses: { "200": jsonResponse(ref("VersionResponse"), "Version info") }
}
},
"/v1/availability": {
post: {
operationId: "checkDomainAvailability",
summary: "Check live registrar availability and current price.",
requestBody: jsonBody(ref("AvailabilityInput")),
responses: {
"200": jsonResponse(ref("AvailabilityQuote"), "Live registrar quote"),
"400": jsonResponse(ref("Error"), "Invalid hostname")
}
}
},
"/v1/provisioning": {
post: {
operationId: "requestDomainProvisioning",
summary: "Reserve, cap the total charge, purchase, delegate and bind a domain through the hosted Domains authority.",
parameters: [{ name: "idempotency-key", in: "header", required: true, schema: { type: "string", minLength: 8, maxLength: 128 } }],
requestBody: jsonBody(ref("DomainProvisioningRequest")),
responses: {
"200": jsonResponse(ref("DomainProvisioningJob"), "Already ready"),
"202": jsonResponse(ref("DomainProvisioningJob"), "Accepted for asynchronous provisioning"),
"409": jsonResponse(ref("Error"), "Conflicting request")
}
}
},
"/v1/provisioning/{id}": {
get: {
operationId: "getDomainProvisioning",
summary: "Read a domain provisioning job.",
parameters: [idParam],
responses: {
"200": jsonResponse(ref("DomainProvisioningJob"), "Provisioning state"),
"404": jsonResponse(ref("Error"), "Not found")
}
}
},
"/v1/provisioning/adopt": {
post: {
operationId: "adoptOwnedDomainProvisioning",
summary: "Adopt an existing portfolio domain into hosted provisioning without a registrar purchase.",
parameters: [{ name: "idempotency-key", in: "header", required: true, schema: { type: "string", minLength: 8, maxLength: 128 } }],
requestBody: jsonBody(ref("DomainAdoptionRequest")),
responses: {
"200": jsonResponse(ref("DomainProvisioningJob"), "Already ready"),
"202": jsonResponse(ref("DomainProvisioningJob"), "Ownership verified and adoption reserved"),
"400": jsonResponse(ref("Error"), "Invalid or registrar-unverified domain"),
"404": jsonResponse(ref("Error"), "Domain is not in the portfolio"),
"409": jsonResponse(ref("Error"), "Conflicting target intent")
}
}
},
"/v1/provisioning/by-name/{name}": {
get: {
operationId: "getDomainProvisioningByName",
summary: "Read the durable provisioning job for a canonical domain name.",
parameters: [{ name: "name", in: "path", required: true, schema: { type: "string" } }],
responses: {
"200": jsonResponse(ref("DomainProvisioningJob"), "Provisioning state"),
"400": jsonResponse(ref("Error"), "Invalid domain name"),
"404": jsonResponse(ref("Error"), "Not found")
}
}
},
"/v1/provisioning/by-name/{name}/dns-reconciliations": {
get: {
operationId: "listProvisionedDomainDnsReconciliations",
summary: "Read durable DNS receipts without claiming leases or replaying provider writes. Follow next_offset until null.",
parameters: [
{ name: "name", in: "path", required: true, schema: { type: "string" } },
{ name: "id", in: "query", schema: { type: "string", maxLength: 128 } },
{ name: "idempotency_key", in: "query", schema: { type: "string", maxLength: 128 } },
{ name: "limit", in: "query", schema: { type: "integer", minimum: 1, maximum: 100, default: 50 } },
{ name: "offset", in: "query", schema: { type: "integer", minimum: 0, default: 0 } }
],
responses: {
"200": jsonResponse({ type: "object", required: ["reconciliations", "next_offset"], properties: {
reconciliations: { type: "array", items: ref("DomainDnsReconciliation") },
next_offset: { type: "integer", nullable: true }
} }, "Durable receipts scoped to the exact domain"),
"400": jsonResponse(ref("Error"), "Invalid lookup filter or pagination")
}
}
},
"/v1/provisioning/by-name/{name}/dns-state": {
get: {
operationId: "getProvisionedDomainDnsState",
summary: "Read a complete selected DNS group and its exact-state guard under the zone lock.",
parameters: [
{ name: "name", in: "path", required: true, schema: { type: "string" } },
{ name: "record_name", in: "query", required: true, schema: { type: "string" } },
{ name: "record_type", in: "query", required: true, schema: { type: "string", enum: ["TXT", "CNAME", "MX"] } }
],
responses: {
"200": jsonResponse(ref("DomainDnsRecordState"), "Complete provider group; no truncation"),
"400": jsonResponse(ref("Error"), "Invalid or non-ready domain request")
}
}
},
"/v1/provisioning/by-name/{name}/dns-reconcile": {
post: {
operationId: "reconcileProvisionedDomainDns",
summary: "Idempotently reconcile bounded TXT, CNAME, and MX record groups for a ready hosted domain.",
parameters: [
{ name: "name", in: "path", required: true, schema: { type: "string" } },
{ name: "idempotency-key", in: "header", required: true, schema: { type: "string", minLength: 8, maxLength: 128 } }
],
requestBody: jsonBody(ref("DomainDnsReconciliationRequest")),
responses: {
"200": jsonResponse(ref("DomainDnsReconciliation"), "Reconciled with provider readback"),
"202": jsonResponse(ref("DomainDnsReconciliation"), "Reserved or requires review"),
"400": jsonResponse(ref("Error"), "Invalid or non-ready domain request"),
"409": jsonResponse(ref("Error"), "Conflicting idempotency key")
}
}
},
"/v1/provisioning/by-name/{name}/dns-reconcile/mail": {
post: {
operationId: "reconcileProvisionedDomainEmailDns",
summary: "Ensure email authorization while preserving existing DMARC and unrelated mail records. Result records are effective provider values, which may differ from requested defaults.",
parameters: [
{ name: "name", in: "path", required: true, schema: { type: "string" } },
{ name: "idempotency-key", in: "header", required: true, schema: { type: "string", minLength: 8, maxLength: 128 } }
],
requestBody: jsonBody(ref("DomainDnsReconciliationRequest")),
responses: {
"200": jsonResponse(ref("DomainDnsReconciliation"), "Preserved mail authorization with provider readback"),
"202": jsonResponse(ref("DomainDnsReconciliation"), "Reserved or requires review"),
"400": jsonResponse(ref("Error"), "Invalid or non-ready domain request"),
"409": jsonResponse(ref("Error"), "Conflicting idempotency key")
}
}
},
"/v1/provisioning/{id}/advance": {
post: {
operationId: "advanceDomainProvisioning",
summary: "Advance one idempotent hosted provisioning step (operator recovery path).",
parameters: [idParam],
responses: {
"200": jsonResponse(ref("DomainProvisioningJob"), "Terminal state"),
"202": jsonResponse(ref("DomainProvisioningJob"), "Advanced or still pending"),
"404": jsonResponse(ref("Error"), "Not found")
}
}
},
"/v1/domains": {
get: {
operationId: "listDomains",
summary: "List domains.",
parameters: [
{ name: "search", in: "query", required: false, schema: { type: "string" } },
{ name: "status", in: "query", required: false, schema: { type: "string" } },
{ name: "limit", in: "query", required: false, schema: { type: "integer" } },
{ name: "offset", in: "query", required: false, schema: { type: "integer" } }
],
responses: { "200": jsonResponse(ref("DomainList"), "A page of domains") }
},
post: {
operationId: "createDomain",
summary: "Create a domain.",
requestBody: jsonBody(ref("CreateDomainInput")),
responses: {
"201": jsonResponse(ref("Domain"), "Created"),
"400": jsonResponse(ref("Error"), "Invalid input"),
"409": jsonResponse(ref("Error"), "Already exists")
}
}
},
"/v1/domains/{id}": {
get: {
operationId: "getDomain",
summary: "Get a domain by id.",
parameters: [idParam],
responses: {
"200": jsonResponse(ref("Domain"), "The domain"),
"404": jsonResponse(ref("Error"), "Not found")
}
},
patch: {
operationId: "updateDomain",
summary: "Update a domain.",
parameters: [idParam],
requestBody: jsonBody(ref("UpdateDomainInput")),
responses: {
"200": jsonResponse(ref("Domain"), "Updated"),
"404": jsonResponse(ref("Error"), "Not found")
}
},
delete: {
operationId: "deleteDomain",
summary: "Delete a domain.",
parameters: [idParam],
responses: { "200": jsonResponse(ref("DeleteResult"), "Deleted") }
}
},
"/v1/stats": {
get: {
operationId: "getDomainStats",
summary: "Portfolio statistics.",
responses: { "200": jsonResponse(ref("DomainStats"), "Stats") }
}
},
"/v1/domains/{id}/dns": {
get: {
operationId: "listDnsRecords",
summary: "List DNS records for a domain.",
parameters: [idParam],
responses: { "200": jsonResponse(ref("DnsRecordList"), "DNS records") }
},
post: {
operationId: "createDnsRecord",
summary: "Create a DNS record for a domain.",
parameters: [idParam],
requestBody: jsonBody(ref("CreateDnsRecordInput")),
responses: {
"201": jsonResponse(ref("DnsRecord"), "Created"),
"404": jsonResponse(ref("Error"), "Domain not found")
}
}
},
"/v1/dns/{id}": {
get: {
operationId: "getDnsRecord",
summary: "Get a DNS record by id.",
parameters: [idParam],
responses: {
"200": jsonResponse(ref("DnsRecord"), "The record"),
"404": jsonResponse(ref("Error"), "Not found")
}
},
delete: {
operationId: "deleteDnsRecord",
summary: "Delete a DNS record.",
parameters: [idParam],
responses: { "200": jsonResponse(ref("DeleteResult"), "Deleted") }
}
},
"/v1/domains/{id}/offers": {
get: {
operationId: "listOffers",
summary: "List marketplace offers for a domain.",
parameters: [idParam],
responses: { "200": jsonResponse(ref("OfferList"), "Offers") }
},
post: {
operationId: "createOffer",
summary: "Create a marketplace offer for a domain.",
parameters: [idParam],
requestBody: jsonBody(ref("CreateOfferInput")),
responses: {
"201": jsonResponse(ref("DomainOffer"), "Created"),
"404": jsonResponse(ref("Error"), "Domain not found")
}
}
}
},
components: {
securitySchemes: {
apiKey: { type: "apiKey", in: "header", name: "x-api-key" }
},
schemas: {
Error: {
type: "object",
properties: { error: { type: "string" }, reason: { type: "string" } },
required: ["error"]
},
HealthResponse: {
type: "object",
properties: {
status: { type: "string" },
version: { type: "string" },
latencyMs: { type: "number" }
},
required: ["status", "version"]
},
ReadyResponse: {
type: "object",
properties: {
status: { type: "string" },
version: { type: "string" },
pendingMigrations: { type: "array", items: { type: "string" } }
},
required: ["status", "version"]
},
VersionResponse: {
type: "object",
properties: {
status: { type: "string" },
version: { type: "string" }
},
required: ["status", "version"]
},
DeleteResult: {
type: "object",
properties: { id: { type: "string" }, deleted: { type: "boolean" } },
required: ["id", "deleted"]
},
AvailabilityInput: {
type: "object",
properties: { name: { type: "string" } },
required: ["name"]
},
AvailabilityQuote: {
type: "object",
properties: {
name: { type: "string" },
available: { type: "boolean" },
price_usd: { type: "number" },
registration_price_usd: { type: "number" },
renewal_price_usd: { type: "number" },
currency: { type: "string" },
is_premium: { type: "boolean" }
},
required: ["name", "available"]
},
DomainProvisioningRequest: {
type: "object",
properties: {
name: { type: "string" },
max_price_usd: { type: "number", exclusiveMinimum: 0, maximum: 1000, description: "Maximum total USD registration charge across all requested years." },
years: { type: "integer", minimum: 1, maximum: 10, default: 1 },
auto_renew: { type: "boolean" },
registrar: { type: "string", enum: ["route53"], default: "route53" },
dns_provider: { type: "string", enum: ["cloudflare"], default: "cloudflare" },
target: { type: "string", enum: ["shortlinks", "website_origin"], default: "shortlinks" },
worker_name: { anyOf: [{ type: "string" }, { type: "null" }], default: "shortlink-router" },
origin_hostname: { anyOf: [{ type: "string" }, { type: "null" }], description: "AWS ALB DNS hostname required for target=website_origin." },
origin_tls_mode: { anyOf: [{ type: "string", enum: ["strict", "full"] }, { type: "null" }], description: "Edge-to-origin TLS policy for website_origin. Defaults to strict; full must be explicit." }
},
required: ["name", "max_price_usd", "years", "auto_renew"]
},
DomainAdoptionRequest: {
type: "object",
additionalProperties: false,
properties: {
name: { type: "string" },
dns_provider: { type: "string", enum: ["cloudflare"], default: "cloudflare" },
target: { type: "string", enum: ["shortlinks", "website_origin"] },
worker_name: { anyOf: [{ type: "string" }, { type: "null" }] },
origin_hostname: { anyOf: [{ type: "string" }, { type: "null" }] },
origin_tls_mode: { anyOf: [{ type: "string", enum: ["strict", "full"] }, { type: "null" }] }
},
required: ["name", "target"]
},
DomainProvisioningProviderState: {
type: "object",
additionalProperties: false,
properties: {
route53_account_ref: { type: "string" },
route53_account_binding_sha256: { type: "string", pattern: "^[0-9a-f]{64}$" },
quoted_price_usd: { type: "number" },
currency: { type: "string" },
registration_operation_id: { type: "string" },
nameserver_operation_id: { type: "string" },
cloudflare_zone_id: { type: "string" },
cloudflare_nameservers: { type: "array", items: { type: "string" } },
route53_zone_ids_before_registration: { type: "array", items: { type: "string" } },
route53_hosted_zone_id: { type: "string" },
route53_hosted_zone_cleaned: { type: "boolean" },
worker_domain_bound: { type: "boolean" },
website_origin_configured: { type: "boolean" },
origin_tls_mode_configured: { type: "string", enum: ["strict", "full", "origin_pull"] },
origin_tls_mode_checked_at: { type: "string" },
web_records: { type: "array", items: ref("ProvisionedWebRecord") },
target_checked_at: { type: "string" },
last_provider_status: { type: "string" },
registration_submitted_at: { type: "string" },
nameservers_submitted_at: { type: "string" },
delegation_dns_preserved_count: { type: "integer", minimum: 0 },
delegation_dns_preserved_sha256: { type: "string", pattern: "^[0-9a-f]{64}$" },
delegation_dns_preserved_at: { type: "string" }
}
},
DomainProvisioningJob: {
type: "object",
properties: {
id: { type: "string" },
domain_id: { type: "string" },
name: { type: "string" },
idempotency_key: { type: "string" },
request_hash: { type: "string" },
status: { type: "string", enum: ["requested", "quoted", "registration_submitting", "registration_submitted", "registered", "zone_ready", "nameservers_submitted", "delegated", "worker_bound", "ready", "manual_review", "failed"] },
max_price_usd: { type: "number" },
years: { type: "integer" },
auto_renew: { type: "boolean" },
acquisition_mode: { type: "string", enum: ["purchase", "adopt"] },
registrar: { type: "string", enum: ["route53", "brandsight"] },
dns_provider: { type: "string" },
target: { type: "string" },
worker_name: { anyOf: [{ type: "string" }, { type: "null" }] },
origin_hostname: { anyOf: [{ type: "string" }, { type: "null" }] },
origin_tls_mode: { anyOf: [{ type: "string", enum: ["strict", "full"] }, { type: "null" }] },
provider_state: ref("DomainProvisioningProviderState"),
result: { anyOf: [ref("DomainProvisioningResult"), { type: "null" }] },
attempts: { type: "integer" },
error: { type: "string", nullable: true },
lease_until: { type: "string", nullable: true },
created_at: { type: "string" },
updated_at: { type: "string" }
},
required: ["id", "domain_id", "name", "idempotency_key", "request_hash", "status", "max_price_usd", "years", "auto_renew", "acquisition_mode", "registrar", "dns_provider", "target", "worker_name", "origin_hostname", "origin_tls_mode", "provider_state", "result", "attempts", "created_at", "updated_at"]
},
ProvisionedWebRecord: {
type: "object",
additionalProperties: false,
properties: {
type: { type: "string", enum: ["CNAME"] },
name: { type: "string" },
value: { type: "string" },
proxied: { type: "boolean", enum: [true] },
ttl: { type: "integer", minimum: 1 }
},
required: ["type", "name", "value", "proxied", "ttl"]
},
DomainProvisioningResult: {
type: "object",
additionalProperties: false,
properties: {
zone_ref: { type: "string" },
nameservers: { type: "array", items: { type: "string" } },
web_records: { type: "array", items: ref("ProvisionedWebRecord") },
origin_tls_mode: { anyOf: [{ type: "string", enum: ["strict", "full"] }, { type: "null" }] },
checked_at: { type: "string" }
},
required: ["zone_ref", "nameservers", "web_records", "origin_tls_mode", "checked_at"]
},
HostedDnsRecord: dnsRecordSchema,
ReconciliationDnsRecord: {
...dnsRecordSchema,
description: "TTL 1 is accepted only with an exact-state guard retaining an identical existing provider record. Ordinary requests require TTL 60-86400.",
properties: { ...dnsRecordSchema.properties, ttl: { anyOf: [dnsRecordSchema.properties.ttl, { type: "integer", enum: [1] }] } }
},
EffectiveHostedDnsRecord: {
...dnsRecordSchema,
properties: { ...dnsRecordSchema.properties, semantic_value: { type: "string", readOnly: true, description: "Domains-derived TXT semantic value. Raw value is unchanged. Absent for legacy or unsupported presentation." }, ttl: { anyOf: [dnsRecordSchema.properties.ttl, { type: "integer", enum: [1] }] } }
},
DomainDnsRecordState: {
type: "object",
description: "records_sha256 is SHA256 of UTF-8 JSON with keys hash_scheme, zone_id, record_name, record_type, records in that order. Each record has keys id,type,name,value,ttl,priority,proxied in that order; records sort lexically by provider id. Null means absent priority/proxied. Domain/job identity fields and records_sha256 are excluded. All provider pages are read; oversized groups refuse instead of truncating.",
properties: {
hash_scheme: { type: "string", enum: ["domains-dns-group-v1"] },
domain_name: { type: "string" },
provisioning_job_id: { type: "string" },
zone_id: { type: "string" },
record_name: { type: "string" },
record_type: { type: "string", enum: ["TXT", "CNAME", "MX"] },
records_sha256: { type: "string", pattern: "^[a-f0-9]{64}$" },
records: { type: "array", maxItems: 1000, items: { type: "object", properties: {
id: { type: "string" },
type: { type: "string" },
name: { type: "string" },
value: { type: "string" },
ttl: { type: "integer" },
priority: { anyOf: [{ type: "integer" }, { type: "null" }] },
proxied: { anyOf: [{ type: "boolean" }, { type: "null" }] }
}, required: ["id", "type", "name", "value", "ttl", "priority", "proxied"] } }
},
required: ["hash_scheme", "domain_name", "provisioning_job_id", "zone_id", "record_name", "record_type", "records_sha256", "records"]
},
DomainDnsReconciliationRequest: {
type: "object",
additionalProperties: false,
properties: {
records: { type: "array", minItems: 1, maxItems: 20, items: ref("ReconciliationDnsRecord") },
expected_current_records_sha256: { type: "string", pattern: "^[a-f0-9]{64}$", description: "Optional dns-state guard for exactly one generic name/type group. Compared under the zone lock before writes; exact matches retain provider identities. Not supported by the mail route. Cloudflare external writers are not atomic with this comparison." }
},
required: ["records"]
},
DomainDnsReconciliation: {
type: "object",
properties: {
id: { type: "string" },
provisioning_job_id: { type: "string" },
domain_name: { type: "string" },
idempotency_key: { type: "string" },
request_hash: { type: "string" },
status: { type: "string", enum: ["requested", "applying", "ready", "manual_review"] },
records: { type: "array", items: ref("ReconciliationDnsRecord") },
result: { anyOf: [{ type: "object", properties: {
records: { type: "array", items: ref("EffectiveHostedDnsRecord") },
checked_at: { type: "string" }
}, required: ["records", "checked_at"] }, { type: "null" }] },
error: { anyOf: [{ type: "string" }, { type: "null" }] },
lease_until: { anyOf: [{ type: "string" }, { type: "null" }] },
created_at: { type: "string" },
updated_at: { type: "string" }
},
required: ["id", "provisioning_job_id", "domain_name", "idempotency_key", "request_hash", "status", "records", "result", "error", "lease_until", "created_at", "updated_at"]
},
Domain: {
type: "object",
properties: {
id: { type: "string" },
name: { type: "string" },
registrar: { type: "string", nullable: true },
status: { type: "string" },
registered_at: { type: "string", nullable: true },
expires_at: { type: "string", nullable: true },
auto_renew: { type: "boolean" },
is_premium: { type: "boolean" },
premium_price: { type: "number", nullable: true },
standard_price: { type: "number", nullable: true },
purchase_price: { type: "number", nullable: true },
purchase_date: { type: "string", nullable: true },
nameservers: { type: "array", items: { type: "string" } },
whois: { type: "object", additionalProperties: true },
ssl_expires_at: { type: "string", nullable: true },
ssl_issuer: { type: "string", nullable: true },
notes: { type: "string", nullable: true },
metadata: { type: "object", additionalProperties: true },
created_at: { type: "string" },
updated_at: { type: "string" }
},
required: ["id", "name", "status", "auto_renew", "is_premium", "created_at", "updated_at"]
},
DomainList: {
type: "object",
properties: {
domains: { type: "array", items: ref("Domain") },
count: { type: "integer" }
},
required: ["domains", "count"]
},
CreateDomainInput: {
type: "object",
properties: {
name: { type: "string" },
registrar: { type: "string" },
status: { type: "string" },
registered_at: { type: "string" },
expires_at: { type: "string" },
auto_renew: { type: "boolean" },
is_premium: { type: "boolean" },
premium_price: { type: "number" },
standard_price: { type: "number" },
purchase_price: { type: "number" },
purchase_date: { type: "string" },
nameservers: { type: "array", items: { type: "string" } },
whois: { type: "object", additionalProperties: true },
ssl_expires_at: { type: "string" },
ssl_issuer: { type: "string" },
notes: { type: "string" },
metadata: { type: "object", additionalProperties: true }
},
required: ["name"]
},
UpdateDomainInput: {
type: "object",
properties: {
name: { type: "string" },
registrar: { type: "string", nullable: true },
status: { type: "string" },
registered_at: { type: "string", nullable: true },
expires_at: { type: "string", nullable: true },
auto_renew: { type: "boolean" },
is_premium: { type: "boolean" },
premium_price: { type: "number", nullable: true },
standard_price: { type: "number", nullable: true },
purchase_price: { type: "number", nullable: true },
purchase_date: { type: "string", nullable: true },
nameservers: { type: "array", items: { type: "string" } },
whois: { type: "object", additionalProperties: true },
ssl_expires_at: { type: "string", nullable: true },
ssl_issuer: { type: "string", nullable: true },
notes: { type: "string", nullable: true },
metadata: { type: "object", additionalProperties: true }
}
},
DnsRecord: {
type: "object",
properties: {
id: { type: "string" },
domain_id: { type: "string" },
type: { type: "string" },
name: { type: "string" },
value: { type: "string" },
ttl: { type: "integer" },
priority: { type: "integer", nullable: true },
created_at: { type: "string" }
},
required: ["id", "domain_id", "type", "name", "value", "ttl", "created_at"]
},
DnsRecordList: {
type: "object",
properties: {
records: { type: "array", items: ref("DnsRecord") },
count: { type: "integer" }
},
required: ["records", "count"]
},
CreateDnsRecordInput: {
type: "object",
properties: {
type: { type: "string", enum: ["A", "AAAA", "CNAME", "MX", "TXT", "NS", "SRV"] },
name: { type: "string" },
value: { type: "string" },
ttl: { type: "integer" },
priority: { type: "integer" }
},
required: ["type", "name", "value"]
},
DomainOffer: {
type: "object",
properties: {
id: { type: "string" },
domain_id: { type: "string" },
our_offer: { type: "number", nullable: true },
their_ask: { type: "number", nullable: true },
status: { type: "string" },
notes: { type: "string", nullable: true },
created_at: { type: "string" }
},
required: ["id", "domain_id", "status", "created_at"]
},
OfferList: {
type: "object",
properties: {
offers: { type: "array", items: ref("DomainOffer") },
count: { type: "integer" }
},
required: ["offers", "count"]
},
CreateOfferInput: {
type: "object",
properties: {
our_offer: { type: "number" },
their_ask: { type: "number" },
status: { type: "string" },
notes: { type: "string" }
}
},
DomainStats: {
type: "object",
properties: {
total: { type: "integer" },
active: { type: "integer" },
expired: { type: "integer" },
transferring: { type: "integer" },
redemption: { type: "integer" },
auto_renew_enabled: { type: "integer" },
expiring_30_days: { type: "integer" },
ssl_expiring_30_days: { type: "integer" }
},
required: ["total"]
}
}
}
};
}
// src/lib/dns-txt.ts
function decodeDnsTxt(value) {
const input = value.trim();
if (!input.startsWith('"'))
return value;
let result = "";
let i = 0;
while (i < input.length) {
if (input[i++] !== '"')
throw new Error("Malformed DNS TXT presentation");
let closed = false;
while (i < input.length) {
let char = input[i++];
if (char === '"') {
closed = true;
break;
}
if (char === "\\") {
if (i === input.length)
throw new Error("Malformed DNS TXT escape");
if (/\d/u.test(input[i])) {
const digits = input.slice(i, i + 3);
if (!/^\d{3}$/u.test(digits) || Number(digits) > 255)
throw new Error("Malformed DNS TXT octet");
char = String.fromCharCode(Number(digits));
i += 3;
} else
char = input[i++];
}
if (/[\x00-\x1f\x7f]/u.test(char))
throw new Error("DNS TXT control character is not supported");
result += char;
}
if (!closed)
throw new Error("Unterminated DNS TXT string");
if (i < input.length && !/\s/u.test(input[i]))
throw new Error("Malformed DNS TXT string separator");
while (i < input.length && /\s/u.test(input[i]))
i++;
}
return result;
}
function mailPolicyKind(value) {
const semantic = decodeDnsTxt(value).trim();
if (/^v=spf1(?:\s|$)/iu.test(semantic))
return "spf";
if (/^v=DMARC1(?:;|\s|$)/iu.test(semantic))
return "dmarc";
return null;
}
// src/lib/provisioning.ts
import { createHash as createHash4, randomUUID } from "crypto";
// src/db/dns-tools.ts
import { domainToASCII } from "url";
// ../contracts/dist/client/transport.js
import { createRequire } from "module";
var MAX_PACKAGE_BYTES = 1024 * 1024;
var MAX_CREDENTIAL_FILE_BYTES = 64 * 1024;
var INSPECT_CUSTOM = Symbol.for("nodejs.util.inspect.custom");
var CREDENTIAL_SEAL = Symbol.for("hasna:contracts:sealedCredential");
var AMBIENT_ENVIRONMENT = Symbol.for("hasna:contracts:ambientClientEnvironment");
var requireSecretsSdk = createRequire(import.meta.url);
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"
]);
// ../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"
]);
// src/lib/domains-resolver.ts
var CONTRACTS_AMBIENT_ENVIRONMENT = Symbol.for("hasna:contracts:ambientClientEnvironment");
// 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 });
}
// src/lib/env-aliases.ts
function firstEnv(env, names) {
for (const key of names) {
const value = env[key];
if (value)
return { key, value };
}
return;
}
var BRANDSIGHT_ENV = {
apiKey: ["BRANDSIGHT_API_KEY"],
apiSecret: ["BRANDSIGHT_API_SECRET"],
customerId: ["BRANDSIGHT_CUSTOMER_ID"],
shopperId: ["BRANDSIGHT_SHOPPER_ID"],
accountId: ["BRANDSIGHT_ACCOUNT_ID"]
};
var CLOUDFLARE_ENV = {
apiToken: ["CLOUDFLARE_API_TOKEN"],
apiKey: ["CLOUDFLARE_API_KEY"],
email: ["CLOUDFLARE_EMAIL"],
accountId: ["CLOUDFLARE_ACCOUNT_ID"]
};
// 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 getConfig() {
return resolveBrandsightConfig();
}
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 requireDomainConfig(config) {
const cfg = config ?? getConfig();
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
};
}
async function listDomains(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 getDomainInfo(domain, config) {
const cfg = requireDomainConfig(config);
const result = await domainApiRequest("GET", customerPath(cfg, `/domains/${encodeURIComponent(domain)}`), cfg);
return normalizeBrandsightDomain(result);
}
async function checkAvailability(domain, config) {
const cfg = requireDomainConfig(config);
return domainAvailability(domain, cfg, "REGISTRATION", 1);
}
async function renewDomain(domain, years = 1, config) {
const cfg = requireDomainConfig(config);
const current = await getDomainInfo(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 updateNameservers(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 getDnsRecords(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 setDnsRecords(domain, records, config) {
const cfg = requireDomainConfig(config);
await domainApiRequest("PUT", customerPath(cfg, `/domains/${encodeURIComponent(domain)}/records`), cfg, records.map(normalizeBrandsightDnsRecord));
return true;
}
async function syncToLocalDb(dbFns, config) {
const domains = await listDomains(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 ?? getConfig();
return {
name: "brandsight",
async listDomains() {
const domains = await listDomains(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 getDomainInfo(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 renewDomain(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 updateNameservers(domain, nameservers, cfg);
return { domain, success: result.success, operationId: result.operationId };
},
async getDnsRecords(domain) {
const records = await getDnsRecords(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 setDnsRecords(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 checkAvailability(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 syncToLocalDb(dbFns, cfg);
}
};
}
// src/lib/cloudflare.ts
import { createHash as createHash3 } from "crypto";
// 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 getConfig2() {
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 ?? getConfig2();
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 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 ?? getConfig2();
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;
}
async function getZoneOriginTlsMode(zoneId, config) {
const setting = await cfFetch(`/zones/${encodeURIComponent(zoneId)}/settings/ssl`, { config });
if (setting.id !== "ssl" || typeof setting.value !== "string" || !setting.value.trim()) {
throw new Error("Cloudflare returned an invalid zone SSL setting");
}
const mode = setting.value.trim().toLowerCase();
if (!["off", "flexible", "full", "strict", "origin_pull"].includes(mode)) {
throw new Error(`Cloudflare returned unsupported zone SSL setting ${mode}`);
}
return mode;
}
async function ensureZoneOriginTlsMode(zoneId, requested, config) {
const current = await getZoneOriginTlsMode(zoneId, config);
if (current === "origin_pull" || current === "strict" && requested === "full") {
return { mode: current, changed: false, downgradeRefused: true };
}
let changed = false;
if (current !== requested) {
await cfFetch(`/zones/${encodeURIComponent(zoneId)}/settings/ssl`, { method: "PATCH", body: { value: requested }, config });
changed = true;
}
const readback = await getZoneOriginTlsMode(zoneId, config);
if (readback !== requested) {
throw new Error(`Cloudflare zone SSL setting readback is ${readback}, expected ${requested}`);
}
return { mode: requested, changed, downgradeRefused: false };
}
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";
}
}
var DNS_MAIL_RECONCILIATION_TIMEOUT_MS = 25000;
async function listRecords(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
}));
}
async function upsertRecord(zoneId, record, config) {
const existing = await listRecordsByNameType(zoneId, record.type, record.name, config);
const body = {
type: record.type,
name: record.name,
content: record.content,
ttl: record.ttl ?? 1,
priority: record.priority,
proxied: record.proxied ?? false
};
const sameRecord = existing.find((r) => r.content === record.content && (r.priority ?? undefined) === (record.priority ?? undefined) && (r.proxied ?? false) === (record.proxied ?? false));
if (sameRecord?.id) {
await cfFetch(`/zones/${zoneId}/dns_records/${sameRecord.id}`, { method: "PUT", body, config });
} else {
await cfFetch(`/zones/${zoneId}/dns_records`, { method: "POST", body, config });
}
}
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 deleteRecord(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 getDnsRecordGroupState(zoneId, type, name, config, options = {}) {
const records = (await listRecords(zoneId, config, options)).filter((record) => record.type === type && record.name.toLowerCase().replace(/\.$/u, "") === name).map((record) => {
if (!record.id)
throw new Error("DNS state record has no provider identity");
return {
id: record.id,
type: record.type,
name: record.name,
value: record.content,
ttl: record.ttl,
priority: record.priority ?? null,
proxied: record.proxied ?? null
};
}).sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0);
if (records.length > 1000 || new Set(records.map((record) => record.id)).size !== records.length) {
throw new Error("DNS state group is oversized or has ambiguous provider identities");
}
const state = { hash_scheme: "domains-dns-group-v1", zone_id: zoneId, record_name: name, record_type: type, records };
return { ...state, records_sha256: createHash3("sha256").update(JSON.stringify(state)).digest("hex") };
}
async function reconcileGuardedRecords(zoneId, desired, expectedHash, config, assertLease = async () => {}) {
const first = desired[0];
if (!first || desired.some((record) => record.type !== first.type || record.name !== first.name))
throw new Error("DNS guard requires exactly one record group");
await assertLease();
const before = await getDnsRecordGroupState(zoneId, first.type, first.name, config, { assertLease });
if (before.records_sha256 !== expectedHash)
throw new Error("DNS current record state does not match expected_current_records_sha256");
const existing = before.records.map((record) => ({
id: record.id,
type: record.type,
name: record.name,
content: record.value,
ttl: record.ttl,
...record.priority === null ? {} : { priority: record.priority },
...record.proxied === null ? {} : { proxied: record.proxied }
}));
const targets = resolveDesiredProxied(desired, existing);
const matches = (actual, target) => sameRecordIdentity(actual, target) && actual.ttl === target.ttl && (target.proxied === undefined || actual.proxied === target.proxied);
const remaining = [...existing];
const retained = [];
const additions = [];
for (const target of targets) {
const index = remaining.findIndex((record) => matches(record, target));
if (index < 0)
additions.push(target);
else
retained.push(remaining.splice(index, 1)[0]);
}
if (additions.some((record) => record.ttl === 1))
throw new Error("Guarded automatic TTL requires an exact retained provider record");
await assertLease();
if ((await getDnsRecordGroupState(zoneId, first.type, first.name, config, { assertLease })).records_sha256 !== expectedHash)
throw new Error("DNS record group changed before mutation");
for (const record of remaining) {
await assertLease();
await deleteRecord(zoneId, record.id, config);
}
for (const record of additions) {
await assertLease();
await cfFetch(`/zones/${zoneId}/dns_records`, { method: "POST", body: record, config });
}
await assertLease();
const after = await getDnsRecordGroupState(zoneId, first.type, first.name, config, { assertLease });
const actual = after.records.map((record) => ({
id: record.id,
type: record.type,
name: record.name,
content: record.value,
ttl: record.ttl,
...record.priority === null ? {} : { priority: record.priority },
...record.proxied === null ? {} : { proxied: record.proxied }
}));
if (actual.length !== targets.length || !targets.every((target) => actual.some((record) => matches(record, target))) || !retained.every((original) => actual.some((record) => record.id === original.id && matches(record, original)))) {
throw new Error("Guarded DNS complete record group readback mismatch");
}
return after;
}
async function reconcileMailRecords(zoneId, records, config, assertLease = async () => {}, operationDeadline = performance.now() + DNS_MAIL_RECONCILIATION_TIMEOUT_MS) {
const deadline = Math.min(operationDeadline, performance.now() + DNS_MAIL_RECONCILIATION_TIMEOUT_MS);
const remaining = () => {
const milliseconds = deadline - performance.now();
if (!Number.isFinite(milliseconds) || milliseconds < 1)
throw new Error("DNS reconciliation time budget exhausted");
return Math.floor(milliseconds);
};
const assertOperation = async () => {
remaining();
await assertLease();
remaining();
};
const applied = [];
for (const desired of records) {
const all = await listRecords(zoneId, config, { assertLease: assertOperation, deadline });
const named = all.filter((record) => record.name.toLowerCase().replace(/\.$/u, "") === desired.name);
const existing = named.filter((record) => record.type === desired.type);
const kind = desired.type === "TXT" ? mailPolicyKind(desired.content) : null;
const dmarc = kind === "dmarc";
const spf = kind === "spf";
const policies = existing.filter((record) => kind !== null && mailPolicyKind(record.content) === kind);
if ((dmarc || spf) && policies.length > 1)
throw new Error("Multiple existing mail policies require review");
if (dmarc && policies[0]) {
applied.push(policies[0]);
continue;
}
const exact = existing.find((record) => sameRecordIdentity(record, desired) && (desired.type !== "CNAME" || record.proxied === false));
if (exact) {
applied.push(exact);
continue;
}
if (spf && policies[0]) {
const current = policies[0];
const tokens = decodeDnsTxt(current.content).trim().split(/\s+/u);
const known = new Set(tokens.map((token) => token.toLowerCase()));
const inserts = decodeDnsTxt(desired.content).trim().split(/\s+/u).slice(1).filter((token) => !/^[+?~-]?all$/iu.test(token) && !known.has(token.toLowerCase()));
if (inserts.some((token) => !/^include:[a-z0-9.-]+$/iu.test(token))) {
throw new Error("Mail preservation accepts only additional SPF includes");
}
if (inserts.length === 0) {
applied.push(current);
continue;
}
const terminal = tokens.findIndex((token) => /^[+?~-]?all$/iu.test(token));
tokens.splice(terminal < 0 ? tokens.length : terminal, 0, ...inserts);
if (!current.id)
throw new Error("Existing SPF record has no provider identity");
const updated = { ...current, content: tokens.join(" ") };
await assertOperation();
const fresh = await listRecords(zoneId, config, { assertLease: assertOperation, deadline });
const freshPolicies = fresh.filter((record) => record.type === "TXT" && record.name === current.name && mailPolicyKind(record.content) === "spf");
const same = freshPolicies.length === 1 ? freshPolicies.find((record) => record.id === current.id) : undefined;
if (!same || JSON.stringify(same) !== JSON.stringify(current))
throw new Error("SPF record changed during reconciliation");
await assertOperation();
await cfFetch(`/zones/${zoneId}/dns_records/${current.id}`, {
method: "PATCH",
body: { content: updated.content },
config,
timeoutMs: remaining()
});
await assertOperation();
applied.push(updated);
continue;
}
if (desired.type !== "TXT" && existing.length > 0)
throw new Error("Existing mail record conflicts with requested authorization");
if (named.some((record) => record.type === "CNAME") && desired.type !== "CNAME" && named.some((record) => record.type === "CNAME" && record.proxied !== true)) {
throw new Error("Mail record conflicts with an existing CNAME");
}
if (desired.type === "CNAME" && named.length > 0)
throw new Error("Mail CNAME conflicts with existing records");
await assertOperation();
await cfFetch(`/zones/${zoneId}/dns_records`, { method: "POST", body: desired, config, timeoutMs: remaining() });
await assertOperation();
applied.push(desired);
}
return applied;
}
async function deleteRecord(zoneId, recordId, config) {
await cfFetch(`/zones/${zoneId}/dns_records/${recordId}`, { method: "DELETE", config });
}
async function deleteRecordByNameType(zoneId, name, type, config) {
const existing = await cfFetch(`/zones/${zoneId}/dns_records?type=${type}&name=${encodeURIComponent(name)}`, { config });
for (const r of existing ?? []) {
await deleteRecord(zoneId, r.id, config);
}
}
async function listWorkerCustomDomains(config) {
const cfg = config ?? getConfig2();
if (!cfg.accountId)
throw new Error("CLOUDFLARE_ACCOUNT_ID is required for Worker Custom Domains.");
return cfFetch(`/accounts/${encodeURIComponent(cfg.accountId)}/workers/domains`, { config: cfg });
}
async function bindWorkerCustomDomain(hostname, zoneId, workerName = "shortlink-router", config) {
const cfg = config ?? getConfig2();
if (!cfg.accountId)
throw new Error("CLOUDFLARE_ACCOUNT_ID is required for Worker Custom Domains.");
if (!zoneId.trim())
throw new Error("Cloudflare zone id is required for Worker Custom Domains.");
if (!/^[A-Za-z0-9_-]{1,64}$/.test(workerName))
throw new Error("Invalid Cloudflare Worker name.");
return cfFetch(`/accounts/${encodeURIComponent(cfg.accountId)}/workers/domains`, {
method: "PUT",
body: { hostname, service: workerName, zone_id: zoneId },
config: cfg
});
}
async function workerCustomDomainReady(hostname, zoneId, workerName = "shortlink-router", config, fetchImpl = fetch, readiness = {}) {
const domains = await listWorkerCustomDomains(config);
const bound = domains.some((domain) => domain.hostname.toLowerCase() === hostname.toLowerCase() && domain.service === workerName && (domain.zone_id === undefined || domain.zone_id === zoneId) && domain.enabled !== false);
if (!bound)
return false;
try {
const path = readiness.path ?? "/.well-known/shortlink-router";
const header = readiness.header ?? "x-shortlink-router";
const expectedValue = readiness.value ?? workerName;
const response = await fetchImpl(`https://${hostname}${path}`, {
method: "GET",
redirect: "manual",
headers: { accept: "application/json" }
});
const ready = response.status === 200 && response.headers.get(header) === expectedValue;
await response.body?.cancel();
return ready;
} catch {
return false;
}
}
// src/lib/provisioning.ts
var HOSTED_DNS_RECORD_TYPES = ["TXT", "CNAME", "MX"];
function publicDnsReconciliation(reconciliation) {
const { lease_token: _leaseToken, ...safe } = reconciliation;
if (safe.result)
safe.result = { ...safe.result, records: safe.result.records.map((record) => {
const { semantic_value: _ignored, ...raw } = record;
if (raw.type !== "TXT")
return raw;
try {
return { ...raw, semantic_value: decodeDnsTxt(raw.value) };
} catch {
return raw;
}
}) };
return safe;
}
class RegistrarActionRequiredError extends Error {
constructor(message) {
super(message);
this.name = "RegistrarActionRequiredError";
}
}
function isPermanentAdoptionProviderAuthorizationFailure(job, error) {
if (job.acquisition_mode !== "adopt" || job.status !== "zone_ready")
return false;
if (error instanceof CloudflareApiError) {
return error.statusCode === 401 || error.statusCode === 403 || error.providerCode === "10000";
}
return error instanceof BrandsightApiError && (error.statusCode === 401 || error.statusCode === 403);
}
var TERMINAL = new Set(["ready", "manual_review", "failed"]);
function hashProvisioningIntent(value) {
return createHash4("sha256").update(JSON.stringify(value)).digest("hex");
}
function provisioningRequestHash(request) {
return hashProvisioningIntent({
auto_renew: request.auto_renew,
acquisition_mode: request.acquisition_mode,
dns_provider: request.dns_provider,
max_price_usd: request.max_price_usd,
name: request.name,
registrar: request.registrar,
target: request.target,
worker_name: request.worker_name,
origin_hostname: request.origin_hostname,
...request.target === "website_origin" ? { origin_tls_mode: request.origin_tls_mode } : {},
years: request.years
});
}
function provisioningRequestHashMatches(storedHash, currentHash, request) {
const canonicalHash = provisioningRequestHash(request);
if (currentHash !== canonicalHash)
return false;
if (storedHash === canonicalHash)
return true;
if (request.acquisition_mode !== "purchase" || request.target !== "shortlinks" || request.origin_hostname !== null || request.origin_tls_mode !== null)
return false;
const legacyHash = hashProvisioningIntent({
auto_renew: request.auto_renew,
dns_provider: request.dns_provider,
max_price_usd: request.max_price_usd,
name: request.name,
registrar: request.registrar,
target: request.target,
worker_name: request.worker_name,
years: request.years
});
return storedHash === legacyHash;
}
function dnsRecordName(value, domain) {
if (typeof value !== "string")
throw new Error("DNS record name must be a string");
const name = (value.trim() === "@" ? domain : value.trim()).toLowerCase().replace(/\.$/u, "");
if (name.length > 253 || !/^[a-z0-9_](?:[a-z0-9_-]{0,61}[a-z0-9_])?(?:\.[a-z0-9_](?:[a-z0-9_-]{0,61}[a-z0-9_])?)*$/u.test(name) || name !== domain && !name.endsWith(`.${domain}`)) {
throw new Error("DNS record name must be the domain or one of its subdomains");
}
return name;
}
function dnsHostnameValue(value) {
if (typeof value !== "string")
throw new Error("DNS record value must be a hostname");
const hostname = value.trim().toLowerCase().replace(/\.$/u, "");
if (hostname.length > 253 || !/^[a-z0-9_](?:[a-z0-9_-]{0,61}[a-z0-9_])?(?:\.[a-z0-9_](?:[a-z0-9_-]{0,61}[a-z0-9_])?)*$/u.test(hostname)) {
throw new Error("DNS record value must be a hostname");
}
return hostname;
}
function normalizeHostedDnsRecords(value, domainValue, allowRetainedAutomaticTtl = false) {
const domain = normalizeDomainName(domainValue);
if (!Array.isArray(value) || value.length < 1 || value.length > 20) {
throw new Error("records must contain 1-20 DNS records");
}
const records = value.map((raw) => {
if (!raw || typeof raw !== "object" || Array.isArray(raw))
throw new Error("invalid DNS record");
const input = raw;
const type = String(input.type ?? "").toUpperCase();
if (!HOSTED_DNS_RECORD_TYPES.includes(type)) {
throw new Error("hosted DNS reconciliation allows only TXT, CNAME, and MX records");
}
const ttl = Number(input.ttl ?? 300);
if (!Number.isInteger(ttl) || !(allowRetainedAutomaticTtl && ttl === 1) && (ttl < 60 || ttl > 86400)) {
throw new Error("DNS record ttl must be an integer from 60 to 86400");
}
const recordType = type;
const value = recordType === "TXT" ? (() => {
if (typeof input.value !== "string" || !input.value.trim() || input.value.length > 4096 || /[\r\n\0]/u.test(input.value)) {
throw new Error("TXT record value must be 1-4096 characters without control lines");
}
return input.value;
})() : dnsHostnameValue(input.value);
const priority = recordType === "MX" ? Number(input.priority) : null;
if (recordType === "MX" && (!Number.isInteger(priority) || Number(priority) < 0 || Number(priority) > 65535)) {
throw new Error("MX record priority must be an integer from 0 to 65535");
}
if (recordType !== "MX" && input.priority !== undefined && input.priority !== null) {
throw new Error("priority is valid only for MX records");
}
return { type: recordType, name: dnsRecordName(input.name, domain), value, ttl, priority };
});
const canonical = [...records].sort((left, right) => {
const leftJson = JSON.stringify(left);
const rightJson = JSON.stringify(right);
return leftJson < rightJson ? -1 : leftJson > rightJson ? 1 : 0;
});
const identities = canonical.map((record) => JSON.stringify(record));
if (new Set(identities).size !== identities.length)
throw new Error("duplicate DNS records are not allowed");
return canonical;
}
function normalizeRequest(input, shortlinksWorkerName = "shortlink-router") {
const name = normalizeDomainName(String(input.name ?? ""));
const idempotencyKey = String(input.idempotency_key ?? "").trim();
if (!/^[A-Za-z0-9._:-]{8,128}$/.test(idempotencyKey)) {
throw new Error("idempotency_key must be 8-128 safe characters");
}
const maxPrice = Number(input.max_price_usd);
if (!Number.isFinite(maxPrice) || maxPrice <= 0 || maxPrice > 1000) {
throw new Error("max_price_usd must be greater than 0 and at most 1000");
}
const years = Number(input.years ?? 1);
if (!Number.isInteger(years) || years < 1 || years > 10) {
throw new Error("years must be an integer from 1 to 10");
}
if (typeof input.auto_renew !== "boolean") {
throw new Error("auto_renew must be explicitly true or false");
}
const registrar = input.registrar ?? "route53";
const dnsProvider = input.dns_provider ?? "cloudflare";
const target = input.target ?? "shortlinks";
if (registrar !== "route53")
throw new Error("only registrar=route53 is supported by hosted provisioning");
if (dnsProvider !== "cloudflare")
throw new Error("only dns_provider=cloudflare is supported by hosted provisioning");
if (target !== "shortlinks" && target !== "website_origin") {
throw new Error("target must be shortlinks or website_origin");
}
let workerName = null;
let originHostname = null;
let originTlsMode = null;
if (target === "shortlinks") {
if (input.origin_hostname !== undefined && input.origin_hostname !== null) {
throw new Error("origin_hostname is only valid for target=website_origin");
}
if (input.origin_tls_mode !== undefined && input.origin_tls_mode !== null) {
throw new Error("origin_tls_mode is only valid for target=website_origin");
}
workerName = String(input.worker_name ?? shortlinksWorkerName).trim();
if (!/^[A-Za-z0-9_-]{1,64}$/.test(workerName))
throw new Error("invalid worker_name");
} else {
if (input.worker_name !== undefined && input.worker_name !== null) {
throw new Error("worker_name is only valid for target=shortlinks");
}
originHostname = normalizeWebsiteOriginHostname(input.origin_hostname);
const requestedTlsMode = input.origin_tls_mode ?? "strict";
if (requestedTlsMode !== "strict" && requestedTlsMode !== "full") {
throw new Error("origin_tls_mode must be strict or full");
}
originTlsMode = requestedTlsMode;
}
return {
name,
idempotency_key: idempotencyKey,
max_price_usd: maxPrice,
years,
auto_renew: input.auto_renew,
acquisition_mode: "purchase",
registrar,
dns_provider: dnsProvider,
target,
worker_name: workerName,
origin_hostname: originHostname,
origin_tls_mode: originTlsMode
};
}
function adoptionRegistrar(value) {
const normalized = value.trim().toLowerCase().replace(/[^a-z0-9]+/gu, " ").trim();
if (normalized === "route53" || normalized === "route 53" || normalized === "aws route 53" || normalized === "amazon registrar" || normalized === "amazon registrar inc") {
return "route53";
}
if (normalized === "brandsight" || normalized === "godaddy corporate domains") {
return "brandsight";
}
throw new RegistrarActionRequiredError(`owned domain registrar '${value}' is not supported by hosted provisioning`);
}
function normalizeWebsiteOriginHostname(value) {
if (typeof value !== "string") {
throw new Error("origin_hostname is required for target=website_origin");
}
const hostname = value.trim().toLowerCase().replace(/\.$/u, "");
if (hostname.length > 253 || !/^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.[a-z0-9-]+\.elb\.amazonaws\.com$/u.test(hostname)) {
throw new Error("origin_hostname must be an AWS ALB DNS hostname");
}
return hostname;
}
function normalizeNameservers(values) {
return [...new Set(values.map((value) => value.trim().toLowerCase().replace(/\.$/, "")).filter(Boolean))].sort();
}
function nameserversEqual(left, right) {
return JSON.stringify(normalizeNameservers(left)) === JSON.stringify(normalizeNameservers(right));
}
function validatedRoute53Binding(state) {
const ref = state.route53_account_ref;
const fingerprint = state.route53_account_binding_sha256;
if (!ref || !/^[a-z][a-z0-9_-]{0,62}$/u.test(ref) || !fingerprint || !/^[0-9a-f]{64}$/u.test(fingerprint)) {
throw new RegistrarActionRequiredError("Route 53 account binding is missing or invalid");
}
return {
route53_account_ref: ref,
route53_account_binding_sha256: fingerprint
};
}
function route53Binding(job) {
const ref = job.provider_state.route53_account_ref;
const fingerprint = job.provider_state.route53_account_binding_sha256;
if (ref === undefined && fingerprint === undefined)
return;
return validatedRoute53Binding(job.provider_state);
}
function operationVerdict(status) {
const normalized = status.toUpperCase();
if (normalized === "SUCCESSFUL")
return "success";
if (normalized === "ERROR" || normalized === "FAILED")
return "failed";
return "pending";
}
function boundedPurchaseQuote(quote, request) {
if (!quote.available)
return { error: "domain is not available" };
const unitRegistrationPrice = quote.registration_price_usd ?? quote.price_usd;
if (!Number.isFinite(unitRegistrationPrice) || unitRegistrationPrice <= 0) {
return { error: "registrar returned no positive bounded purchase price" };
}
const currency = (quote.currency ?? "USD").toUpperCase();
if (currency !== "USD")
return { error: `registrar returned unsupported currency ${currency}` };
const totalPriceUsd = Number((unitRegistrationPrice * request.years).toFixed(2));
if (totalPriceUsd > request.max_price_usd) {
return { error: `quoted total price exceeds max_price_usd (${totalPriceUsd} > ${request.max_price_usd})` };
}
return { totalPriceUsd, currency: "USD" };
}
function positiveIntegerOption(name, value, fallback) {
const resolved = value ?? fallback;
if (!Number.isSafeInteger(resolved) || resolved <= 0) {
throw new Error(`${name} must be a positive integer`);
}
return resolved;
}
class DomainProvisioningService {
store;
providers;
intervalMs;
batchSize;
leaseMs;
maxAttempts;
shortlinksWorkerName;
now;
log;
timer = null;
scheduledRunActive = false;
constructor(store, providers, options = {}) {
this.store = store;
this.providers = providers;
this.intervalMs = positiveIntegerOption("intervalMs", options.intervalMs, 5000);
this.batchSize = positiveIntegerOption("batchSize", options.batchSize, 5);
this.leaseMs = positiveIntegerOption("leaseMs", options.leaseMs, 60000);
this.maxAttempts = positiveIntegerOption("maxAttempts", options.maxAttempts, 17280);
this.shortlinksWorkerName = options.shortlinksWorkerName?.trim() || "shortlink-router";
if (!/^[A-Za-z0-9_-]{1,64}$/.test(this.shortlinksWorkerName))
throw new Error("shortlinksWorkerName is invalid");
this.now = options.now ?? (() => new Date);
this.log = options.log ?? (() => {});
}
async quote(name) {
const normalized = normalizeDomainName(name);
const quote = await this.providers.checkAvailability(normalized);
return { name: normalized, ...quote };
}
async request(input) {
if (input.acquisition_mode !== undefined && input.acquisition_mode !== "purchase") {
throw new Error("use the adoption endpoint for acquisition_mode=adopt");
}
const normalized = normalizeRequest(input, this.shortlinksWorkerName);
return this.store.reserve(normalized, provisioningRequestHash(normalized));
}
async adopt(input) {
const normalized = normalizeRequest({
name: input.name,
idempotency_key: input.idempotency_key,
max_price_usd: 1,
years: 1,
auto_renew: true,
registrar: "route53",
dns_provider: input.dns_provider,
target: input.target,
worker_name: input.worker_name,
origin_hostname: input.origin_hostname,
origin_tls_mode: input.origin_tls_mode
}, this.shortlinksWorkerName);
const existing = await this.store.getByName(normalized.name);
const portfolio = existing ? null : await this.store.getPortfolioRegistration(normalized.name);
if (!existing && !portfolio) {
throw new RegistrarActionRequiredError("owned domain is not present in the hosted Domains portfolio");
}
if (portfolio && portfolio.status !== "active" && portfolio.status !== "purchased") {
throw new RegistrarActionRequiredError(`owned domain portfolio status '${portfolio.status}' is not eligible for adoption`);
}
const registrar = existing?.registrar ?? adoptionRegistrar(portfolio.registrar);
const request = {
...normalized,
acquisition_mode: "adopt",
max_price_usd: 0,
registrar
};
const hash = provisioningRequestHash(request);
if (await this.store.getByName(request.name)) {
return this.store.reserveAdoption(request, hash, { nameservers: [] });
}
let resolved = null;
let detail;
if (registrar === "route53") {
if (!this.providers.resolveAdoptionAccount) {
throw new RegistrarActionRequiredError("Route 53 adoption account resolution is unavailable");
}
resolved = await this.providers.resolveAdoptionAccount(normalized.name);
detail = resolved?.detail ?? null;
if (resolved)
validatedRoute53Binding(resolved);
} else {
detail = await this.providers.getDomainDetail(normalized.name, registrar);
}
if (!detail) {
throw new RegistrarActionRequiredError(`${registrar} does not report this portfolio domain as already owned`);
}
if (detail.registrar && adoptionRegistrar(detail.registrar) !== registrar) {
throw new RegistrarActionRequiredError("registrar ownership readback does not match the portfolio authority");
}
return this.store.reserveAdoption(request, hash, detail, resolved ? {
route53_account_ref: resolved.route53_account_ref,
route53_account_binding_sha256: resolved.route53_account_binding_sha256
} : undefined);
}
get(id) {
return this.store.get(id);
}
getByName(name) {
return this.store.getByName(normalizeDomainName(name));
}
async listDnsReconciliations(name, query = {}) {
const canonicalName = normalizeDomainName(name);
const limit = query.limit === undefined ? 50 : Number(query.limit);
const offset = query.offset === undefined ? 0 : Number(query.offset);
if (!Number.isSafeInteger(limit) || limit < 1 || limit > 100)
throw new Error("limit must be an integer from 1 to 100");
if (!Number.isSafeInteger(offset) || offset < 0)
throw new Error("offset must be a non-negative integer");
const filters = {};
for (const key of ["id", "idempotency_key"]) {
if (query[key] === undefined)
continue;
if (typeof query[key] !== "string" || !/^[A-Za-z0-9._:-]{1,128}$/u.test(query[key]))
throw new Error(`${key} must contain 1-128 safe characters`);
filters[key] = query[key];
}
const rows = await this.store.listDnsReconciliations(canonicalName, { ...filters, limit: limit + 1, offset });
return { reconciliations: rows.slice(0, limit), next_offset: rows.length > limit ? offset + limit : null };
}
async getDnsState(name, recordName, recordType) {
const canonicalName = normalizeDomainName(name);
if (!HOSTED_DNS_RECORD_TYPES.includes(recordType))
throw new Error("record_type must be TXT, CNAME or MX");
if (typeof recordName !== "string")
throw new Error("record_name is required");
const canonicalRecordName = dnsRecordName(recordName, canonicalName);
const job = await this.store.getByName(canonicalName);
if (!job || job.status !== "ready")
throw new Error("domain provisioning job is not ready");
const zoneId = job.provider_state.cloudflare_zone_id;
if (!zoneId || !this.providers.getDnsRecordState)
throw new Error("DNS state provider is not configured");
return this.store.withDnsZoneLock(zoneId, async () => ({
...await this.providers.getDnsRecordState({ zoneId, recordName: canonicalRecordName, recordType }),
domain_name: canonicalName,
provisioning_job_id: job.id
}));
}
async reconcileDns(name, input) {
const deadline = performance.now() + DNS_MAIL_RECONCILIATION_TIMEOUT_MS;
const canonicalName = normalizeDomainName(name);
const idempotencyKey = String(input.idempotency_key ?? "").trim();
if (!/^[A-Za-z0-9._:-]{8,128}$/.test(idempotencyKey)) {
throw new Error("idempotency_key must be 8-128 safe characters");
}
if (input.mode !== undefined && input.mode !== "preserve_mail")
throw new Error("unsupported DNS reconciliation mode");
const mode = input.mode;
const expectedHash = input.expected_current_records_sha256;
if (expectedHash !== undefined && (typeof expectedHash !== "string" || !/^[a-f0-9]{64}$/u.test(expectedHash)))
throw new Error("expected_current_records_sha256 must be a lowercase SHA256 hash");
const records = normalizeHostedDnsRecords(input.records, canonicalName, expectedHash !== undefined);
if (expectedHash !== undefined && (mode || new Set(records.map((record) => `${record.type}|${record.name}`)).size !== 1))
throw new Error("DNS state guard supports exactly one generic record group");
const job = await this.store.getByName(canonicalName);
if (!job || job.status !== "ready")
throw new Error("domain provisioning job is not ready");
const zoneId = job.provider_state.cloudflare_zone_id;
if (!zoneId)
throw new Error("provisioned domain has no DNS zone");
const hash = createHash4("sha256").update(JSON.stringify({
domain_name: canonicalName,
records,
...mode ? { mode } : {},
...expectedHash !== undefined ? { expected_current_records_sha256: expectedHash } : {}
})).digest("hex");
return this.store.withDnsZoneLock(zoneId, async (store) => {
let reconciliation = await store.reserveDnsReconciliation({
job,
idempotencyKey,
requestHash: hash,
records
});
if (reconciliation.status === "ready")
return reconciliation;
const leaseToken = randomUUID();
const leaseUntil = new Date(this.now().getTime() + this.leaseMs).toISOString();
const claimed = await store.claimDnsReconciliation(reconciliation.id, leaseToken, leaseUntil);
if (!claimed)
return reconciliation;
const assertLease = async () => {
if (mode && performance.now() >= deadline)
throw new Error("DNS reconciliation time budget exhausted");
if (!claimed.lease_until || new Date(claimed.lease_until).getTime() <= this.now().getTime()) {
throw new Error("DNS reconciliation lease expired");
}
if (!await store.updateDnsReconciliation(claimed.id, { status: "applying" }, leaseToken)) {
throw new Error("DNS reconciliation lease lost");
}
if (new Date(claimed.lease_until).getTime() <= this.now().getTime())
throw new Error("DNS reconciliation lease expired");
if (mode && performance.now() >= deadline)
throw new Error("DNS reconciliation time budget exhausted");
};
try {
await assertLease();
const appliedResult = await this.providers.reconcileDnsRecords({
hostname: canonicalName,
zoneId,
records,
...mode ? { mode, assertLease, deadline } : {},
...expectedHash !== undefined ? { expectedCurrentRecordsSha256: expectedHash, assertLease } : {}
});
const applied = Array.isArray(appliedResult) ? appliedResult : appliedResult.records;
const verifiedGroup = Array.isArray(appliedResult) ? undefined : appliedResult.verifiedGroup;
if (expectedHash !== undefined && (!verifiedGroup || verifiedGroup.zone_id !== zoneId || verifiedGroup.record_name !== records[0].name || verifiedGroup.record_type !== records[0].type)) {
throw new Error("Guarded DNS provider did not return bound complete-group verification");
}
await assertLease();
if (!await this.providers.dnsRecordsReady({ hostname: canonicalName, zoneId, records: applied, assertLease, ...mode ? { mode, deadline } : {}, ...verifiedGroup ? { verifiedGroup } : {} })) {
throw new Error("DNS provider readback does not match the requested records");
}
await assertLease();
reconciliation = await store.updateDnsReconciliation(claimed.id, {
status: "ready",
result: { records: applied, checked_at: this.now().toISOString() },
error: null,
lease_token: null,
lease_until: null
}, leaseToken);
if (!reconciliation)
throw new Error("DNS reconciliation lease lost before receipt");
return reconciliation;
} catch (error) {
const updated = await store.updateDnsReconciliation(claimed.id, {
status: "manual_review",
error: `DNS reconciliation outcome requires review: ${error instanceof Error ? error.message : String(error)}`.slice(0, 1000),
lease_token: null,
lease_until: null
}, leaseToken);
return updated ?? claimed;
}
});
}
async advance(id) {
const leaseToken = randomUUID();
const leaseUntil = new Date(this.now().getTime() + this.leaseMs).toISOString();
const claimed = await this.store.claim(id, leaseToken, leaseUntil);
if (!claimed) {
const current = await this.store.get(id);
if (!current)
throw new Error("provisioning job not found");
return current;
}
try {
if (TERMINAL.has(claimed.status))
return claimed;
if (claimed.attempts >= this.maxAttempts) {
return await this.store.update(claimed.id, {
status: "failed",
attempts: claimed.attempts + 1,
error: "provisioning attempt limit exceeded",
lease_token: null,
lease_until: null
}, leaseToken);
}
const advanced = await this.advanceClaimed(claimed, leaseToken);
this.log("domain_provisioning_advanced", {
id: advanced.id,
name: advanced.name,
status: advanced.status,
attempts: advanced.attempts
});
return advanced;
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
const ambiguous = claimed.status === "registration_submitting";
const actionRequired = error instanceof RegistrarActionRequiredError || isPermanentAdoptionProviderAuthorizationFailure(claimed, error);
const status = ambiguous || actionRequired ? "manual_review" : claimed.status;
const updated = await this.store.update(claimed.id, {
status,
attempts: claimed.attempts + 1,
error: message.slice(0, 1000),
lease_token: null,
lease_until: null
}, leaseToken);
this.log("domain_provisioning_error", {
id: claimed.id,
name: claimed.name,
status,
error: message.slice(0, 300)
});
return updated ?? claimed;
}
}
async advanceClaimed(job, leaseToken) {
const nextAttempts = job.attempts + 1;
const clearLease = { lease_token: null, lease_until: null };
const update = async (patch) => {
const transitioned = patch.status !== undefined && patch.status !== job.status;
const attempts = patch.attempts ?? (transitioned ? 0 : nextAttempts);
return await this.store.update(job.id, { attempts, error: null, ...patch }, leaseToken);
};
if (job.acquisition_mode === "adopt" && job.registrar === "route53") {
const detail = await this.providers.getDomainDetail(job.name, job.registrar, route53Binding(job));
if (!detail) {
return update({ status: "manual_review", error: "bound Route 53 account no longer reports this domain as owned", ...clearLease });
}
if (detail.registrar && adoptionRegistrar(detail.registrar) !== "route53") {
return update({ status: "manual_review", error: "bound Route 53 ownership readback changed registrar authority", ...clearLease });
}
}
switch (job.status) {
case "requested": {
const quote = boundedPurchaseQuote(await this.providers.checkAvailability(job.name), job);
if ("error" in quote)
return update({ status: "failed", error: quote.error, ...clearLease });
return update({
status: "quoted",
provider_state: { ...job.provider_state, quoted_price_usd: quote.totalPriceUsd, currency: quote.currency },
...clearLease
});
}
case "quoted": {
const quote = boundedPurchaseQuote(await this.providers.checkAvailability(job.name), job);
if ("error" in quote)
return update({ status: "failed", error: quote.error, ...clearLease });
const zoneIdsBeforeRegistration = this.providers.listRoute53HostedZoneIds ? await this.providers.listRoute53HostedZoneIds(job.name) : undefined;
const providerState = {
...job.provider_state,
quoted_price_usd: quote.totalPriceUsd,
currency: quote.currency,
...zoneIdsBeforeRegistration ? { route53_zone_ids_before_registration: [...new Set(zoneIdsBeforeRegistration)].sort() } : {},
registration_submitted_at: this.now().toISOString()
};
const submitting = await this.store.update(job.id, {
status: "registration_submitting",
attempts: 0,
error: null,
provider_state: providerState
}, leaseToken);
if (!submitting)
throw new Error("failed to record registration intent");
let submitted;
try {
submitted = await this.providers.submitRegistration({
name: job.name,
years: job.years,
autoRenew: job.auto_renew
});
} catch (error) {
return await this.store.update(job.id, {
status: "manual_review",
error: `registration submission outcome is ambiguous: ${error instanceof Error ? error.message : String(error)}`.slice(0, 1000),
lease_token: null,
lease_until: null
}, leaseToken);
}
return await this.store.update(job.id, {
status: "registration_submitted",
provider_state: { ...submitting.provider_state, registration_operation_id: submitted.operationId },
lease_token: null,
lease_until: null
}, leaseToken);
}
case "registration_submitting": {
const detail = await this.providers.getDomainDetail(job.name, job.registrar, route53Binding(job));
if (!detail)
return update({ status: "manual_review", error: "registration submission outcome is ambiguous", ...clearLease });
return update({ status: "registered", ...clearLease });
}
case "registration_submitted": {
const operationId = job.provider_state.registration_operation_id;
if (!operationId)
return update({ status: "manual_review", error: "registration operation id is missing", ...clearLease });
const status = await this.providers.getOperationStatus(operationId, route53Binding(job));
const verdict = operationVerdict(status.status);
if (verdict === "pending") {
return update({ provider_state: { ...job.provider_state, last_provider_status: status.status }, ...clearLease });
}
if (verdict === "failed") {
return update({ status: "failed", error: status.message || `registration ${status.status}`, ...clearLease });
}
return update({ status: "registered", provider_state: { ...job.provider_state, last_provider_status: status.status }, ...clearLease });
}
case "registered": {
const zone = await this.providers.ensureCloudflareZone(job.name);
return update({
status: "zone_ready",
provider_state: {
...job.provider_state,
cloudflare_zone_id: zone.id,
cloudflare_nameservers: zone.nameservers
},
...clearLease
});
}
case "zone_ready": {
const nameservers = job.provider_state.cloudflare_nameservers ?? [];
if (!nameservers.length)
return update({ status: "failed", error: "Cloudflare zone returned no nameservers", ...clearLease });
const publicNameservers = await this.providers.resolvePublicNameservers(job.name);
if (job.acquisition_mode === "adopt" && nameserversEqual(publicNameservers, nameservers)) {
return update({
status: "delegated",
provider_state: {
...job.provider_state,
last_provider_status: "PUBLIC_NAMESERVERS_ALREADY_DELEGATED"
},
...clearLease
});
}
if (job.acquisition_mode === "adopt") {
const zoneId = job.provider_state.cloudflare_zone_id;
if (!zoneId) {
return update({ status: "manual_review", error: "Cloudflare zone id is missing", ...clearLease });
}
if (job.target === "website_origin") {
if (!job.origin_tls_mode) {
return update({ status: "manual_review", error: "website origin TLS mode is missing", ...clearLease });
}
const tls = await this.providers.ensureWebsiteOriginTls({
zoneId,
requestedMode: job.origin_tls_mode
});
if (tls.downgradeRefused) {
return update({
status: "manual_review",
error: `refused to weaken existing Cloudflare ${tls.mode} origin TLS mode to ${job.origin_tls_mode}`,
provider_state: {
...job.provider_state,
origin_tls_mode_configured: tls.mode,
origin_tls_mode_checked_at: this.now().toISOString()
},
...clearLease
});
}
if (tls.mode !== job.origin_tls_mode) {
return update({
status: "manual_review",
error: `Cloudflare origin TLS readback is ${tls.mode}, expected ${job.origin_tls_mode}`,
provider_state: {
...job.provider_state,
origin_tls_mode_configured: tls.mode,
origin_tls_mode_checked_at: this.now().toISOString()
},
...clearLease
});
}
if (job.provider_state.origin_tls_mode_configured !== job.origin_tls_mode) {
return update({
provider_state: {
...job.provider_state,
origin_tls_mode_configured: job.origin_tls_mode,
origin_tls_mode_checked_at: this.now().toISOString()
},
...clearLease
});
}
}
const hasDnsPreservationCheckpoint = job.provider_state.delegation_dns_preserved_count !== undefined && /^[0-9a-f]{64}$/u.test(job.provider_state.delegation_dns_preserved_sha256 ?? "");
const registrarDetail = await this.providers.getDomainDetail(job.name, job.registrar, route53Binding(job));
if (registrarDetail && nameserversEqual(registrarDetail.nameservers, nameservers)) {
if (!hasDnsPreservationCheckpoint) {
return update({
status: "manual_review",
error: "registrar nameservers changed before the DNS preservation checkpoint was recorded",
...clearLease
});
}
return update({
status: "delegated",
provider_state: {
...job.provider_state,
nameservers_submitted_at: job.provider_state.nameservers_submitted_at ?? this.now().toISOString(),
last_provider_status: "REGISTRAR_NAMESERVERS_ALREADY_DELEGATED"
},
...clearLease
});
}
const preservation = await this.providers.preserveRegistrarDnsBeforeDelegation({
hostname: job.name,
zoneId,
registrar: job.registrar,
route53Binding: route53Binding(job)
});
const previousHash = job.provider_state.delegation_dns_preserved_sha256;
const previousCount = job.provider_state.delegation_dns_preserved_count;
if (previousHash !== preservation.sha256 || previousCount !== preservation.count) {
return update({
provider_state: {
...job.provider_state,
delegation_dns_preserved_count: preservation.count,
delegation_dns_preserved_sha256: preservation.sha256,
delegation_dns_preserved_at: this.now().toISOString()
},
...clearLease
});
}
}
const operation = await this.providers.updateNameservers(job.name, nameservers, job.registrar, route53Binding(job));
if (operation.completed === true) {
return update({
status: "delegated",
provider_state: {
...job.provider_state,
nameserver_operation_id: operation.operationId,
nameservers_submitted_at: this.now().toISOString(),
last_provider_status: "SUCCESSFUL"
},
...clearLease
});
}
return update({
status: "nameservers_submitted",
provider_state: {
...job.provider_state,
nameserver_operation_id: operation.operationId,
nameservers_submitted_at: this.now().toISOString()
},
...clearLease
});
}
case "nameservers_submitted": {
const operationId = job.provider_state.nameserver_operation_id;
if (!operationId)
return update({ status: "manual_review", error: "nameserver operation id is missing", ...clearLease });
const status = await this.providers.getOperationStatus(operationId, route53Binding(job));
const verdict = operationVerdict(status.status);
if (verdict === "pending")
return update({ provider_state: { ...job.provider_state, last_provider_status: status.status }, ...clearLease });
if (verdict === "failed")
return update({ status: "failed", error: status.message || `nameserver update ${status.status}`, ...clearLease });
return update({ status: "delegated", provider_state: { ...job.provider_state, last_provider_status: status.status }, ...clearLease });
}
case "delegated": {
const detail = await this.providers.getDomainDetail(job.name, job.registrar, route53Binding(job));
const zone = await this.providers.ensureCloudflareZone(job.name);
const publicNameservers = await this.providers.resolvePublicNameservers(job.name);
if (!detail || zone.status !== "active" || !nameserversEqual(detail.nameservers, zone.nameservers) || !nameserversEqual(publicNameservers, zone.nameservers)) {
return update({ ...clearLease });
}
let targetState;
if (job.target === "website_origin") {
if (!job.origin_hostname || !job.origin_tls_mode) {
return update({ status: "manual_review", error: "website origin configuration is missing", ...clearLease });
}
const tls = await this.providers.ensureWebsiteOriginTls({
zoneId: zone.id,
requestedMode: job.origin_tls_mode
});
if (tls.downgradeRefused) {
return update({
status: "manual_review",
error: `refused to weaken existing Cloudflare ${tls.mode} origin TLS mode to ${job.origin_tls_mode}`,
provider_state: {
...job.provider_state,
origin_tls_mode_configured: tls.mode,
origin_tls_mode_checked_at: this.now().toISOString()
},
...clearLease
});
}
if (tls.mode !== job.origin_tls_mode) {
return update({
status: "manual_review",
error: `Cloudflare origin TLS readback is ${tls.mode}, expected ${job.origin_tls_mode}`,
provider_state: {
...job.provider_state,
origin_tls_mode_configured: tls.mode,
origin_tls_mode_checked_at: this.now().toISOString()
},
...clearLease
});
}
const webRecords = await this.providers.configureWebsiteOrigin({
hostname: job.name,
zoneId: zone.id,
originHostname: job.origin_hostname
});
targetState = {
website_origin_configured: true,
origin_tls_mode_configured: job.origin_tls_mode,
origin_tls_mode_checked_at: this.now().toISOString(),
web_records: webRecords
};
} else {
if (!job.worker_name) {
return update({ status: "manual_review", error: "worker name is missing", ...clearLease });
}
await this.providers.bindWorkerDomain({
hostname: job.name,
zoneId: zone.id,
workerName: job.worker_name
});
targetState = { worker_domain_bound: true };
}
return update({
status: "worker_bound",
provider_state: {
...job.provider_state,
cloudflare_zone_id: zone.id,
cloudflare_nameservers: zone.nameservers,
...targetState
},
...clearLease
});
}
case "worker_bound": {
const zoneId = job.provider_state.cloudflare_zone_id;
if (!zoneId)
return update({ status: "manual_review", error: "Cloudflare zone id is missing", ...clearLease });
let ready;
if (job.target === "website_origin") {
if (!job.origin_hostname || !job.origin_tls_mode) {
return update({ status: "manual_review", error: "website origin configuration is missing", ...clearLease });
}
ready = await this.providers.websiteOriginReady({
hostname: job.name,
zoneId,
originHostname: job.origin_hostname,
originTlsMode: job.origin_tls_mode
});
} else {
if (!job.worker_name) {
return update({ status: "manual_review", error: "worker name is missing", ...clearLease });
}
ready = await this.providers.workerDomainReady({
hostname: job.name,
zoneId,
workerName: job.worker_name
});
}
if (!ready)
return update({ ...clearLease });
const detail = await this.providers.getDomainDetail(job.name, job.registrar, route53Binding(job));
if (!detail)
return update({ status: "manual_review", error: "registered domain detail is missing", ...clearLease });
let finalProviderState = {
...job.provider_state,
target_checked_at: this.now().toISOString()
};
const baseline = finalProviderState.route53_zone_ids_before_registration;
if (job.registrar === "route53" && job.acquisition_mode === "purchase" && !finalProviderState.route53_hosted_zone_id && baseline && this.providers.listRoute53HostedZoneIds) {
const currentIds = [...new Set(await this.providers.listRoute53HostedZoneIds(job.name))].sort();
const newIds = currentIds.filter((id) => !baseline.includes(id));
if (newIds.length === 1) {
finalProviderState.route53_hosted_zone_id = newIds[0];
} else if (newIds.length > 1) {
this.log("route53_zone_cleanup_skipped", {
id: job.id,
name: job.name,
reason: "multiple new hosted zones appeared after registration"
});
}
}
const readyJob = {
...job,
status: "ready",
provider_state: finalProviderState,
attempts: nextAttempts,
error: null,
lease_token: null,
lease_until: null
};
await this.store.markPortfolioReady(readyJob, detail);
const completed = await update({
status: "ready",
provider_state: finalProviderState,
...clearLease
});
const hostedZoneId = finalProviderState.route53_hosted_zone_id;
if (job.registrar === "route53" && job.acquisition_mode === "purchase" && this.providers.cleanupRoute53HostedZone && hostedZoneId) {
try {
const cleaned = await this.providers.cleanupRoute53HostedZone({
name: job.name,
hostedZoneId,
registrarNameservers: detail.nameservers
});
if (cleaned) {
finalProviderState = { ...finalProviderState, route53_hosted_zone_cleaned: true };
await this.store.update(job.id, { provider_state: finalProviderState });
}
} catch (error) {
this.log("route53_zone_cleanup_deferred", {
id: job.id,
name: job.name,
error: error instanceof Error ? error.message.slice(0, 300) : String(error).slice(0, 300)
});
}
}
return await this.store.get(job.id) ?? completed;
}
default:
return update({ ...clearLease });
}
}
async runOnce() {
const jobs = await this.store.listRunnable(this.batchSize);
let ready = 0;
let failed = 0;
for (const job of jobs) {
const result = await this.advance(job.id);
if (result.status === "ready")
ready++;
if (result.status === "failed" || result.status === "manual_review")
failed++;
}
return { processed: jobs.length, ready, failed };
}
async runScheduledOnce() {
if (this.scheduledRunActive)
return;
this.scheduledRunActive = true;
try {
await this.runOnce();
} catch (error) {
this.log("domain_provisioning_worker_error", {
error: error instanceof Error ? error.message.slice(0, 300) : String(error).slice(0, 300)
});
} finally {
this.scheduledRunActive = false;
}
}
start() {
if (this.timer)
return;
this.timer = setInterval(() => void this.runScheduledOnce(), this.intervalMs);
this.timer.unref?.();
this.runScheduledOnce();
}
stop() {
if (!this.timer)
return;
clearInterval(this.timer);
this.timer = null;
}
}
function publicProvisioningJob(job) {
const { lease_token: _leaseToken, ...safe } = job;
const zoneRef = job.provider_state.cloudflare_zone_id;
const checkedAt = job.provider_state.target_checked_at;
const nameservers = job.provider_state.cloudflare_nameservers;
const webRecords = job.provider_state.web_records;
const configuredTlsMode = job.provider_state.origin_tls_mode_configured;
const result = job.status === "ready" && zoneRef && checkedAt && Array.isArray(nameservers) && (job.target === "shortlinks" || Array.isArray(webRecords) && configuredTlsMode === job.origin_tls_mode) ? {
zone_ref: `zone:${createHash4("sha256").update(zoneRef).digest("hex").slice(0, 24)}`,
nameservers: [...nameservers],
web_records: job.target === "website_origin" ? [...webRecords ?? []] : [],
origin_tls_mode: job.target === "website_origin" ? job.origin_tls_mode : null,
checked_at: checkedAt
} : null;
return { ...safe, result };
}
// src/server/app.ts
async function readReadiness(db, knownIds) {
const start = Date.now();
try {
const rows = await db.many("SELECT id FROM schema_migrations");
const applied = new Set(rows.map((r) => r.id));
const pending = knownIds.filter((id) => !applied.has(id));
return { ok: pending.length === 0, pendingMigrations: pending, latencyMs: Date.now() - start };
} catch (e) {
return {
ok: false,
pendingMigrations: knownIds,
latencyMs: Date.now() - start,
error: e instanceof Error ? e.message : String(e)
};
}
}
var SECURITY_HEADERS = {
"X-Content-Type-Options": "nosniff",
"X-Frame-Options": "DENY",
"Referrer-Policy": "strict-origin-when-cross-origin"
};
function json(data, status = 200) {
return new Response(JSON.stringify(data), {
status,
headers: { "Content-Type": "application/json", ...SECURITY_HEADERS }
});
}
function createServeApp(options) {
const { db, version } = options;
const repo = new DomainsRepo(db);
const migrationIds = buildMigrations().map((m) => m.id);
const spec = buildOpenApiSpec(version);
const verifier = verifyApiKey({
app: "domains",
signingSecret: options.signingSecret,
keyStatus: options.keyStatus,
...options.audit ? { audit: options.audit } : {}
});
async function readBody(req) {
const text = await req.text();
if (!text)
return {};
try {
return JSON.parse(text);
} catch {
throw new HttpError(400, "invalid JSON body");
}
}
async function auth(req, path, scopes) {
const decision = await verifier.authenticate(req.headers, {
method: req.method,
path,
requiredScopes: scopes
});
if (decision.ok)
return null;
return json({ error: decision.message, reason: decision.reason }, decision.status);
}
async function handle(req) {
const url = new URL(req.url);
const path = url.pathname;
const method = req.method;
try {
if (method === "GET" && path === "/health") {
const h = await checkHealth(db);
return json({ status: h.ok ? "ok" : "error", version, latencyMs: h.latencyMs, ...h.error ? { error: h.error } : {} }, h.ok ? 200 : 503);
}
if (method === "GET" && path === "/ready") {
const r = await readReadiness(db, migrationIds);
return json({
status: r.ok ? "ok" : "not_ready",
version,
pendingMigrations: r.pendingMigrations,
...r.error ? { error: r.error } : {}
}, r.ok ? 200 : 503);
}
if (method === "GET" && (path === "/version" || path === "/v1/version")) {
return json({ status: "ok", version });
}
if (method === "GET" && (path === "/openapi.json" || path === "/v1/openapi.json")) {
return json(spec);
}
if (path === "/v1/availability" && method === "POST") {
const denied = await auth(req, path, ["domains:read"]);
if (denied)
return denied;
if (!options.provisioning)
return json({ error: "hosted domain provisioning is not configured" }, 503);
const body = await readBody(req);
if (!body || typeof body.name !== "string")
return json({ error: "name is required" }, 400);
try {
return json(await options.provisioning.quote(body.name));
} catch (error) {
if (error instanceof DnsToolValidationError)
return json({ error: error.message }, 400);
throw error;
}
}
if (path === "/v1/provisioning" && method === "POST") {
const denied = await auth(req, path, ["domains:purchase"]);
if (denied)
return denied;
if (!options.provisioning)
return json({ error: "hosted domain provisioning is not configured" }, 503);
const body = await readBody(req);
const idempotencyKey = req.headers.get("idempotency-key")?.trim() || body?.idempotency_key;
try {
const job = await options.provisioning.request({ ...body, idempotency_key: idempotencyKey });
return json(publicProvisioningJob(job), job.status === "ready" ? 200 : 202);
} catch (error) {
if (error instanceof HttpError)
throw error;
return json({ error: error instanceof Error ? error.message : String(error) }, 400);
}
}
if (path === "/v1/provisioning/adopt" && method === "POST") {
const denied = await auth(req, path, ["domains:write"]);
if (denied)
return denied;
if (!options.provisioning)
return json({ error: "hosted domain provisioning is not configured" }, 503);
const body = await readBody(req);
const idempotencyKey = req.headers.get("idempotency-key")?.trim() || body?.idempotency_key;
try {
const job = await options.provisioning.adopt({ ...body, idempotency_key: idempotencyKey });
return json(publicProvisioningJob(job), job.status === "ready" ? 200 : 202);
} catch (error) {
if (error instanceof HttpError)
throw error;
if (error instanceof DnsToolValidationError)
return json({ error: error.message }, 400);
return json({ error: error instanceof Error ? error.message : String(error) }, 400);
}
}
const receiptsMatch = path.match(/^\/v1\/provisioning\/by-name\/([^/]+)\/dns-reconciliations$/);
if (receiptsMatch && method === "GET") {
const denied = await auth(req, path, ["domains:read"]);
if (denied)
return denied;
if (!options.provisioning?.listDnsReconciliations)
return json({ error: "hosted DNS receipt lookup is not configured" }, 503);
try {
const query = new URL(req.url).searchParams;
const result = await options.provisioning.listDnsReconciliations(decodeURIComponent(receiptsMatch[1]), {
id: query.get("id") ?? undefined,
idempotency_key: query.get("idempotency_key") ?? undefined,
limit: query.get("limit") ?? undefined,
offset: query.get("offset") ?? undefined
});
return json({ reconciliations: result.reconciliations.map(publicDnsReconciliation), next_offset: result.next_offset });
} catch (error) {
if (error instanceof HttpError)
throw error;
return json({ error: error instanceof Error ? error.message : String(error) }, 400);
}
}
const stateMatch = path.match(/^\/v1\/provisioning\/by-name\/([^/]+)\/dns-state$/);
if (stateMatch && method === "GET") {
const denied = await auth(req, path, ["domains:read"]);
if (denied)
return denied;
if (!options.provisioning?.getDnsState)
return json({ error: "hosted DNS state is not configured" }, 503);
try {
const query = new URL(req.url).searchParams;
return json(await options.provisioning.getDnsState(decodeURIComponent(stateMatch[1]), query.get("record_name"), query.get("record_type")));
} catch (error) {
if (error instanceof HttpError)
throw error;
return json({ error: error instanceof Error ? error.message : String(error) }, 400);
}
}
let provisioningMatch = path.match(/^\/v1\/provisioning\/by-name\/([^/]+)\/dns-reconcile(\/mail)?$/);
if (provisioningMatch && method === "POST") {
const denied = await auth(req, path, ["domains:write"]);
if (denied)
return denied;
if (!options.provisioning)
return json({ error: "hosted domain provisioning is not configured" }, 503);
const body = await readBody(req);
const idempotencyKey = req.headers.get("idempotency-key")?.trim() || body?.idempotency_key;
try {
const reconciliation = await options.provisioning.reconcileDns(decodeURIComponent(provisioningMatch[1]), { ...body, idempotency_key: idempotencyKey, mode: provisioningMatch[2] ? "preserve_mail" : undefined });
return json(publicDnsReconciliation(reconciliation), reconciliation.status === "ready" ? 200 : 202);
} catch (error) {
if (error instanceof HttpError)
throw error;
if (error instanceof DnsToolValidationError)
return json({ error: error.message }, 400);
return json({ error: error instanceof Error ? error.message : String(error) }, 400);
}
}
provisioningMatch = path.match(/^\/v1\/provisioning\/by-name\/([^/]+)$/);
if (provisioningMatch && method === "GET") {
const denied = await auth(req, path, ["domains:read"]);
if (denied)
return denied;
if (!options.provisioning)
return json({ error: "hosted domain provisioning is not configured" }, 503);
try {
const job = await options.provisioning.getByName(decodeURIComponent(provisioningMatch[1]));
return job ? json(publicProvisioningJob(job)) : json({ error: "provisioning job not found" }, 404);
} catch (error) {
if (error instanceof DnsToolValidationError)
return json({ error: error.message }, 400);
throw error;
}
}
provisioningMatch = path.match(/^\/v1\/provisioning\/([^/]+)$/);
if (provisioningMatch && method === "GET") {
const denied = await auth(req, path, ["domains:read"]);
if (denied)
return denied;
if (!options.provisioning)
return json({ error: "hosted domain provisioning is not configured" }, 503);
const job = await options.provisioning.get(decodeURIComponent(provisioningMatch[1]));
return job ? json(publicProvisioningJob(job)) : json({ error: "provisioning job not found" }, 404);
}
provisioningMatch = path.match(/^\/v1\/provisioning\/([^/]+)\/advance$/);
if (provisioningMatch && method === "POST") {
const denied = await auth(req, path, ["domains:purchase"]);
if (denied)
return denied;
if (!options.provisioning)
return json({ error: "hosted domain provisioning is not configured" }, 503);
try {
const job = await options.provisioning.advance(decodeURIComponent(provisioningMatch[1]));
return json(publicProvisioningJob(job), job.status === "ready" || job.status === "failed" || job.status === "manual_review" ? 200 : 202);
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
return /not found/i.test(message) ? json({ error: message }, 404) : json({ error: message }, 500);
}
}
if (path === "/v1/domains") {
if (method === "GET") {
const denied = await auth(req, path, ["domains:read"]);
if (denied)
return denied;
const domains = await repo.listDomains({
search: url.searchParams.get("search") ?? undefined,
status: url.searchParams.get("status") ?? undefined,
limit: url.searchParams.get("limit") ? Number(url.searchParams.get("limit")) : undefined,
offset: url.searchParams.get("offset") ? Number(url.searchParams.get("offset")) : undefined
});
return json({ domains, count: domains.length });
}
if (method === "POST") {
const denied = await auth(req, path, ["domains:write"]);
if (denied)
return denied;
const domain = await repo.createDomain(await readBody(req));
return json(domain, 201);
}
}
if (method === "GET" && path === "/v1/stats") {
const denied = await auth(req, path, ["domains:read"]);
if (denied)
return denied;
return json(await repo.getStats());
}
let m = path.match(/^\/v1\/domains\/([^/]+)$/);
if (m) {
const id = decodeURIComponent(m[1]);
if (method === "GET") {
const denied = await auth(req, path, ["domains:read"]);
if (denied)
return denied;
const domain = await repo.getDomain(id);
return domain ? json(domain) : json({ error: "domain not found" }, 404);
}
if (method === "PATCH" || method === "PUT") {
const denied = await auth(req, path, ["domains:write"]);
if (denied)
return denied;
const domain = await repo.updateDomain(id, await readBody(req));
return domain ? json(domain) : json({ error: "domain not found" }, 404);
}
if (method === "DELETE") {
const denied = await auth(req, path, ["domains:write"]);
if (denied)
return denied;
const deleted = await repo.deleteDomain(id);
return json({ id, deleted });
}
}
m = path.match(/^\/v1\/domains\/([^/]+)\/dns$/);
if (m) {
const id = decodeURIComponent(m[1]);
if (method === "GET") {
const denied = await auth(req, path, ["domains:read"]);
if (denied)
return denied;
const records = await repo.listDnsRecords(id);
return json({ records, count: records.length });
}
if (method === "POST") {
const denied = await auth(req, path, ["domains:write"]);
if (denied)
return denied;
const record = await repo.createDnsRecord(id, await readBody(req));
return json(record, 201);
}
}
m = path.match(/^\/v1\/dns\/([^/]+)$/);
if (m) {
const id = decodeURIComponent(m[1]);
if (method === "GET") {
const denied = await auth(req, path, ["domains:read"]);
if (denied)
return denied;
const record = await repo.getDnsRecord(id);
return record ? json(record) : json({ error: "dns record not found" }, 404);
}
if (method === "PATCH" || method === "PUT") {
const denied = await auth(req, path, ["domains:write"]);
if (denied)
return denied;
const record = await repo.updateDnsRecord(id, await readBody(req));
return record ? json(record) : json({ error: "dns record not found" }, 404);
}
if (method === "DELETE") {
const denied = await auth(req, path, ["domains:write"]);
if (denied)
return denied;
const deleted = await repo.deleteDnsRecord(id);
return json({ id, deleted });
}
}
m = path.match(/^\/v1\/domains\/([^/]+)\/offers$/);
if (m) {
const id = decodeURIComponent(m[1]);
if (method === "GET") {
const denied = await auth(req, path, ["domains:read"]);
if (denied)
return denied;
const offers = await repo.listOffers(id);
return json({ offers, count: offers.length });
}
if (method === "POST") {
const denied = await auth(req, path, ["domains:write"]);
if (denied)
return denied;
const offer = await repo.createOffer(id, await readBody(req));
return json(offer, 201);
}
}
m = path.match(/^\/v1\/domains\/([^/]+)\/alerts$/);
if (m) {
const id = decodeURIComponent(m[1]);
if (method === "GET") {
const denied = await auth(req, path, ["domains:read"]);
if (denied)
return denied;
const alerts = await repo.listAlerts(id);
return json({ alerts, count: alerts.length });
}
if (method === "POST") {
const denied = await auth(req, path, ["domains:write"]);
if (denied)
return denied;
return json(await repo.createAlert(id, await readBody(req)), 201);
}
}
m = path.match(/^\/v1\/alerts\/([^/]+)$/);
if (m) {
const id = decodeURIComponent(m[1]);
if (method === "GET") {
const denied = await auth(req, path, ["domains:read"]);
if (denied)
return denied;
const alert = await repo.getAlert(id);
return alert ? json(alert) : json({ error: "alert not found" }, 404);
}
if (method === "DELETE") {
const denied = await auth(req, path, ["domains:write"]);
if (denied)
return denied;
return json({ id, deleted: await repo.deleteAlert(id) });
}
}
m = path.match(/^\/v1\/domains\/([^/]+)\/emails$/);
if (m) {
const id = decodeURIComponent(m[1]);
if (method === "GET") {
const denied = await auth(req, path, ["domains:read"]);
if (denied)
return denied;
const emails = await repo.listEmailLinks(id);
return json({ emails, count: emails.length });
}
if (method === "POST") {
const denied = await auth(req, path, ["domains:write"]);
if (denied)
return denied;
return json(await repo.linkEmail(id, await readBody(req)), 201);
}
}
m = path.match(/^\/v1\/emails\/([^/]+)$/);
if (m && method === "GET") {
const denied = await auth(req, path, ["domains:read"]);
if (denied)
return denied;
const link = await repo.getEmailLink(decodeURIComponent(m[1]));
return link ? json(link) : json({ error: "email link not found" }, 404);
}
m = path.match(/^\/v1\/offers\/([^/]+)$/);
if (m && method === "GET") {
const denied = await auth(req, path, ["domains:read"]);
if (denied)
return denied;
const offer = await repo.getOffer(decodeURIComponent(m[1]));
return offer ? json(offer) : json({ error: "offer not found" }, 404);
}
if (path === "/v1/owners-portfolio" && method === "GET") {
const denied = await auth(req, path, ["domains:read"]);
if (denied)
return denied;
const domains = await repo.listDomainsWithOwners();
return json({ domains, count: domains.length });
}
m = path.match(/^\/v1\/domains\/([^/]+)\/owners$/);
if (m) {
const id = decodeURIComponent(m[1]);
if (method === "GET") {
const denied = await auth(req, path, ["domains:read"]);
if (denied)
return denied;
const owners = await repo.listOwnersForDomain(id);
return json({ owners, count: owners.length });
}
if (method === "POST") {
const denied = await auth(req, path, ["domains:write"]);
if (denied)
return denied;
return json(await repo.createOwner(id, await readBody(req)), 201);
}
}
if (path === "/v1/owners" && method === "GET") {
const denied = await auth(req, path, ["domains:read"]);
if (denied)
return denied;
const owners = await repo.listOwners({
search: url.searchParams.get("search") ?? undefined,
source: url.searchParams.get("source") ?? undefined,
verified: url.searchParams.has("verified") ? url.searchParams.get("verified") === "true" : undefined
});
return json({ owners, count: owners.length });
}
m = path.match(/^\/v1\/owners\/([^/]+)$/);
if (m) {
const id = decodeURIComponent(m[1]);
if (method === "GET") {
const denied = await auth(req, path, ["domains:read"]);
if (denied)
return denied;
const owner = await repo.getOwner(id);
return owner ? json(owner) : json({ error: "owner not found" }, 404);
}
if (method === "PATCH" || method === "PUT") {
const denied = await auth(req, path, ["domains:write"]);
if (denied)
return denied;
const owner = await repo.updateOwner(id, await readBody(req));
return owner ? json(owner) : json({ error: "owner not found" }, 404);
}
if (method === "DELETE") {
const denied = await auth(req, path, ["domains:write"]);
if (denied)
return denied;
return json({ id, deleted: await repo.deleteOwner(id) });
}
}
if (path === "/v1/history-changes" && method === "GET") {
const denied = await auth(req, path, ["domains:read"]);
if (denied)
return denied;
const domains = await repo.listHistoryChanges();
return json({ domains, count: domains.length });
}
if (path === "/v1/history" && method === "GET") {
const denied = await auth(req, path, ["domains:read"]);
if (denied)
return denied;
const start = url.searchParams.get("start");
const end = url.searchParams.get("end");
if (!start || !end)
return json({ error: "start and end are required" }, 400);
const hist = await repo.listHistoryByDateRange(start, end, url.searchParams.get("domain") ?? undefined);
return json({ history: hist, count: hist.length });
}
m = path.match(/^\/v1\/domains\/([^/]+)\/history$/);
if (m) {
const id = decodeURIComponent(m[1]);
if (method === "GET") {
const denied = await auth(req, path, ["domains:read"]);
if (denied)
return denied;
const hist = await repo.listHistory(id, {
type: url.searchParams.get("type") ?? undefined,
limit: url.searchParams.get("limit") ? Number(url.searchParams.get("limit")) : undefined
});
return json({ history: hist, count: hist.length });
}
if (method === "POST") {
const denied = await auth(req, path, ["domains:write"]);
if (denied)
return denied;
return json(await repo.createHistory(id, await readBody(req)), 201);
}
if (method === "DELETE") {
const denied = await auth(req, path, ["domains:write"]);
if (denied)
return denied;
return json({ id, deleted: await repo.deleteHistoryByDomain(id) });
}
}
m = path.match(/^\/v1\/history\/([^/]+)$/);
if (m) {
const id = decodeURIComponent(m[1]);
if (method === "GET") {
const denied = await auth(req, path, ["domains:read"]);
if (denied)
return denied;
const entry = await repo.getHistory(id);
return entry ? json(entry) : json({ error: "history entry not found" }, 404);
}
if (method === "DELETE") {
const denied = await auth(req, path, ["domains:write"]);
if (denied)
return denied;
return json({ id, deleted: await repo.deleteHistory(id) });
}
}
if (path === "/v1/reputation" && method === "GET") {
const denied = await auth(req, path, ["domains:read"]);
if (denied)
return denied;
const reputation = await repo.listReputation({
blacklisted: url.searchParams.get("blacklisted") === "true",
threshold: url.searchParams.get("threshold") ? Number(url.searchParams.get("threshold")) : undefined
});
return json({ reputation, count: reputation.length });
}
m = path.match(/^\/v1\/domains\/([^/]+)\/reputation$/);
if (m) {
const id = decodeURIComponent(m[1]);
if (method === "GET") {
const denied = await auth(req, path, ["domains:read"]);
if (denied)
return denied;
const rep = await repo.getReputation(id);
return rep ? json(rep) : json({ error: "reputation not found" }, 404);
}
if (method === "PUT" || method === "PATCH") {
const denied = await auth(req, path, ["domains:write"]);
if (denied)
return denied;
return json(await repo.upsertReputation(id, await readBody(req)));
}
}
m = path.match(/^\/v1\/reputation\/([^/]+)$/);
if (m) {
const id = decodeURIComponent(m[1]);
if (method === "PATCH" || method === "PUT") {
const denied = await auth(req, path, ["domains:write"]);
if (denied)
return denied;
const rep = await repo.updateReputation(id, await readBody(req));
return rep ? json(rep) : json({ error: "reputation not found" }, 404);
}
if (method === "DELETE") {
const denied = await auth(req, path, ["domains:write"]);
if (denied)
return denied;
return json({ id, deleted: await repo.deleteReputation(id) });
}
}
return json({ error: "Not found" }, 404);
} catch (e) {
if (e instanceof HttpError)
return json({ error: e.message }, e.status);
const message = e instanceof Error ? e.message : String(e);
return json({ error: message }, 500);
}
}
return { handle };
}
// src/server/provisioning-repo.ts
function dnsRow(row) {
return {
...row,
records: JSON.parse(row.records),
result: row.result ? JSON.parse(row.result) : null
};
}
function parseProviderState(raw) {
if (!raw)
return {};
try {
const value = JSON.parse(raw);
return value && typeof value === "object" && !Array.isArray(value) ? value : {};
} catch {
return {};
}
}
function rowToJob(row) {
return {
id: row.id,
domain_id: row.domain_id,
name: row.domain_name,
idempotency_key: row.idempotency_key,
request_hash: row.request_hash,
status: row.status,
max_price_usd: Number(row.max_price_usd),
years: Number(row.years),
auto_renew: Boolean(row.auto_renew),
acquisition_mode: row.acquisition_mode,
registrar: row.registrar,
dns_provider: row.dns_provider,
target: row.target,
worker_name: row.worker_name,
origin_hostname: row.origin_hostname,
origin_tls_mode: row.origin_tls_mode,
provider_state: parseProviderState(row.provider_state),
attempts: Number(row.attempts),
error: row.error,
lease_token: row.lease_token,
lease_until: row.lease_until,
created_at: row.created_at,
updated_at: row.updated_at
};
}
class DomainsProvisioningRepo {
db;
domains;
constructor(db) {
this.db = db;
this.domains = new DomainsRepo(db);
}
assertCanonicalRequestHash(request, requestHash) {
if (requestHash !== provisioningRequestHash(request)) {
throw new HttpError(409, "provisioning request hash is not canonical");
}
}
async resolveUniqueReservationConflict(request, requestHash, messages) {
const byKey = await this.db.get("SELECT * FROM domain_provisioning_jobs WHERE idempotency_key = $1", [request.idempotency_key]);
if (byKey && !provisioningRequestHashMatches(byKey.request_hash, requestHash, request)) {
throw new HttpError(409, messages.key);
}
const byDomain = await this.db.get("SELECT * FROM domain_provisioning_jobs WHERE domain_name = $1", [request.name]);
if (byDomain && !provisioningRequestHashMatches(byDomain.request_hash, requestHash, request)) {
throw new HttpError(409, messages.domain);
}
if (byKey && byDomain && byKey.id !== byDomain.id) {
throw new HttpError(409, messages.crossed);
}
const existing = byKey ?? byDomain;
if (!existing)
throw new HttpError(409, messages.missing);
return rowToJob(existing);
}
async reserve(request, requestHash) {
this.assertCanonicalRequestHash(request, requestHash);
const byKey = await this.db.get("SELECT * FROM domain_provisioning_jobs WHERE idempotency_key = $1", [request.idempotency_key]);
if (byKey) {
if (!provisioningRequestHashMatches(byKey.request_hash, requestHash, request))
throw new HttpError(409, "idempotency key already used for a different provisioning request");
return rowToJob(byKey);
}
const byDomain = await this.db.get("SELECT * FROM domain_provisioning_jobs WHERE domain_name = $1", [request.name]);
if (byDomain) {
if (!provisioningRequestHashMatches(byDomain.request_hash, requestHash, request))
throw new HttpError(409, `domain '${request.name}' already has a different provisioning request`);
return rowToJob(byDomain);
}
let domain = await this.domains.getDomainByName(request.name);
if (!domain) {
try {
domain = await this.domains.createDomain({
name: request.name,
registrar: "AWS Route 53",
status: "researching",
auto_renew: request.auto_renew,
notes: "Reserved by the hosted Domains API provisioning authority.",
metadata: { provisioning: { status: "requested", target: request.target } }
});
} catch (error) {
if (!(error instanceof HttpError) || error.status !== 409)
throw error;
domain = await this.domains.getDomainByName(request.name);
}
}
if (!domain)
throw new Error("failed to reserve domain portfolio row");
const id = crypto.randomUUID();
const now = new Date().toISOString();
try {
const row = await this.db.get(`INSERT INTO domain_provisioning_jobs (
id, domain_id, domain_name, idempotency_key, request_hash, status,
max_price_usd, years, auto_renew, acquisition_mode, registrar, dns_provider, target,
worker_name, origin_hostname, origin_tls_mode, provider_state, attempts, error, lease_token, lease_until,
created_at, updated_at
) VALUES ($1,$2,$3,$4,$5,'requested',$6,$7,$8,$9,$10,$11,$12,$13,$14,$15,'{}',0,NULL,NULL,NULL,$16,$17)
RETURNING *`, [
id,
domain.id,
request.name,
request.idempotency_key,
requestHash,
request.max_price_usd,
request.years,
request.auto_renew,
request.acquisition_mode,
request.registrar,
request.dns_provider,
request.target,
request.worker_name,
request.origin_hostname,
request.origin_tls_mode,
now,
now
]);
return rowToJob(row);
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
if (!/duplicate key|unique constraint/i.test(message))
throw error;
return this.resolveUniqueReservationConflict(request, requestHash, {
key: "idempotency key already used for a different provisioning request",
domain: `domain '${request.name}' already has a different provisioning request`,
crossed: "idempotency key and domain were claimed by different provisioning requests",
missing: "conflicting provisioning request"
});
}
}
async reserveAdoption(request, requestHash, detail, initialProviderState = {}) {
this.assertCanonicalRequestHash(request, requestHash);
const byKey = await this.db.get("SELECT * FROM domain_provisioning_jobs WHERE idempotency_key=$1", [request.idempotency_key]);
if (byKey) {
if (!provisioningRequestHashMatches(byKey.request_hash, requestHash, request))
throw new HttpError(409, "idempotency key already used for a different adoption request");
return rowToJob(byKey);
}
const byDomain = await this.db.get("SELECT * FROM domain_provisioning_jobs WHERE domain_name=$1", [request.name]);
if (byDomain) {
if (!provisioningRequestHashMatches(byDomain.request_hash, requestHash, request))
throw new HttpError(409, `domain '${request.name}' already has different provisioning intent`);
return rowToJob(byDomain);
}
const domain = await this.domains.getDomainByName(request.name);
if (!domain)
throw new HttpError(404, "owned domain is not present in the portfolio");
const now = new Date().toISOString();
const providerState = {
...initialProviderState,
last_provider_status: "externally_verified_owned"
};
try {
const row = await this.db.get(`INSERT INTO domain_provisioning_jobs (
id, domain_id, domain_name, idempotency_key, request_hash, status,
max_price_usd, years, auto_renew, acquisition_mode, registrar, dns_provider, target,
worker_name, origin_hostname, origin_tls_mode, provider_state, attempts, error, lease_token, lease_until,
created_at, updated_at
) VALUES ($1,$2,$3,$4,$5,'registered',0,1,$6,'adopt',$7,$8,$9,$10,$11,$12,$13,0,NULL,NULL,NULL,$14,$15)
RETURNING *`, [
crypto.randomUUID(),
domain.id,
request.name,
request.idempotency_key,
requestHash,
detail.auto_renew ?? request.auto_renew,
request.registrar,
request.dns_provider,
request.target,
request.worker_name,
request.origin_hostname,
request.origin_tls_mode,
JSON.stringify(providerState),
now,
now
]);
return rowToJob(row);
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
if (!/duplicate key|unique constraint/i.test(message))
throw error;
return this.resolveUniqueReservationConflict(request, requestHash, {
key: "idempotency key already used for a different adoption request",
domain: `domain '${request.name}' already has different provisioning intent`,
crossed: "idempotency key and domain were claimed by different adoption requests",
missing: "conflicting domain adoption request"
});
}
}
async get(id) {
const row = await this.db.get("SELECT * FROM domain_provisioning_jobs WHERE id = $1", [id]);
return row ? rowToJob(row) : null;
}
async getByName(name) {
const row = await this.db.get("SELECT * FROM domain_provisioning_jobs WHERE domain_name = $1", [name]);
return row ? rowToJob(row) : null;
}
async getPortfolioRegistration(name) {
const domain = await this.domains.getDomainByName(name);
if (!domain || !domain.registrar)
return null;
return {
id: domain.id,
status: domain.status,
registrar: domain.registrar,
registered_at: domain.registered_at ?? undefined,
expires_at: domain.expires_at ?? undefined,
auto_renew: domain.auto_renew,
nameservers: [...domain.nameservers]
};
}
async listRunnable(limit) {
const now = new Date().toISOString();
const rows = await this.db.many(`SELECT * FROM domain_provisioning_jobs
WHERE status NOT IN ('ready','manual_review','failed')
AND (lease_until IS NULL OR lease_until < $1)
ORDER BY updated_at ASC
LIMIT $2`, [now, Math.min(Math.max(limit, 1), 50)]);
return rows.map(rowToJob);
}
async claim(id, leaseToken, leaseUntil) {
const now = new Date().toISOString();
const row = await this.db.get(`UPDATE domain_provisioning_jobs
SET lease_token = $2, lease_until = $3, updated_at = $4
WHERE id = $1
AND status NOT IN ('ready','manual_review','failed')
AND (lease_until IS NULL OR lease_until < $4)
RETURNING *`, [id, leaseToken, leaseUntil, now]);
return row ? rowToJob(row) : null;
}
async update(id, patch, leaseToken) {
const sets = [];
const params = [];
const add = (column, value) => {
params.push(value);
sets.push(`${column} = $${params.length}`);
};
if (patch.status !== undefined)
add("status", patch.status);
if (patch.provider_state !== undefined)
add("provider_state", JSON.stringify(patch.provider_state));
if (patch.attempts !== undefined)
add("attempts", patch.attempts);
if (patch.error !== undefined)
add("error", patch.error);
if (patch.lease_token !== undefined)
add("lease_token", patch.lease_token);
if (patch.lease_until !== undefined)
add("lease_until", patch.lease_until);
add("updated_at", new Date().toISOString());
params.push(id);
const idParam = `$${params.length}`;
let where = `id = ${idParam}`;
if (leaseToken !== undefined) {
params.push(leaseToken);
where += ` AND lease_token = $${params.length}`;
}
const row = await this.db.get(`UPDATE domain_provisioning_jobs SET ${sets.join(", ")} WHERE ${where} RETURNING *`, params);
return row ? rowToJob(row) : null;
}
async markPortfolioReady(job, detail) {
const existing = await this.domains.getDomain(job.domain_id);
if (!existing)
throw new Error("domain portfolio row disappeared during provisioning");
await this.domains.updateDomain(job.domain_id, {
registrar: detail.registrar ?? "AWS Route 53",
status: "active",
registered_at: detail.registered_at ?? existing.registered_at ?? undefined,
expires_at: detail.expires_at ?? existing.expires_at ?? undefined,
auto_renew: detail.auto_renew ?? job.auto_renew,
purchase_price: job.provider_state.quoted_price_usd ?? existing.purchase_price,
standard_price: job.provider_state.quoted_price_usd ?? existing.standard_price,
purchase_date: existing.purchase_date ?? job.created_at,
nameservers: detail.nameservers,
metadata: {
...existing.metadata,
provisioning: {
job_id: job.id,
status: "ready",
target: job.target,
acquisition_mode: job.acquisition_mode,
worker_name: job.worker_name,
cloudflare_zone_id: job.provider_state.cloudflare_zone_id,
registration_operation_id: job.provider_state.registration_operation_id,
nameserver_operation_id: job.provider_state.nameserver_operation_id,
ready_at: new Date().toISOString()
}
}
});
}
async listDnsReconciliations(name, query) {
const values = [name];
const where = ["domain_name = $1"];
if (query.id !== undefined) {
values.push(query.id);
where.push(`id = $${values.length}`);
}
if (query.idempotency_key !== undefined) {
values.push(query.idempotency_key);
where.push(`idempotency_key = $${values.length}`);
}
values.push(query.limit, query.offset);
const rows = await this.db.many(`SELECT * FROM domain_dns_reconciliations WHERE ${where.join(" AND ")} ORDER BY created_at, id LIMIT $${values.length - 1} OFFSET $${values.length}`, values);
return rows.map(dnsRow);
}
async reserveDnsReconciliation(input) {
const existing = await this.db.get("SELECT * FROM domain_dns_reconciliations WHERE idempotency_key = $1", [input.idempotencyKey]);
if (existing) {
if (existing.request_hash !== input.requestHash) {
throw new HttpError(409, "idempotency key already used for different DNS records");
}
return dnsRow(existing);
}
const now = new Date().toISOString();
try {
const row = await this.db.get(`INSERT INTO domain_dns_reconciliations (
id, provisioning_job_id, domain_name, idempotency_key, request_hash,
status, records, result, error, lease_token, lease_until, created_at, updated_at
) VALUES ($1,$2,$3,$4,$5,'requested',$6,NULL,NULL,NULL,NULL,$7,$8)
RETURNING *`, [
crypto.randomUUID(),
input.job.id,
input.job.name,
input.idempotencyKey,
input.requestHash,
JSON.stringify(input.records),
now,
now
]);
return dnsRow(row);
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
if (!/duplicate key|unique constraint/i.test(message))
throw error;
const raced = await this.db.get("SELECT * FROM domain_dns_reconciliations WHERE idempotency_key = $1", [input.idempotencyKey]);
if (!raced || raced.request_hash !== input.requestHash) {
throw new HttpError(409, "conflicting DNS reconciliation request");
}
return dnsRow(raced);
}
}
async withDnsZoneLock(zoneId, work) {
const pool = this.db.pool;
if (!pool)
throw new HttpError(503, "DNS reconciliation requires a dedicated database connection");
const connection = await pool.connect();
const client = wrapExecutor(connection);
const key = `domains:dns-zone:${zoneId}`;
let locked = false;
let discard = false;
try {
let lock;
try {
lock = await client.get("SELECT pg_try_advisory_lock(hashtextextended($1, 0)) AS acquired", [key]);
} catch (error) {
discard = true;
throw error;
}
locked = lock?.acquired === true;
if (!locked)
throw new HttpError(503, "DNS zone reconciliation is busy; retry this request");
return await work(new DomainsProvisioningRepo(client));
} finally {
try {
if (locked) {
const unlocked = await client.get("SELECT pg_advisory_unlock(hashtextextended($1, 0)) AS released", [key]);
if (unlocked?.released !== true)
throw new Error("DNS zone lock ownership was lost");
}
} catch (error) {
discard = true;
throw error;
} finally {
connection.release(discard);
}
}
}
async claimDnsReconciliation(id, leaseToken, leaseUntil) {
const now = new Date().toISOString();
const row = await this.db.get(`UPDATE domain_dns_reconciliations
SET lease_token=$2, lease_until=$3, updated_at=$4
WHERE id=$1 AND status <> 'ready' AND (lease_until IS NULL OR lease_until < $4)
RETURNING *`, [id, leaseToken, leaseUntil, now]);
return row ? dnsRow(row) : null;
}
async updateDnsReconciliation(id, patch, leaseToken) {
const sets = [];
const params = [];
const add = (column, value) => {
params.push(value);
sets.push(`${column}=$${params.length}`);
};
if (patch.status !== undefined)
add("status", patch.status);
if (patch.result !== undefined)
add("result", patch.result === null ? null : JSON.stringify(patch.result));
if (patch.error !== undefined)
add("error", patch.error);
if (patch.lease_token !== undefined)
add("lease_token", patch.lease_token);
if (patch.lease_until !== undefined)
add("lease_until", patch.lease_until);
add("updated_at", new Date().toISOString());
params.push(id, leaseToken);
const row = await this.db.get(`UPDATE domain_dns_reconciliations SET ${sets.join(", ")}
WHERE id=$${params.length - 1} AND lease_token=$${params.length} RETURNING *`, params);
return row ? dnsRow(row) : null;
}
}
// src/server/provisioning-runtime.ts
import { createHash as createHash6 } from "crypto";
import { promises as dns } from "dns";
// ../../node_modules/.bun/@aws-sdk+credential-providers@3.1127.0/node_modules/@aws-sdk/credential-providers/dist-es/fromTemporaryCredentials.js
var import_config29 = __toESM(require_config());
// ../../node_modules/.bun/@aws-sdk+credential-providers@3.1127.0/node_modules/@aws-sdk/credential-providers/dist-es/fromNodeProviderChain.js
var fromNodeProviderChain = (init = {}) => {
let chain;
return async (args) => {
if (!chain) {
await Promise.resolve().then(() => init_dist_es10());
chain = defaultProvider({ ...init });
}
return chain(args);
};
};
// ../../node_modules/.bun/@aws-sdk+credential-providers@3.1127.0/node_modules/@aws-sdk/credential-providers/dist-es/fromTemporaryCredentials.base.js
var import_core = __toESM(require_dist_cjs2());
var import_config28 = __toESM(require_config());
var ASSUME_ROLE_DEFAULT_REGION = "us-east-1";
var fromTemporaryCredentials = (options, credentialDefaultProvider, regionProvider) => {
let stsClient;
return async (awsIdentityProperties = {}) => {
const { callerClientConfig } = awsIdentityProperties;
const profile = options.clientConfig?.profile ?? callerClientConfig?.profile;
const logger = options.logger ?? callerClientConfig?.logger;
logger?.debug("@aws-sdk/credential-providers - fromTemporaryCredentials (STS)");
const params = { ...options.params, RoleSessionName: options.params.RoleSessionName ?? "aws-sdk-js-" + Date.now() };
if (params?.SerialNumber) {
if (!options.mfaCodeProvider) {
throw new import_config28.CredentialsProviderError(`Temporary credential requires multi-factor authentication, but no MFA code callback was provided.`, {
tryNextLink: false,
logger
});
}
params.TokenCode = await options.mfaCodeProvider(params?.SerialNumber);
}
const { AssumeRoleCommand, STSClient } = await Promise.resolve().then(() => (init_loadSts(), exports_loadSts));
if (!stsClient) {
const defaultCredentialsOrError = typeof credentialDefaultProvider === "function" ? credentialDefaultProvider() : undefined;
const credentialSources = [
options.masterCredentials,
options.clientConfig?.credentials,
void callerClientConfig?.credentials,
callerClientConfig?.credentialDefaultProvider?.(),
defaultCredentialsOrError
];
let credentialSource = "STS client default credentials";
if (credentialSources[0]) {
credentialSource = "options.masterCredentials";
} else if (credentialSources[1]) {
credentialSource = "options.clientConfig.credentials";
} else if (credentialSources[2]) {
credentialSource = "caller client's credentials";
throw new Error("fromTemporaryCredentials recursion in callerClientConfig.credentials");
} else if (credentialSources[3]) {
credentialSource = "caller client's credentialDefaultProvider";
} else if (credentialSources[4]) {
credentialSource = "AWS SDK default credentials";
}
const regionSources = [
options.clientConfig?.region,
callerClientConfig?.region,
await regionProvider?.({
profile
}),
ASSUME_ROLE_DEFAULT_REGION
];
let regionSource = "default partition's default region";
if (regionSources[0]) {
regionSource = "options.clientConfig.region";
} else if (regionSources[1]) {
regionSource = "caller client's region";
} else if (regionSources[2]) {
regionSource = "file or env region";
}
const requestHandlerSources = [
filterRequestHandler(options.clientConfig?.requestHandler),
filterRequestHandler(callerClientConfig?.requestHandler)
];
let requestHandlerSource = "STS default requestHandler";
if (requestHandlerSources[0]) {
requestHandlerSource = "options.clientConfig.requestHandler";
} else if (requestHandlerSources[1]) {
requestHandlerSource = "caller client's requestHandler";
}
logger?.debug?.(`@aws-sdk/credential-providers - fromTemporaryCredentials STS client init with ${regionSource}=${await import_core.normalizeProvider(coalesce(regionSources))()}, ${credentialSource}, ${requestHandlerSource}.`);
stsClient = new STSClient({
userAgentAppId: callerClientConfig?.userAgentAppId,
...options.clientConfig,
credentials: coalesce(credentialSources),
logger,
profile,
region: coalesce(regionSources),
requestHandler: coalesce(requestHandlerSources)
});
}
if (options.clientPlugins) {
for (const plugin of options.clientPlugins) {
stsClient.middlewareStack.use(plugin);
}
}
const { Credentials } = await stsClient.send(new AssumeRoleCommand(params));
if (!Credentials || !Credentials.AccessKeyId || !Credentials.SecretAccessKey) {
throw new import_config28.CredentialsProviderError(`Invalid response from STS.assumeRole call with role ${params.RoleArn}`, {
logger
});
}
return {
accessKeyId: Credentials.AccessKeyId,
secretAccessKey: Credentials.SecretAccessKey,
sessionToken: Credentials.SessionToken,
expiration: Credentials.Expiration,
credentialScope: Credentials.CredentialScope
};
};
};
var filterRequestHandler = (requestHandler) => {
return requestHandler?.metadata?.handlerProtocol === "h2" ? undefined : requestHandler;
};
var coalesce = (args) => {
for (const item of args) {
if (item !== undefined) {
return item;
}
}
};
// ../../node_modules/.bun/@aws-sdk+credential-providers@3.1127.0/node_modules/@aws-sdk/credential-providers/dist-es/fromTemporaryCredentials.js
var fromTemporaryCredentials2 = (options) => {
return fromTemporaryCredentials(options, fromNodeProviderChain, async ({ profile = process.env.AWS_PROFILE }) => import_config29.loadConfig({
environmentVariableSelector: (env) => env.AWS_REGION,
configFileSelector: (profileData) => {
return profileData.region;
},
default: () => {
return;
}
}, { ...import_config29.NODE_REGION_CONFIG_FILE_OPTIONS, profile })());
};
// ../../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_core2 = __toESM(require_dist_cjs2());
var import_client25 = __toESM(require_client());
var import_config31 = __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_client16 = __toESM(require_client());
var defaultRoute53HttpAuthSchemeParametersProvider = async (config, context, input) => {
return {
operation: import_client16.getSmithyContext(context).operation,
region: await import_client16.normalizeProvider(config.region)() || (() => {
throw new Error("expected `region` to be configured for `aws.auth#sigv4`");
})()
};
};
function createAwsAuthSigv4HttpAuthOption2(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(createAwsAuthSigv4HttpAuthOption2(authParameters));
}
}
return options;
};
var resolveHttpAuthSchemeConfig2 = (config) => {
const config_0 = import_httpAuthSchemes.resolveAwsSdkSigV4Config(config);
return Object.assign(config_0, {
authSchemePreference: import_client16.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 resolveClientEndpointParameters2 = (options) => {
return Object.assign(options, {
useDualstackEndpoint: options.useDualstackEndpoint ?? false,
useFipsEndpoint: options.useFipsEndpoint ?? false,
defaultSigningName: "route53"
});
};
var commonParams2 = {
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
init_dist_es10();
var import_client20 = __toESM(require_client2());
var import_httpAuthSchemes3 = __toESM(require_httpAuthSchemes());
var import_client21 = __toESM(require_client());
var import_config30 = __toESM(require_config());
var import_retry3 = __toESM(require_retry());
var import_serde4 = __toESM(require_serde());
var import_node_http_handler2 = __toESM(require_dist_cjs3());
// ../../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 t = "authSchemes";
var u = "name";
var v = "signingRegion";
var a2 = -1;
var b2 = true;
var c2 = "isSet";
var d2 = "PartitionResult";
var e2 = "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 = { [t]: [{ [u]: h2, [v]: "us-east-1" }] };
var m = { [t]: [{ [u]: h2, [v]: "cn-northwest-1" }] };
var n = { [t]: [{ [u]: h2, [v]: "us-gov-west-1" }] };
var o = { [t]: [{ [u]: h2, [v]: "eusc-de-east-1" }] };
var p = { [t]: [{ [u]: h2, [v]: "{PartitionResult#implicitGlobalRegion}" }] };
var q = [{ [s]: "Region" }];
var _data2 = {
conditions: [
[c2, [i2]],
[c2, q],
["aws.partition", q, d2],
[e2, [{ [s]: "UseFIPS" }, b2]],
[f2, [j2, "aws"]],
[f2, [j2, "aws-cn"]],
[f2, [j2, "aws-us-gov"]],
[e2, [{ [s]: "UseDualStack" }, b2]],
[e2, [{ 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"]],
[e2, [{ 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", n],
["https://route53.us-gov.api.aws", n],
["https://route53.c2s.ic.gov", { [t]: [{ [u]: h2, [v]: "us-iso-east-1" }] }],
["https://route53.sc2s.sgov.gov", { [t]: [{ [u]: h2, [v]: "us-isob-east-1" }] }],
["https://route53.cloud.adc-e.uk", { [t]: [{ [u]: h2, [v]: "eu-isoe-west-1" }] }],
["https://route53.csp.hci.ic.gov", { [t]: [{ [u]: h2, [v]: "us-isof-south-1" }] }],
["https://route53.amazonaws.eu", o],
["https://route53.global.api.amazonwebservices.eu", o],
["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 r2 = 1e8;
var nodes2 = new Int32Array([
-1,
1,
-1,
0,
27,
3,
1,
4,
r2 + 25,
2,
5,
r2 + 25,
3,
19,
6,
4,
18,
7,
5,
17,
8,
6,
25,
9,
7,
15,
10,
9,
r2 + 12,
11,
10,
r2 + 13,
12,
11,
r2 + 14,
13,
12,
r2 + 15,
14,
13,
r2 + 16,
r2 + 24,
13,
r2 + 17,
16,
14,
r2 + 22,
r2 + 23,
7,
r2 + 9,
r2 + 8,
7,
r2 + 6,
r2 + 4,
4,
26,
20,
6,
25,
21,
7,
23,
22,
8,
r2 + 20,
r2 + 21,
8,
24,
r2 + 19,
14,
r2 + 18,
r2 + 19,
7,
r2 + 11,
r2 + 10,
7,
r2 + 7,
r2 + 5,
3,
r2 + 1,
28,
7,
r2 + 2,
r2 + 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_config30.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_config30.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_config30.loadConfig(import_retry3.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_handler2.NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
retryMode: config?.retryMode ?? import_config30.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_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_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 = resolveClientEndpointParameters2(_config_0);
const _config_2 = import_client24.resolveUserAgentConfig(_config_1);
const _config_3 = import_retry4.resolveRetryConfig(_config_2);
const _config_4 = import_config31.resolveRegionConfig(_config_3);
const _config_5 = import_client24.resolveHostHeaderConfig(_config_4);
const _config_6 = import_endpoints3.resolveEndpointConfig(_config_5);
const _config_7 = resolveHttpAuthSchemeConfig2(_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_core2.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
httpAuthSchemeParametersProvider: defaultRoute53HttpAuthSchemeParametersProvider,
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+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(commonParams2, "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/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/ListHostedZonesByNameCommand.js
class ListHostedZonesByNameCommand extends command2(_ep02, _mw02, "ListHostedZonesByName", ListHostedZonesByName$) {
}
// ../../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_core3 = __toESM(require_dist_cjs2());
var import_client36 = __toESM(require_client());
var import_config33 = __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
init_dist_es10();
var import_client31 = __toESM(require_client2());
var import_httpAuthSchemes6 = __toESM(require_httpAuthSchemes());
var import_client32 = __toESM(require_client());
var import_config32 = __toESM(require_config());
var import_retry5 = __toESM(require_retry());
var import_serde6 = __toESM(require_serde());
var import_node_http_handler3 = __toESM(require_dist_cjs3());
// ../../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 e3 = "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],
[e3, [{ [k3]: "UseFIPS" }, b3]],
[e3, [{ [k3]: "UseDualStack" }, b3]],
[e3, [{ fn: f3, argv: [h3, "supportsDualStack"] }, b3]],
[e3, [{ 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 r3 = 1e8;
var nodes3 = new Int32Array([
-1,
1,
-1,
0,
12,
3,
1,
4,
r3 + 11,
2,
5,
r3 + 11,
3,
8,
6,
4,
7,
r3 + 10,
5,
r3 + 8,
r3 + 9,
4,
10,
9,
6,
r3 + 6,
r3 + 7,
5,
11,
r3 + 5,
6,
r3 + 4,
r3 + 5,
3,
r3 + 1,
13,
4,
r3 + 2,
r3 + 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_config32.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_config32.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_config32.loadConfig(import_retry5.NODE_MAX_ATTEMPT_CONFIG_OPTIONS, config),
region: config?.region ?? import_config32.loadConfig(import_config32.NODE_REGION_CONFIG_OPTIONS, { ...import_config32.NODE_REGION_CONFIG_FILE_OPTIONS, ...loaderConfig }),
requestHandler: import_node_http_handler3.NodeHttpHandler.create(config?.requestHandler ?? defaultConfigProvider),
retryMode: config?.retryMode ?? import_config32.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_config32.loadConfig(import_config32.NODE_USE_DUALSTACK_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
useFipsEndpoint: config?.useFipsEndpoint ?? import_config32.loadConfig(import_config32.NODE_USE_FIPS_ENDPOINT_CONFIG_OPTIONS, loaderConfig),
userAgentAppId: config?.userAgentAppId ?? import_config32.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_config33.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_core3.getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
httpAuthSchemeParametersProvider: defaultRoute53DomainsHttpAuthSchemeParametersProvider,
identityProviderConfigProvider: async (config) => new import_core3.DefaultIdentityProviderConfig({
"aws.auth#sigv4": config.credentials
})
}));
this.middlewareStack.use(import_core3.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_config37 = __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_config36 = __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_config35 = __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_config34 = __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_config34.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_config34.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_config35.CredentialsProviderError(`Detected a cycle attempting to resolve credentials for profile ${import_config35.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_config35.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_config36.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 fromIni3 = (init = {}) => async ({ callerClientConfig } = {}) => {
init.logger?.debug("@aws-sdk/credential-provider-ini - fromIni");
const profiles = await import_config37.parseKnownFiles(init);
return resolveProfileData2(import_config37.getProfileName({
profile: init.profile ?? callerClientConfig?.profile
}), profiles, init, callerClientConfig);
};
// src/lib/route53.ts
function getConfig3() {
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 ?? getConfig3();
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 ? fromIni3({ profile: cfg.profile }) : undefined);
return {
route53: new Route53Client({ region, credentials }),
domains: new Route53DomainsClient({ region: "us-east-1", credentials })
};
}
async function checkAvailability2(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 registerDomain(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 getRegistrationContactFromDomain(domain, config) {
const { domains } = makeClients(config);
const result = await domains.send(new GetDomainDetailCommand({ DomainName: domain }));
const contact = result.RegistrantContact ?? result.AdminContact ?? result.TechContact;
if (!contact)
throw new Error(`Route53 returned no reusable registration contact for ${domain}`);
const required = {
first_name: contact.FirstName,
last_name: contact.LastName,
email: contact.Email,
phone: contact.PhoneNumber,
address_line_1: contact.AddressLine1,
city: contact.City,
country_code: contact.CountryCode,
zip_code: contact.ZipCode
};
for (const [key, value] of Object.entries(required)) {
if (!value || !String(value).trim())
throw new Error(`Route53 contact source is missing ${key}`);
}
return {
first_name: String(required.first_name),
last_name: String(required.last_name),
email: String(required.email),
phone: String(required.phone),
address_line_1: String(required.address_line_1),
...contact.AddressLine2 ? { address_line_2: contact.AddressLine2 } : {},
city: String(required.city),
...contact.State ? { state: contact.State } : {},
country_code: String(required.country_code).toLowerCase(),
zip_code: String(required.zip_code),
...contact.OrganizationName ? { organization_name: contact.OrganizationName } : {}
};
}
async function findRegisteredDomainDetail(domain, config) {
const summary = await getDomainSummary(domain, config);
if (!summary)
return null;
return getDomainDetail(domain, config);
}
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 normalizeNameserver(value) {
return value.trim().toLowerCase().replace(/\.$/, "");
}
function nameserversMatch(a, b) {
if (a.length !== b.length)
return false;
const left = [...new Set(a.map(normalizeNameserver))].sort();
const right = [...new Set(b.map(normalizeNameserver))].sort();
return left.length === right.length && left.every((value, index) => value === right[index]);
}
function cleanChangeId(id) {
return id?.replace("/change/", "") || null;
}
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 listHostedZonesByDomain(domain, config) {
const { route53 } = makeClients(config);
const normalized = domain.trim().toLowerCase().replace(/\.$/, "");
const dnsName = `${normalized}.`;
const zones = [];
let nextDnsName = normalized;
let nextHostedZoneId;
do {
const result = await route53.send(new ListHostedZonesByNameCommand({
DNSName: nextDnsName,
HostedZoneId: nextHostedZoneId
}));
for (const zone of result.HostedZones ?? []) {
if (zone.Name?.toLowerCase() !== dnsName || zone.Config?.PrivateZone)
continue;
zones.push({
id: cleanZoneId(zone.Id ?? ""),
name: zone.Name ?? dnsName,
record_count: zone.ResourceRecordSetCount ?? 0,
comment: zone.Config?.Comment,
private_zone: false
});
}
if (!result.IsTruncated || !result.NextDNSName)
break;
if (result.NextDNSName.toLowerCase().replace(/\.$/, "") !== normalized)
break;
nextDnsName = result.NextDNSName;
nextHostedZoneId = result.NextHostedZoneId;
} while (nextDnsName);
return zones.filter((zone) => zone.id);
}
async function deleteDefaultHostedZone(hostedZoneId, domain, delegatedNameservers, config) {
const zoneId = normalizeZoneId(hostedZoneId);
const expectedName = `${domain.trim().toLowerCase().replace(/\.$/, "")}.`;
const detail = await getHostedZone(zoneId, config);
if (detail.id !== zoneId || detail.name.toLowerCase() !== expectedName || detail.private_zone) {
return { deleted: false, reason: "hosted zone identity does not match the persisted public-zone provenance" };
}
if (!delegatedNameservers.length || nameserversMatch(detail.name_servers, delegatedNameservers)) {
return { deleted: false, reason: "registrar delegation still points at the Route 53 hosted zone" };
}
const { route53 } = makeClients(config);
const records = [];
let nextName;
let nextType;
let nextIdentifier;
do {
const result = await route53.send(new ListResourceRecordSetsCommand({
HostedZoneId: zoneId,
StartRecordName: nextName,
StartRecordType: nextType,
StartRecordIdentifier: nextIdentifier
}));
records.push(...result.ResourceRecordSets ?? []);
nextName = result.IsTruncated ? result.NextRecordName : undefined;
nextType = result.IsTruncated ? result.NextRecordType : undefined;
nextIdentifier = result.IsTruncated ? result.NextRecordIdentifier : undefined;
} while (nextName && nextType);
const apexRecords = records.filter((record) => record.Name?.toLowerCase() === expectedName);
const ns = apexRecords.filter((record) => record.Type === "NS");
const soa = apexRecords.filter((record) => record.Type === "SOA");
if (records.length !== 2 || apexRecords.length !== 2 || ns.length !== 1 || soa.length !== 1) {
return { deleted: false, reason: "hosted zone contains records other than the expected apex NS and SOA" };
}
const nsValues = ns[0]?.ResourceRecords?.map((record) => record.Value ?? "") ?? [];
if (!nameserversMatch(nsValues, detail.name_servers)) {
return { deleted: false, reason: "hosted zone apex NS does not match its delegation set" };
}
try {
await route53.send(new DeleteHostedZoneCommand({ Id: zoneId }));
return { deleted: true };
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
const name = error instanceof Error ? error.name : "";
if (name === "HostedZoneNotEmpty" || /HostedZoneNotEmpty|not empty/i.test(message)) {
return { deleted: false, reason: "hosted zone changed after inspection and Route 53 refused deletion" };
}
throw error;
}
}
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 listRecords2(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 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 ?? getConfig3();
const registerWithRoute53 = registerDomain;
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 listRecords2(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 checkAvailability2(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/server/provisioning-runtime.ts
var DEFAULT_ROUTE53_ACCOUNT_REF = "default";
function parseRoute53RegistrarAccounts(env) {
const raw = env["DOMAINS_ROUTE53_REGISTRAR_ACCOUNTS_JSON"]?.trim();
if (!raw)
return new Map;
let parsed;
try {
parsed = JSON.parse(raw);
} catch {
throw new Error("DOMAINS_ROUTE53_REGISTRAR_ACCOUNTS_JSON must be valid JSON");
}
if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
throw new Error("DOMAINS_ROUTE53_REGISTRAR_ACCOUNTS_JSON must be an object of account references to role ARNs");
}
const entries = Object.entries(parsed);
if (entries.length > 16)
throw new Error("DOMAINS_ROUTE53_REGISTRAR_ACCOUNTS_JSON supports at most 16 accounts");
const result = new Map;
for (const [ref, value] of entries) {
if (ref === DEFAULT_ROUTE53_ACCOUNT_REF || !/^[a-z][a-z0-9_-]{0,62}$/u.test(ref)) {
throw new Error(`invalid Route 53 registrar account reference '${ref}'`);
}
if (typeof value !== "string" || !/^arn:aws(?:-[a-z]+)?:iam::[0-9]{12}:role\/[A-Za-z0-9+=,.@_\/-]{1,512}$/u.test(value)) {
throw new Error(`Route 53 registrar account '${ref}' must name an IAM role ARN`);
}
result.set(ref, value);
}
return result;
}
function route53AccountBindingFingerprint(roleArn) {
return createHash6("sha256").update(roleArn ?? "domains:route53:default-task-role:v1").digest("hex");
}
async function resolveRoute53AdoptionAccount(candidates, read) {
const matches = [];
for (const candidate of candidates) {
const detail = await read(candidate);
if (detail) {
matches.push({
detail,
route53_account_ref: candidate.ref,
route53_account_binding_sha256: route53AccountBindingFingerprint(candidate.roleArn)
});
}
}
if (matches.length > 1) {
throw new RegistrarActionRequiredError("Route 53 reports the adopted domain as owned by more than one configured account");
}
return matches[0] ?? null;
}
function sourceDomain(env) {
const value = env["DOMAINS_REGISTRANT_SOURCE_DOMAIN"]?.trim();
if (!value)
throw new Error("DOMAINS_REGISTRANT_SOURCE_DOMAIN is required for hosted domain purchases");
return value;
}
function hostedCloudflareConfig(env) {
const apiToken = env["CLOUDFLARE_API_TOKEN"]?.trim();
const accountId = env["CLOUDFLARE_ACCOUNT_ID"]?.trim();
if (!apiToken) {
if (env["CLOUDFLARE_API_KEY"] || env["CLOUDFLARE_EMAIL"]) {
throw new Error("hosted provisioning requires CLOUDFLARE_API_TOKEN; global API key/email authentication is not accepted");
}
throw new Error("CLOUDFLARE_API_TOKEN is required for hosted provisioning");
}
if (!accountId)
throw new Error("CLOUDFLARE_ACCOUNT_ID is required for hosted provisioning");
return { apiToken, accountId };
}
function nameserversEqual2(left, right) {
const norm = (items) => [...new Set(items.map((item) => item.trim().toLowerCase().replace(/\.$/, "")).filter(Boolean))].sort();
return JSON.stringify(norm(left)) === JSON.stringify(norm(right));
}
var PRESERVABLE_DNS_TYPES = new Set([
"A",
"AAAA",
"CAA",
"CNAME",
"MX",
"NS",
"TXT"
]);
function delegationRecordName(value, hostname) {
const raw = value.trim().toLowerCase().replace(/\.$/u, "");
const name = raw === "@" || raw === "" ? hostname : raw === hostname || raw.endsWith(`.${hostname}`) ? raw : `${raw}.${hostname}`;
if (name.length > 253 || !/^(?:\*\.)?[a-z0-9_](?:[a-z0-9_-]{0,61}[a-z0-9_])?(?:\.[a-z0-9_](?:[a-z0-9_-]{0,61}[a-z0-9_])?)*$/u.test(name) || name !== hostname && !name.endsWith(`.${hostname}`)) {
throw new RegistrarActionRequiredError("registrar DNS contains a record outside the adopted domain");
}
return name;
}
function delegationRecordValue(type, value, hostname) {
const raw = String(value ?? "").trim();
if (!raw || raw.length > 8192 || /[\0\r\n]/u.test(raw)) {
throw new RegistrarActionRequiredError("registrar DNS contains an invalid record value");
}
if (!["CNAME", "MX", "NS"].includes(type))
return raw;
if (type === "MX")
return raw === "." ? raw : raw.toLowerCase().replace(/\.$/u, "");
const target = raw.toLowerCase().replace(/\.$/u, "");
return target.includes(".") ? target : `${target}.${hostname}`;
}
function canonicalDelegationRecords(records, hostname) {
if (records.length > 500) {
throw new RegistrarActionRequiredError("registrar DNS has more than 500 records; automatic preservation is refused");
}
const canonical = [];
for (const record of records) {
const type = String(record.type ?? "").trim().toUpperCase();
const name = delegationRecordName(String(record.name ?? ""), hostname);
if (type === "SOA" || type === "NS" && name === hostname)
continue;
if (!PRESERVABLE_DNS_TYPES.has(type)) {
throw new RegistrarActionRequiredError(`registrar DNS record type '${type}' cannot be preserved automatically`);
}
const value = delegationRecordValue(type, record.value, hostname);
const ttl = Number(record.ttl);
if (!Number.isInteger(ttl) || ttl < 60 || ttl > 86400) {
throw new RegistrarActionRequiredError("registrar DNS contains a TTL outside 60-86400 seconds");
}
const priority = record.priority === undefined || record.priority === null ? null : Number(record.priority);
if (priority !== null && (!Number.isInteger(priority) || priority < 0 || priority > 65535)) {
throw new RegistrarActionRequiredError("registrar DNS contains an invalid priority");
}
canonical.push({ type, name, value, ttl, priority });
}
canonical.sort((left, right) => JSON.stringify(left).localeCompare(JSON.stringify(right)));
if (new Set(canonical.map((record) => JSON.stringify(record))).size !== canonical.length) {
throw new RegistrarActionRequiredError("registrar DNS contains duplicate records");
}
return canonical;
}
function delegationRecordHash(records) {
return createHash6("sha256").update(JSON.stringify(records)).digest("hex");
}
function createHostedProvisioningProviders(env = process.env) {
const cloudflareConfig = hostedCloudflareConfig(env);
const readinessPath = env["DOMAINS_SHORTLINKS_READY_PATH"]?.trim() || "/.well-known/shortlink-router";
if (!readinessPath.startsWith("/") || /[\r\n]/u.test(readinessPath))
throw new Error("DOMAINS_SHORTLINKS_READY_PATH is invalid");
const readinessHeader = env["DOMAINS_SHORTLINKS_READY_HEADER"]?.trim().toLowerCase() || "x-shortlink-router";
if (!/^[a-z0-9][a-z0-9-]{0,126}$/u.test(readinessHeader))
throw new Error("DOMAINS_SHORTLINKS_READY_HEADER is invalid");
const readinessValue = env["DOMAINS_SHORTLINKS_READY_VALUE"]?.trim() || undefined;
const registrantSourceDomain = sourceDomain(env);
const brandsightConfig = resolveBrandsightConfig(env);
const brandsight = brandsightConfig.apiKey && brandsightConfig.apiSecret && brandsightConfig.customerId ? createBrandsightProvider(brandsightConfig) : null;
const route53Accounts = parseRoute53RegistrarAccounts(env);
const admissionPause = env["DOMAINS_ROUTE53_ADOPTION_PAUSED"] ?? "false";
if (admissionPause !== "true" && admissionPause !== "false") {
throw new Error("DOMAINS_ROUTE53_ADOPTION_PAUSED must be true or false");
}
const configForAccount = (binding) => {
if (!binding)
return;
const roleArn = binding.route53_account_ref === DEFAULT_ROUTE53_ACCOUNT_REF ? undefined : route53Accounts.get(binding.route53_account_ref);
if (binding.route53_account_ref !== DEFAULT_ROUTE53_ACCOUNT_REF && !roleArn) {
throw new RegistrarActionRequiredError(`Route 53 account reference '${binding.route53_account_ref}' is not configured`);
}
if (route53AccountBindingFingerprint(roleArn) !== binding.route53_account_binding_sha256) {
throw new RegistrarActionRequiredError(`Route 53 account binding '${binding.route53_account_ref}' changed after adoption`);
}
return roleArn ? {
credentials: fromTemporaryCredentials2({
clientConfig: { region: "us-east-1" },
params: { RoleArn: roleArn, RoleSessionName: "hasna-domains-registrar" }
})
} : undefined;
};
const route53Provider = (binding) => createRoute53Provider(configForAccount(binding));
const registeredDetail = (detail) => ({
registered_at: detail.created || undefined,
expires_at: detail.expiry || undefined,
auto_renew: detail.auto_renew ?? undefined,
nameservers: detail.nameservers,
registrar: detail.registrar_name || "AWS Route 53"
});
const readRoute53Domain = async (name, config) => {
const detail = await findRegisteredDomainDetail(name, config);
return detail ? registeredDetail(detail) : null;
};
const requireBrandsight = () => {
if (!brandsight) {
throw new RegistrarActionRequiredError("Brandsight ownership or delegation requires the existing BRANDSIGHT_API_KEY, BRANDSIGHT_API_SECRET, and BRANDSIGHT_CUSTOMER_ID credential references");
}
return brandsight;
};
return {
async checkAvailability(name) {
const availability = await checkAvailability2(name);
return {
available: availability.available,
...availability.price !== undefined ? { price_usd: Number(availability.price) } : {},
...availability.price !== undefined ? { registration_price_usd: Number(availability.price) } : {},
...availability.renewal_price !== undefined ? { renewal_price_usd: Number(availability.renewal_price) } : {},
...availability.currency ? { currency: availability.currency } : {}
};
},
async submitRegistration(input) {
const contact = await getRegistrationContactFromDomain(registrantSourceDomain);
return registerDomain(input.name, contact, input.years, input.autoRenew, undefined, { privacy_protected: true });
},
getOperationStatus(operationId, route53Binding) {
return getRegistrationStatus(operationId, configForAccount(route53Binding));
},
async getDomainDetail(name, registrar = "route53", route53Binding) {
if (registrar === "brandsight") {
try {
const detail = await requireBrandsight().getDomainInfo(name);
if (detail.domain.toLowerCase().replace(/\.$/u, "") !== name) {
throw new RegistrarActionRequiredError("Brandsight ownership readback returned a different domain");
}
return {
registered_at: detail.created || undefined,
expires_at: detail.expires || undefined,
auto_renew: detail.auto_renew,
nameservers: detail.nameservers,
registrar: "Brandsight"
};
} catch (error) {
if (error instanceof RegistrarActionRequiredError)
throw error;
const message = error instanceof Error ? error.message : String(error);
if (/not found|not registered|404/i.test(message))
return null;
throw error;
}
}
return readRoute53Domain(name, configForAccount(route53Binding));
},
async resolveAdoptionAccount(name) {
if (admissionPause === "true") {
throw new RegistrarActionRequiredError("Route 53 adoption is paused for runtime rollout");
}
const candidates = [
{ ref: DEFAULT_ROUTE53_ACCOUNT_REF, roleArn: undefined },
...[...route53Accounts.entries()].map(([ref, roleArn]) => ({ ref, roleArn }))
];
return resolveRoute53AdoptionAccount(candidates, async (candidate) => {
const binding = {
route53_account_ref: candidate.ref,
route53_account_binding_sha256: route53AccountBindingFingerprint(candidate.roleArn)
};
return readRoute53Domain(name, configForAccount(binding));
});
},
async ensureCloudflareZone(name) {
const zone = await ensureZone(name, cloudflareConfig);
return { id: zone.id, status: zone.status, nameservers: zone.nameservers };
},
async updateNameservers(name, nameservers, registrar = "route53", route53Binding) {
if (registrar === "brandsight") {
const provider = requireBrandsight();
if (!provider.updateNameservers) {
throw new RegistrarActionRequiredError("Brandsight nameserver updates are unavailable");
}
const result = await provider.updateNameservers(name, nameservers);
if (!result.success) {
throw new Error("Brandsight nameserver update was not accepted");
}
return {
operationId: result.operationId || `brandsight:completed:${name}`,
completed: true
};
}
return updateNameservers2(name, nameservers, configForAccount(route53Binding));
},
async resolvePublicNameservers(name) {
return dns.resolveNs(name).catch(() => []);
},
async preserveRegistrarDnsBeforeDelegation(input) {
const registrar = input.registrar === "brandsight" ? requireBrandsight() : route53Provider(input.route53Binding);
const registrarRecords = await registrar.getDnsRecords(input.hostname);
if (input.registrar === "route53" && registrarRecords.length === 0) {
throw new RegistrarActionRequiredError("Route 53 has no readable hosted-zone records to preserve before delegation");
}
const source = canonicalDelegationRecords(registrarRecords, input.hostname);
await reconcileRecords(input.zoneId, source.map((record) => ({
type: record.type,
name: record.name,
content: record.value,
ttl: record.ttl,
...record.priority === null ? {} : { priority: record.priority },
...["A", "AAAA", "CNAME"].includes(record.type) ? { proxied: false } : {}
})), cloudflareConfig);
const expectedGroups = new Set(source.map((record) => `${record.type}|${record.name}`));
const readback = canonicalDelegationRecords((await listRecords(input.zoneId, cloudflareConfig)).filter((record) => expectedGroups.has(`${record.type.toUpperCase()}|${record.name.toLowerCase().replace(/\.$/u, "")}`)).map((record) => ({
type: record.type,
name: record.name,
value: record.content,
ttl: record.ttl,
priority: record.priority
})), input.hostname);
if (JSON.stringify(readback) !== JSON.stringify(source)) {
throw new RegistrarActionRequiredError("Cloudflare DNS readback does not match the registrar DNS snapshot");
}
return { count: source.length, sha256: delegationRecordHash(source) };
},
async bindWorkerDomain(input) {
await bindWorkerCustomDomain(input.hostname, input.zoneId, input.workerName, cloudflareConfig);
},
workerDomainReady(input) {
return workerCustomDomainReady(input.hostname, input.zoneId, input.workerName, cloudflareConfig, fetch, {
path: readinessPath,
header: readinessHeader,
value: readinessValue ?? input.workerName
});
},
ensureWebsiteOriginTls(input) {
return ensureZoneOriginTlsMode(input.zoneId, input.requestedMode, cloudflareConfig);
},
async configureWebsiteOrigin(input) {
const records = [input.hostname, `www.${input.hostname}`].map((name) => ({
type: "CNAME",
name,
content: input.originHostname,
proxied: true,
ttl: 1
}));
for (const record of records) {
await deleteRecordByNameType(input.zoneId, record.name, "A", cloudflareConfig);
await deleteRecordByNameType(input.zoneId, record.name, "AAAA", cloudflareConfig);
await upsertRecord(input.zoneId, record, cloudflareConfig);
}
return records.map((record) => ({
type: record.type,
name: record.name,
value: record.content,
proxied: record.proxied,
ttl: record.ttl
}));
},
async websiteOriginReady(input) {
if (await getZoneOriginTlsMode(input.zoneId, cloudflareConfig) !== input.originTlsMode) {
return false;
}
const records = await listRecords(input.zoneId, cloudflareConfig);
const names = new Set([input.hostname, `www.${input.hostname}`]);
const matching = records.filter((record) => record.type === "CNAME" && names.has(record.name.toLowerCase().replace(/\.$/u, "")) && record.content.toLowerCase().replace(/\.$/u, "") === input.originHostname && record.proxied === true);
if (matching.length !== names.size)
return false;
try {
const signal = AbortSignal.timeout(1e4);
const response = await fetch(`https://${input.hostname}/`, {
method: "GET",
redirect: "error",
signal,
headers: { "user-agent": "hasna-domains-provisioning/1" }
});
if (response.status !== 200 || !/^text\/html(?:;|$)/iu.test(response.headers.get("content-type") ?? "")) {
return false;
}
const body = await boundedResponseText(response, 1048576, signal);
const escapedHost = input.hostname.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
const canonical = new RegExp(`<link\\b(?=[^>]*\\brel=["'][^"']*\\bcanonical\\b[^"']*["'])(?=[^>]*\\bhref=["']https://${escapedHost}/?["'])[^>]*>`, "iu");
return canonical.test(body);
} catch {
return false;
}
},
async getDnsRecordState(input) {
return getDnsRecordGroupState(input.zoneId, input.recordType, input.recordName, cloudflareConfig);
},
async reconcileDnsRecords(input) {
const records = input.records.map((record) => ({
type: record.type,
name: record.name,
content: record.value,
ttl: record.ttl,
...record.priority === null ? {} : { priority: record.priority },
...record.type === "CNAME" ? { proxied: false } : {}
}));
if (input.mode === "preserve_mail") {
const applied = await reconcileMailRecords(input.zoneId, records, cloudflareConfig, input.assertLease, input.deadline);
return applied.map((record) => ({
type: record.type,
name: record.name,
value: record.content,
ttl: record.ttl,
priority: record.priority ?? null
}));
}
if (input.expectedCurrentRecordsSha256 !== undefined) {
const verifiedGroup = await reconcileGuardedRecords(input.zoneId, records, input.expectedCurrentRecordsSha256, cloudflareConfig, input.assertLease);
return { records: input.records, verifiedGroup };
} else
await reconcileRecords(input.zoneId, records, cloudflareConfig);
return input.records;
},
async dnsRecordsReady(input) {
if (input.verifiedGroup) {
const group = input.verifiedGroup;
if (group.zone_id !== input.zoneId || input.records.some((record) => record.name !== group.record_name || record.type !== group.record_type))
return false;
const current = await getDnsRecordGroupState(input.zoneId, group.record_type, group.record_name, cloudflareConfig, { assertLease: input.assertLease });
return current.records_sha256 === group.records_sha256;
}
const current = await listRecords(input.zoneId, cloudflareConfig, { assertLease: input.assertLease, deadline: input.deadline });
if (input.mode === "preserve_mail") {
for (const expected of input.records) {
if (expected.type !== "TXT")
continue;
let policy;
try {
policy = mailPolicyKind(expected.value);
} catch {
return false;
}
if (!policy)
continue;
let policies;
try {
policies = current.filter((record) => record.type === "TXT" && record.name.toLowerCase().replace(/\.$/u, "") === expected.name && mailPolicyKind(record.content) === policy);
} catch {
return false;
}
if (policies.length !== 1)
return false;
}
}
return input.records.every((expected) => current.some((record) => record.type === expected.type && record.name.toLowerCase().replace(/\.$/u, "") === expected.name && record.content === expected.value && record.ttl === expected.ttl && (record.priority ?? null) === expected.priority && (expected.type !== "CNAME" || record.proxied === false)));
},
async listRoute53HostedZoneIds(name) {
return (await listHostedZonesByDomain(name)).map((zone) => zone.id).sort();
},
async cleanupRoute53HostedZone(input) {
const cloudflare = await getZone(input.name, cloudflareConfig);
if (!cloudflare || !nameserversEqual2(cloudflare.nameservers, input.registrarNameservers))
return false;
const result = await deleteDefaultHostedZone(input.hostedZoneId, input.name, input.registrarNameservers);
return result.deleted;
}
};
}
// src/server/index.ts
var DEFAULT_PORT = 8080;
var SIGNING_KEY_ENVS = [
"HASNA_DOMAINS_API_SIGNING_KEY",
"HASNA_API_SIGNING_KEY",
"API_KEY_SIGNING_SECRET"
];
function normalizeEnv(env = process.env) {
if (!env["HASNA_DOMAINS_DATABASE_URL"] && env["DATABASE_URL"]) {
env["HASNA_DOMAINS_DATABASE_URL"] = env["DATABASE_URL"];
}
}
function resolveSigningSecret(env = process.env) {
for (const key of SIGNING_KEY_ENVS) {
const v = env[key]?.trim();
if (v)
return v;
}
throw new Error(`Missing API-key signing secret. Set ${SIGNING_KEY_ENVS[0]} (or ${SIGNING_KEY_ENVS[2]}).`);
}
function parseArg(name, fallback) {
const eq = process.argv.find((a) => a.startsWith(`${name}=`));
if (eq)
return eq.split("=")[1];
const idx = process.argv.indexOf(name);
if (idx >= 0 && process.argv[idx + 1])
return process.argv[idx + 1];
return fallback;
}
var USAGE = `domains-serve \u2014 standalone HTTP API server for @hasna/domains (PostgreSQL backend)
Usage: domains-serve [--port <n>] [--host <addr>]
Options:
--port <n> Port to listen on (default: $PORT or ${DEFAULT_PORT})
--host <addr> Address to bind (default: $HOST or 0.0.0.0)
-h, --help Print this help and exit
-V, --version Print the package version and exit
Environment:
HASNA_DOMAINS_DATABASE_URL PostgreSQL DSN (falls back to DATABASE_URL)
HASNA_DOMAINS_API_SIGNING_KEY HMAC signing secret for API keys
(falls back to API_KEY_SIGNING_SECRET)`;
function earlyArgAnswer(argv) {
if (argv.includes("--help") || argv.includes("-h"))
return USAGE;
if (argv.includes("--version") || argv.includes("-V"))
return getPackageVersion();
return;
}
async function main() {
const early = earlyArgAnswer(process.argv);
if (early !== undefined) {
console.log(early);
return;
}
await startDomainsServer({
port: Number(parseArg("--port", process.env["PORT"]) ?? DEFAULT_PORT),
host: parseArg("--host", process.env["HOST"]) ?? "0.0.0.0"
});
}
async function startDomainsServer(options) {
const { port, host } = options;
if (!Number.isInteger(port) || port < 1 || port > 65535)
throw new Error("Port must be an integer from 1 to 65535.");
if (!host.trim())
throw new Error("Host must not be blank.");
normalizeEnv();
const version = getPackageVersion();
const signingSecret = resolveSigningSecret();
const { client, connectionSource } = createServerPoolFromEnv("domains", {
applicationName: "domains-serve",
max: 5
});
const store = new ApiKeyStore(client);
const provisioning = new DomainProvisioningService(new DomainsProvisioningRepo(client), createHostedProvisioningProviders(process.env), {
intervalMs: Number(process.env["DOMAINS_PROVISIONING_INTERVAL_MS"] ?? "5000"),
maxAttempts: Number(process.env["DOMAINS_PROVISIONING_MAX_ATTEMPTS"] ?? "17280"),
shortlinksWorkerName: process.env["DOMAINS_SHORTLINKS_WORKER_NAME"]?.trim() || "shortlink-router",
log: (event, detail) => console.log(JSON.stringify({ level: "info", event, ...detail }))
});
provisioning.start();
const app = createServeApp({
db: client,
signingSecret,
version,
keyStatus: store.keyStatus,
provisioning,
audit: (e) => {
if (e.outcome === "deny") {
console.error(JSON.stringify({ level: "warn", event: "api_auth_deny", ...e }));
}
}
});
Bun.serve({
port,
hostname: host,
idleTimeout: 30,
fetch: (req) => app.handle(req)
});
console.log(JSON.stringify({
level: "info",
event: "domains_serve_started",
version,
port,
host,
dsnSource: connectionSource
}));
}
if (import.meta.main) {
main().catch((err) => {
console.error(JSON.stringify({ level: "error", event: "domains_serve_fatal", error: err instanceof Error ? err.message : String(err) }));
process.exit(1);
});
}
export {
SIGNING_KEY_ENVS,
USAGE,
normalizeEnv,
resolveSigningSecret,
startDomainsServer
};