Created
February 22, 2023 22:36
-
-
Save jymboche/2a435eb594a59a769fbbe55848513f60 to your computer and use it in GitHub Desktop.
This file has been truncated, but you can view the full file.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
#!/usr/bin/env node | |
"use strict"; | |
var __create = Object.create; | |
var __defProp = Object.defineProperty; | |
var __getOwnPropDesc = Object.getOwnPropertyDescriptor; | |
var __getOwnPropNames = Object.getOwnPropertyNames; | |
var __getProtoOf = Object.getPrototypeOf; | |
var __hasOwnProp = Object.prototype.hasOwnProperty; | |
var __esm = (fn, res) => function __init() { | |
return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res; | |
}; | |
var __commonJS = (cb, mod) => function __require() { | |
return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports; | |
}; | |
var __export = (target, all3) => { | |
for (var name in all3) | |
__defProp(target, name, { get: all3[name], enumerable: true }); | |
}; | |
var __copyProps = (to, from, except, desc) => { | |
if (from && typeof from === "object" || typeof from === "function") { | |
for (let key of __getOwnPropNames(from)) | |
if (!__hasOwnProp.call(to, key) && key !== except) | |
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable }); | |
} | |
return to; | |
}; | |
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps( | |
// If the importer is in node compatibility mode or this is not an ESM | |
// file that has been converted to a CommonJS file using a Babel- | |
// compatible transform (i.e. "__esModule" has not been set), then set | |
// "default" to the CommonJS "module.exports" for node compatibility. | |
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, | |
mod | |
)); | |
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod); | |
// ../../node_modules/.pnpm/tslib@2.4.0/node_modules/tslib/tslib.es6.js | |
var tslib_es6_exports = {}; | |
__export(tslib_es6_exports, { | |
__assign: () => __assign, | |
__asyncDelegator: () => __asyncDelegator, | |
__asyncGenerator: () => __asyncGenerator, | |
__asyncValues: () => __asyncValues, | |
__await: () => __await, | |
__awaiter: () => __awaiter, | |
__classPrivateFieldGet: () => __classPrivateFieldGet, | |
__classPrivateFieldIn: () => __classPrivateFieldIn, | |
__classPrivateFieldSet: () => __classPrivateFieldSet, | |
__createBinding: () => __createBinding, | |
__decorate: () => __decorate, | |
__exportStar: () => __exportStar, | |
__extends: () => __extends, | |
__generator: () => __generator, | |
__importDefault: () => __importDefault, | |
__importStar: () => __importStar, | |
__makeTemplateObject: () => __makeTemplateObject, | |
__metadata: () => __metadata, | |
__param: () => __param, | |
__read: () => __read, | |
__rest: () => __rest, | |
__spread: () => __spread, | |
__spreadArray: () => __spreadArray, | |
__spreadArrays: () => __spreadArrays, | |
__values: () => __values | |
}); | |
function __extends(d, b) { | |
if (typeof b !== "function" && b !== null) | |
throw new TypeError("Class extends value " + String(b) + " is not a constructor or null"); | |
extendStatics(d, b); | |
function __() { | |
this.constructor = d; | |
} | |
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); | |
} | |
function __rest(s, e) { | |
var t = {}; | |
for (var p in s) | |
if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) | |
t[p] = s[p]; | |
if (s != null && typeof Object.getOwnPropertySymbols === "function") | |
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { | |
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) | |
t[p[i]] = s[p[i]]; | |
} | |
return t; | |
} | |
function __decorate(decorators, target, key, desc) { | |
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; | |
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") | |
r = Reflect.decorate(decorators, target, key, desc); | |
else | |
for (var i = decorators.length - 1; i >= 0; i--) | |
if (d = decorators[i]) | |
r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; | |
return c > 3 && r && Object.defineProperty(target, key, r), r; | |
} | |
function __param(paramIndex, decorator) { | |
return function(target, key) { | |
decorator(target, key, paramIndex); | |
}; | |
} | |
function __metadata(metadataKey, metadataValue) { | |
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") | |
return Reflect.metadata(metadataKey, metadataValue); | |
} | |
function __awaiter(thisArg, _arguments, P, generator) { | |
function adopt(value) { | |
return value instanceof P ? value : new P(function(resolve) { | |
resolve(value); | |
}); | |
} | |
return new (P || (P = Promise))(function(resolve, reject) { | |
function fulfilled(value) { | |
try { | |
step(generator.next(value)); | |
} catch (e) { | |
reject(e); | |
} | |
} | |
function rejected(value) { | |
try { | |
step(generator["throw"](value)); | |
} catch (e) { | |
reject(e); | |
} | |
} | |
function step(result) { | |
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); | |
} | |
step((generator = generator.apply(thisArg, _arguments || [])).next()); | |
}); | |
} | |
function __generator(thisArg, body) { | |
var _ = { label: 0, sent: function() { | |
if (t[0] & 1) | |
throw t[1]; | |
return t[1]; | |
}, trys: [], ops: [] }, f, y, t, g; | |
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { | |
return this; | |
}), g; | |
function verb(n) { | |
return function(v) { | |
return step([n, v]); | |
}; | |
} | |
function step(op) { | |
if (f) | |
throw new TypeError("Generator is already executing."); | |
while (_) | |
try { | |
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) | |
return t; | |
if (y = 0, t) | |
op = [op[0] & 2, t.value]; | |
switch (op[0]) { | |
case 0: | |
case 1: | |
t = op; | |
break; | |
case 4: | |
_.label++; | |
return { value: op[1], done: false }; | |
case 5: | |
_.label++; | |
y = op[1]; | |
op = [0]; | |
continue; | |
case 7: | |
op = _.ops.pop(); | |
_.trys.pop(); | |
continue; | |
default: | |
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { | |
_ = 0; | |
continue; | |
} | |
if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) { | |
_.label = op[1]; | |
break; | |
} | |
if (op[0] === 6 && _.label < t[1]) { | |
_.label = t[1]; | |
t = op; | |
break; | |
} | |
if (t && _.label < t[2]) { | |
_.label = t[2]; | |
_.ops.push(op); | |
break; | |
} | |
if (t[2]) | |
_.ops.pop(); | |
_.trys.pop(); | |
continue; | |
} | |
op = body.call(thisArg, _); | |
} catch (e) { | |
op = [6, e]; | |
y = 0; | |
} finally { | |
f = t = 0; | |
} | |
if (op[0] & 5) | |
throw op[1]; | |
return { value: op[0] ? op[1] : void 0, done: true }; | |
} | |
} | |
function __exportStar(m, o) { | |
for (var p in m) | |
if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) | |
__createBinding(o, m, p); | |
} | |
function __values(o) { | |
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; | |
if (m) | |
return m.call(o); | |
if (o && typeof o.length === "number") | |
return { | |
next: function() { | |
if (o && i >= o.length) | |
o = void 0; | |
return { value: o && o[i++], done: !o }; | |
} | |
}; | |
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); | |
} | |
function __read(o, n) { | |
var m = typeof Symbol === "function" && o[Symbol.iterator]; | |
if (!m) | |
return o; | |
var i = m.call(o), r, ar = [], e; | |
try { | |
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) | |
ar.push(r.value); | |
} catch (error) { | |
e = { error }; | |
} finally { | |
try { | |
if (r && !r.done && (m = i["return"])) | |
m.call(i); | |
} finally { | |
if (e) | |
throw e.error; | |
} | |
} | |
return ar; | |
} | |
function __spread() { | |
for (var ar = [], i = 0; i < arguments.length; i++) | |
ar = ar.concat(__read(arguments[i])); | |
return ar; | |
} | |
function __spreadArrays() { | |
for (var s = 0, i = 0, il = arguments.length; i < il; i++) | |
s += arguments[i].length; | |
for (var r = Array(s), k = 0, i = 0; i < il; i++) | |
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) | |
r[k] = a[j]; | |
return r; | |
} | |
function __spreadArray(to, from, pack) { | |
if (pack || arguments.length === 2) | |
for (var i = 0, l = from.length, ar; i < l; i++) { | |
if (ar || !(i in from)) { | |
if (!ar) | |
ar = Array.prototype.slice.call(from, 0, i); | |
ar[i] = from[i]; | |
} | |
} | |
return to.concat(ar || Array.prototype.slice.call(from)); | |
} | |
function __await(v) { | |
return this instanceof __await ? (this.v = v, this) : new __await(v); | |
} | |
function __asyncGenerator(thisArg, _arguments, generator) { | |
if (!Symbol.asyncIterator) | |
throw new TypeError("Symbol.asyncIterator is not defined."); | |
var g = generator.apply(thisArg, _arguments || []), i, q = []; | |
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() { | |
return this; | |
}, i; | |
function verb(n) { | |
if (g[n]) | |
i[n] = function(v) { | |
return new Promise(function(a, b) { | |
q.push([n, v, a, b]) > 1 || resume(n, v); | |
}); | |
}; | |
} | |
function resume(n, v) { | |
try { | |
step(g[n](v)); | |
} catch (e) { | |
settle2(q[0][3], e); | |
} | |
} | |
function step(r) { | |
r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle2(q[0][2], r); | |
} | |
function fulfill(value) { | |
resume("next", value); | |
} | |
function reject(value) { | |
resume("throw", value); | |
} | |
function settle2(f, v) { | |
if (f(v), q.shift(), q.length) | |
resume(q[0][0], q[0][1]); | |
} | |
} | |
function __asyncDelegator(o) { | |
var i, p; | |
return i = {}, verb("next"), verb("throw", function(e) { | |
throw e; | |
}), verb("return"), i[Symbol.iterator] = function() { | |
return this; | |
}, i; | |
function verb(n, f) { | |
i[n] = o[n] ? function(v) { | |
return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; | |
} : f; | |
} | |
} | |
function __asyncValues(o) { | |
if (!Symbol.asyncIterator) | |
throw new TypeError("Symbol.asyncIterator is not defined."); | |
var m = o[Symbol.asyncIterator], i; | |
return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() { | |
return this; | |
}, i); | |
function verb(n) { | |
i[n] = o[n] && function(v) { | |
return new Promise(function(resolve, reject) { | |
v = o[n](v), settle2(resolve, reject, v.done, v.value); | |
}); | |
}; | |
} | |
function settle2(resolve, reject, d, v) { | |
Promise.resolve(v).then(function(v2) { | |
resolve({ value: v2, done: d }); | |
}, reject); | |
} | |
} | |
function __makeTemplateObject(cooked, raw) { | |
if (Object.defineProperty) { | |
Object.defineProperty(cooked, "raw", { value: raw }); | |
} else { | |
cooked.raw = raw; | |
} | |
return cooked; | |
} | |
function __importStar(mod) { | |
if (mod && mod.__esModule) | |
return mod; | |
var result = {}; | |
if (mod != null) { | |
for (var k in mod) | |
if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) | |
__createBinding(result, mod, k); | |
} | |
__setModuleDefault(result, mod); | |
return result; | |
} | |
function __importDefault(mod) { | |
return mod && mod.__esModule ? mod : { default: mod }; | |
} | |
function __classPrivateFieldGet(receiver, state, kind, f) { | |
if (kind === "a" && !f) | |
throw new TypeError("Private accessor was defined without a getter"); | |
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) | |
throw new TypeError("Cannot read private member from an object whose class did not declare it"); | |
return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver); | |
} | |
function __classPrivateFieldSet(receiver, state, value, kind, f) { | |
if (kind === "m") | |
throw new TypeError("Private method is not writable"); | |
if (kind === "a" && !f) | |
throw new TypeError("Private accessor was defined without a setter"); | |
if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) | |
throw new TypeError("Cannot write private member to an object whose class did not declare it"); | |
return kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value), value; | |
} | |
function __classPrivateFieldIn(state, receiver) { | |
if (receiver === null || typeof receiver !== "object" && typeof receiver !== "function") | |
throw new TypeError("Cannot use 'in' operator on non-object"); | |
return typeof state === "function" ? receiver === state : state.has(receiver); | |
} | |
var extendStatics, __assign, __createBinding, __setModuleDefault; | |
var init_tslib_es6 = __esm({ | |
"../../node_modules/.pnpm/tslib@2.4.0/node_modules/tslib/tslib.es6.js"() { | |
extendStatics = function(d, b) { | |
extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) { | |
d2.__proto__ = b2; | |
} || function(d2, b2) { | |
for (var p in b2) | |
if (Object.prototype.hasOwnProperty.call(b2, p)) | |
d2[p] = b2[p]; | |
}; | |
return extendStatics(d, b); | |
}; | |
__assign = function() { | |
__assign = Object.assign || function __assign3(t) { | |
for (var s, i = 1, n = arguments.length; i < n; i++) { | |
s = arguments[i]; | |
for (var p in s) | |
if (Object.prototype.hasOwnProperty.call(s, p)) | |
t[p] = s[p]; | |
} | |
return t; | |
}; | |
return __assign.apply(this, arguments); | |
}; | |
__createBinding = Object.create ? function(o, m, k, k2) { | |
if (k2 === void 0) | |
k2 = k; | |
var desc = Object.getOwnPropertyDescriptor(m, k); | |
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) { | |
desc = { enumerable: true, get: function() { | |
return m[k]; | |
} }; | |
} | |
Object.defineProperty(o, k2, desc); | |
} : function(o, m, k, k2) { | |
if (k2 === void 0) | |
k2 = k; | |
o[k2] = m[k]; | |
}; | |
__setModuleDefault = Object.create ? function(o, v) { | |
Object.defineProperty(o, "default", { enumerable: true, value: v }); | |
} : function(o, v) { | |
o["default"] = v; | |
}; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/service-customizations/s3.js | |
var require_s3 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/service-customizations/s3.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.isArnBucketName = exports.isDnsCompatibleBucketName = exports.S3_HOSTNAME_PATTERN = exports.DOT_PATTERN = exports.resolveParamsForS3 = void 0; | |
var resolveParamsForS3 = async (endpointParams) => { | |
const bucket = (endpointParams === null || endpointParams === void 0 ? void 0 : endpointParams.Bucket) || ""; | |
if (typeof endpointParams.Bucket === "string") { | |
endpointParams.Bucket = bucket.replace(/#/g, encodeURIComponent("#")).replace(/\?/g, encodeURIComponent("?")); | |
} | |
if ((0, exports.isArnBucketName)(bucket)) { | |
if (endpointParams.ForcePathStyle === true) { | |
throw new Error("Path-style addressing cannot be used with ARN buckets"); | |
} | |
} else if (!(0, exports.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; | |
}; | |
exports.resolveParamsForS3 = resolveParamsForS3; | |
var DOMAIN_PATTERN = /^[a-z0-9][a-z0-9\.\-]{1,61}[a-z0-9]$/; | |
var IP_ADDRESS_PATTERN = /(\d+\.){3}\d+/; | |
var DOTS_PATTERN = /\.\./; | |
exports.DOT_PATTERN = /\./; | |
exports.S3_HOSTNAME_PATTERN = /^(.+\.)?s3(-fips)?(\.dualstack)?[.-]([a-z0-9-]+)\./; | |
var isDnsCompatibleBucketName = (bucketName) => DOMAIN_PATTERN.test(bucketName) && !IP_ADDRESS_PATTERN.test(bucketName) && !DOTS_PATTERN.test(bucketName); | |
exports.isDnsCompatibleBucketName = isDnsCompatibleBucketName; | |
var isArnBucketName = (bucketName) => { | |
const [arn, partition, service, region, account, typeOrId] = bucketName.split(":"); | |
const isArn = arn === "arn" && bucketName.split(":").length >= 6; | |
const isValidArn = [arn, partition, service, account, typeOrId].filter(Boolean).length === 5; | |
if (isArn && !isValidArn) { | |
throw new Error(`Invalid ARN: ${bucketName} was an invalid ARN.`); | |
} | |
return arn === "arn" && !!partition && !!service && !!account && !!typeOrId; | |
}; | |
exports.isArnBucketName = isArnBucketName; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/service-customizations/index.js | |
var require_service_customizations = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/service-customizations/index.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); | |
tslib_1.__exportStar(require_s3(), exports); | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/adaptors/createConfigValueProvider.js | |
var require_createConfigValueProvider = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/adaptors/createConfigValueProvider.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.createConfigValueProvider = void 0; | |
var createConfigValueProvider = (configKey, canonicalEndpointParamKey, config) => { | |
const configProvider = async () => { | |
var _a; | |
const configValue = (_a = config[configKey]) !== null && _a !== void 0 ? _a : config[canonicalEndpointParamKey]; | |
if (typeof configValue === "function") { | |
return configValue(); | |
} | |
return configValue; | |
}; | |
if (configKey === "endpoint" || canonicalEndpointParamKey === "endpoint") { | |
return async () => { | |
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: path3 } = endpoint; | |
return `${protocol}//${hostname}${port ? ":" + port : ""}${path3}`; | |
} | |
} | |
return endpoint; | |
}; | |
} | |
return configProvider; | |
}; | |
exports.createConfigValueProvider = createConfigValueProvider; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/adaptors/getEndpointFromInstructions.js | |
var require_getEndpointFromInstructions = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/adaptors/getEndpointFromInstructions.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.resolveParams = exports.getEndpointFromInstructions = void 0; | |
var service_customizations_1 = require_service_customizations(); | |
var createConfigValueProvider_1 = require_createConfigValueProvider(); | |
var getEndpointFromInstructions = async (commandInput, instructionsSupplier, clientConfig, context) => { | |
const endpointParams = await (0, exports.resolveParams)(commandInput, instructionsSupplier, clientConfig); | |
if (typeof clientConfig.endpointProvider !== "function") { | |
throw new Error("config.endpointProvider is not set."); | |
} | |
const endpoint = clientConfig.endpointProvider(endpointParams, context); | |
return endpoint; | |
}; | |
exports.getEndpointFromInstructions = getEndpointFromInstructions; | |
var resolveParams = async (commandInput, instructionsSupplier, clientConfig) => { | |
var _a; | |
const endpointParams = {}; | |
const instructions = ((_a = instructionsSupplier === null || instructionsSupplier === void 0 ? void 0 : instructionsSupplier.getEndpointParameterInstructions) === null || _a === void 0 ? void 0 : _a.call(instructionsSupplier)) || {}; | |
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 (0, createConfigValueProvider_1.createConfigValueProvider)(instruction.name, name, clientConfig)(); | |
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 (0, service_customizations_1.resolveParamsForS3)(endpointParams); | |
} | |
return endpointParams; | |
}; | |
exports.resolveParams = resolveParams; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+querystring-parser@3.272.0/node_modules/@aws-sdk/querystring-parser/dist-cjs/index.js | |
var require_dist_cjs = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+querystring-parser@3.272.0/node_modules/@aws-sdk/querystring-parser/dist-cjs/index.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.parseQueryString = void 0; | |
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; | |
} | |
exports.parseQueryString = parseQueryString; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+url-parser@3.272.0/node_modules/@aws-sdk/url-parser/dist-cjs/index.js | |
var require_dist_cjs2 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+url-parser@3.272.0/node_modules/@aws-sdk/url-parser/dist-cjs/index.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.parseUrl = void 0; | |
var querystring_parser_1 = require_dist_cjs(); | |
var parseUrl = (url2) => { | |
if (typeof url2 === "string") { | |
return (0, exports.parseUrl)(new URL(url2)); | |
} | |
const { hostname, pathname, port, protocol, search } = url2; | |
let query; | |
if (search) { | |
query = (0, querystring_parser_1.parseQueryString)(search); | |
} | |
return { | |
hostname, | |
port: port ? parseInt(port) : void 0, | |
protocol, | |
path: pathname, | |
query | |
}; | |
}; | |
exports.parseUrl = parseUrl; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/adaptors/toEndpointV1.js | |
var require_toEndpointV1 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/adaptors/toEndpointV1.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.toEndpointV1 = void 0; | |
var url_parser_1 = require_dist_cjs2(); | |
var toEndpointV1 = (endpoint) => { | |
if (typeof endpoint === "object") { | |
if ("url" in endpoint) { | |
return (0, url_parser_1.parseUrl)(endpoint.url); | |
} | |
return endpoint; | |
} | |
return (0, url_parser_1.parseUrl)(endpoint); | |
}; | |
exports.toEndpointV1 = toEndpointV1; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/adaptors/index.js | |
var require_adaptors = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/adaptors/index.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); | |
tslib_1.__exportStar(require_getEndpointFromInstructions(), exports); | |
tslib_1.__exportStar(require_toEndpointV1(), exports); | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/endpointMiddleware.js | |
var require_endpointMiddleware = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/endpointMiddleware.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.endpointMiddleware = void 0; | |
var getEndpointFromInstructions_1 = require_getEndpointFromInstructions(); | |
var endpointMiddleware = ({ config, instructions }) => { | |
return (next, context) => async (args) => { | |
var _a, _b; | |
const endpoint = await (0, getEndpointFromInstructions_1.getEndpointFromInstructions)(args.input, { | |
getEndpointParameterInstructions() { | |
return instructions; | |
} | |
}, { ...config }, context); | |
context.endpointV2 = endpoint; | |
context.authSchemes = (_a = endpoint.properties) === null || _a === void 0 ? void 0 : _a.authSchemes; | |
const authScheme = (_b = context.authSchemes) === null || _b === void 0 ? void 0 : _b[0]; | |
if (authScheme) { | |
context["signing_region"] = authScheme.signingRegion; | |
context["signing_service"] = authScheme.signingName; | |
} | |
return next({ | |
...args | |
}); | |
}; | |
}; | |
exports.endpointMiddleware = endpointMiddleware; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-serde@3.272.0/node_modules/@aws-sdk/middleware-serde/dist-cjs/deserializerMiddleware.js | |
var require_deserializerMiddleware = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-serde@3.272.0/node_modules/@aws-sdk/middleware-serde/dist-cjs/deserializerMiddleware.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.deserializerMiddleware = void 0; | |
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 | |
}); | |
throw error; | |
} | |
}; | |
exports.deserializerMiddleware = deserializerMiddleware; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-serde@3.272.0/node_modules/@aws-sdk/middleware-serde/dist-cjs/serializerMiddleware.js | |
var require_serializerMiddleware = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-serde@3.272.0/node_modules/@aws-sdk/middleware-serde/dist-cjs/serializerMiddleware.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.serializerMiddleware = void 0; | |
var serializerMiddleware = (options, serializer) => (next, context) => async (args) => { | |
var _a; | |
const endpoint = ((_a = context.endpointV2) === null || _a === void 0 ? void 0 : _a.url) && options.urlParser ? async () => options.urlParser(context.endpointV2.url) : options.endpoint; | |
if (!endpoint) { | |
throw new Error("No valid endpoint provider available."); | |
} | |
const request = await serializer(args.input, { ...options, endpoint }); | |
return next({ | |
...args, | |
request | |
}); | |
}; | |
exports.serializerMiddleware = serializerMiddleware; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-serde@3.272.0/node_modules/@aws-sdk/middleware-serde/dist-cjs/serdePlugin.js | |
var require_serdePlugin = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-serde@3.272.0/node_modules/@aws-sdk/middleware-serde/dist-cjs/serdePlugin.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.getSerdePlugin = exports.serializerMiddlewareOption = exports.deserializerMiddlewareOption = void 0; | |
var deserializerMiddleware_1 = require_deserializerMiddleware(); | |
var serializerMiddleware_1 = require_serializerMiddleware(); | |
exports.deserializerMiddlewareOption = { | |
name: "deserializerMiddleware", | |
step: "deserialize", | |
tags: ["DESERIALIZER"], | |
override: true | |
}; | |
exports.serializerMiddlewareOption = { | |
name: "serializerMiddleware", | |
step: "serialize", | |
tags: ["SERIALIZER"], | |
override: true | |
}; | |
function getSerdePlugin(config, serializer, deserializer) { | |
return { | |
applyToStack: (commandStack) => { | |
commandStack.add((0, deserializerMiddleware_1.deserializerMiddleware)(config, deserializer), exports.deserializerMiddlewareOption); | |
commandStack.add((0, serializerMiddleware_1.serializerMiddleware)(config, serializer), exports.serializerMiddlewareOption); | |
} | |
}; | |
} | |
exports.getSerdePlugin = getSerdePlugin; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-serde@3.272.0/node_modules/@aws-sdk/middleware-serde/dist-cjs/index.js | |
var require_dist_cjs3 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-serde@3.272.0/node_modules/@aws-sdk/middleware-serde/dist-cjs/index.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); | |
tslib_1.__exportStar(require_deserializerMiddleware(), exports); | |
tslib_1.__exportStar(require_serdePlugin(), exports); | |
tslib_1.__exportStar(require_serializerMiddleware(), exports); | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/getEndpointPlugin.js | |
var require_getEndpointPlugin = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/getEndpointPlugin.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.getEndpointPlugin = exports.endpointMiddlewareOptions = void 0; | |
var middleware_serde_1 = require_dist_cjs3(); | |
var endpointMiddleware_1 = require_endpointMiddleware(); | |
exports.endpointMiddlewareOptions = { | |
step: "serialize", | |
tags: ["ENDPOINT_PARAMETERS", "ENDPOINT_V2", "ENDPOINT"], | |
name: "endpointV2Middleware", | |
override: true, | |
relation: "before", | |
toMiddleware: middleware_serde_1.serializerMiddlewareOption.name | |
}; | |
var getEndpointPlugin = (config, instructions) => ({ | |
applyToStack: (clientStack) => { | |
clientStack.addRelativeTo((0, endpointMiddleware_1.endpointMiddleware)({ | |
config, | |
instructions | |
}), exports.endpointMiddlewareOptions); | |
} | |
}); | |
exports.getEndpointPlugin = getEndpointPlugin; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+util-middleware@3.272.0/node_modules/@aws-sdk/util-middleware/dist-cjs/normalizeProvider.js | |
var require_normalizeProvider = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+util-middleware@3.272.0/node_modules/@aws-sdk/util-middleware/dist-cjs/normalizeProvider.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.normalizeProvider = void 0; | |
var normalizeProvider = (input) => { | |
if (typeof input === "function") | |
return input; | |
const promisified = Promise.resolve(input); | |
return () => promisified; | |
}; | |
exports.normalizeProvider = normalizeProvider; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+util-middleware@3.272.0/node_modules/@aws-sdk/util-middleware/dist-cjs/index.js | |
var require_dist_cjs4 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+util-middleware@3.272.0/node_modules/@aws-sdk/util-middleware/dist-cjs/index.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); | |
tslib_1.__exportStar(require_normalizeProvider(), exports); | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/resolveEndpointConfig.js | |
var require_resolveEndpointConfig = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/resolveEndpointConfig.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.resolveEndpointConfig = void 0; | |
var util_middleware_1 = require_dist_cjs4(); | |
var toEndpointV1_1 = require_toEndpointV1(); | |
var resolveEndpointConfig = (input) => { | |
var _a, _b, _c; | |
const tls = (_a = input.tls) !== null && _a !== void 0 ? _a : true; | |
const { endpoint } = input; | |
const customEndpointProvider = endpoint != null ? async () => (0, toEndpointV1_1.toEndpointV1)(await (0, util_middleware_1.normalizeProvider)(endpoint)()) : void 0; | |
const isCustomEndpoint = !!endpoint; | |
return { | |
...input, | |
endpoint: customEndpointProvider, | |
tls, | |
isCustomEndpoint, | |
useDualstackEndpoint: (0, util_middleware_1.normalizeProvider)((_b = input.useDualstackEndpoint) !== null && _b !== void 0 ? _b : false), | |
useFipsEndpoint: (0, util_middleware_1.normalizeProvider)((_c = input.useFipsEndpoint) !== null && _c !== void 0 ? _c : false) | |
}; | |
}; | |
exports.resolveEndpointConfig = resolveEndpointConfig; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/types.js | |
var require_types = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/types.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/index.js | |
var require_dist_cjs5 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-endpoint@3.272.0/node_modules/@aws-sdk/middleware-endpoint/dist-cjs/index.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); | |
tslib_1.__exportStar(require_adaptors(), exports); | |
tslib_1.__exportStar(require_endpointMiddleware(), exports); | |
tslib_1.__exportStar(require_getEndpointPlugin(), exports); | |
tslib_1.__exportStar(require_resolveEndpointConfig(), exports); | |
tslib_1.__exportStar(require_types(), exports); | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/NoOpLogger.js | |
var require_NoOpLogger = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/NoOpLogger.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.NoOpLogger = void 0; | |
var NoOpLogger = class { | |
trace() { | |
} | |
debug() { | |
} | |
info() { | |
} | |
warn() { | |
} | |
error() { | |
} | |
}; | |
exports.NoOpLogger = NoOpLogger; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-stack@3.272.0/node_modules/@aws-sdk/middleware-stack/dist-cjs/MiddlewareStack.js | |
var require_MiddlewareStack = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-stack@3.272.0/node_modules/@aws-sdk/middleware-stack/dist-cjs/MiddlewareStack.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.constructStack = void 0; | |
var constructStack = () => { | |
let absoluteEntries = []; | |
let relativeEntries = []; | |
const entriesNameSet = /* @__PURE__ */ 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) => { | |
if (entry.name && entry.name === toRemove) { | |
isRemoved = true; | |
entriesNameSet.delete(toRemove); | |
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; | |
if (entry.name) | |
entriesNameSet.delete(entry.name); | |
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 }); | |
}); | |
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: [] | |
}; | |
if (normalizedEntry.name) | |
normalizedEntriesNameMap[normalizedEntry.name] = normalizedEntry; | |
normalizedAbsoluteEntries.push(normalizedEntry); | |
}); | |
relativeEntries.forEach((entry) => { | |
const normalizedEntry = { | |
...entry, | |
before: [], | |
after: [] | |
}; | |
if (normalizedEntry.name) | |
normalizedEntriesNameMap[normalizedEntry.name] = normalizedEntry; | |
normalizedRelativeEntries.push(normalizedEntry); | |
}); | |
normalizedRelativeEntries.forEach((entry) => { | |
if (entry.toMiddleware) { | |
const toMiddleware = normalizedEntriesNameMap[entry.toMiddleware]; | |
if (toMiddleware === void 0) { | |
if (debug) { | |
return; | |
} | |
throw new Error(`${entry.toMiddleware} is not found when adding ${entry.name || "anonymous"} 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, expendedMiddlewareList) => { | |
wholeList.push(...expendedMiddlewareList); | |
return wholeList; | |
}, []); | |
return mainChain; | |
}; | |
const stack = { | |
add: (middleware, options = {}) => { | |
const { name, override } = options; | |
const entry = { | |
step: "initialize", | |
priority: "normal", | |
middleware, | |
...options | |
}; | |
if (name) { | |
if (entriesNameSet.has(name)) { | |
if (!override) | |
throw new Error(`Duplicate middleware name '${name}'`); | |
const toOverrideIndex = absoluteEntries.findIndex((entry2) => entry2.name === name); | |
const toOverride = absoluteEntries[toOverrideIndex]; | |
if (toOverride.step !== entry.step || toOverride.priority !== entry.priority) { | |
throw new Error(`"${name}" middleware with ${toOverride.priority} priority in ${toOverride.step} step cannot be overridden by same-name middleware with ${entry.priority} priority in ${entry.step} step.`); | |
} | |
absoluteEntries.splice(toOverrideIndex, 1); | |
} | |
entriesNameSet.add(name); | |
} | |
absoluteEntries.push(entry); | |
}, | |
addRelativeTo: (middleware, options) => { | |
const { name, override } = options; | |
const entry = { | |
middleware, | |
...options | |
}; | |
if (name) { | |
if (entriesNameSet.has(name)) { | |
if (!override) | |
throw new Error(`Duplicate middleware name '${name}'`); | |
const toOverrideIndex = relativeEntries.findIndex((entry2) => entry2.name === name); | |
const toOverride = relativeEntries[toOverrideIndex]; | |
if (toOverride.toMiddleware !== entry.toMiddleware || toOverride.relation !== entry.relation) { | |
throw new Error(`"${name}" middleware ${toOverride.relation} "${toOverride.toMiddleware}" middleware cannot be overridden by same-name middleware ${entry.relation} "${entry.toMiddleware}" middleware.`); | |
} | |
relativeEntries.splice(toOverrideIndex, 1); | |
} | |
entriesNameSet.add(name); | |
} | |
relativeEntries.push(entry); | |
}, | |
clone: () => cloneTo((0, exports.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 } = entry; | |
if (tags && tags.includes(toRemove)) { | |
if (name) | |
entriesNameSet.delete(name); | |
isRemoved = true; | |
return false; | |
} | |
return true; | |
}; | |
absoluteEntries = absoluteEntries.filter(filterCb); | |
relativeEntries = relativeEntries.filter(filterCb); | |
return isRemoved; | |
}, | |
concat: (from) => { | |
const cloned = cloneTo((0, exports.constructStack)()); | |
cloned.use(from); | |
return cloned; | |
}, | |
applyToStack: cloneTo, | |
identify: () => { | |
return getMiddlewareList(true).map((mw) => { | |
return mw.name + ": " + (mw.tags || []).join(","); | |
}); | |
}, | |
resolve: (handler, context) => { | |
for (const middleware of getMiddlewareList().map((entry) => entry.middleware).reverse()) { | |
handler = middleware(handler, context); | |
} | |
return handler; | |
} | |
}; | |
return stack; | |
}; | |
exports.constructStack = constructStack; | |
var stepWeights = { | |
initialize: 5, | |
serialize: 4, | |
build: 3, | |
finalizeRequest: 2, | |
deserialize: 1 | |
}; | |
var priorityWeights = { | |
high: 3, | |
normal: 2, | |
low: 1 | |
}; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-stack@3.272.0/node_modules/@aws-sdk/middleware-stack/dist-cjs/index.js | |
var require_dist_cjs6 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-stack@3.272.0/node_modules/@aws-sdk/middleware-stack/dist-cjs/index.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); | |
tslib_1.__exportStar(require_MiddlewareStack(), exports); | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/client.js | |
var require_client = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/client.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.Client = void 0; | |
var middleware_stack_1 = require_dist_cjs6(); | |
var Client = class { | |
constructor(config) { | |
this.middlewareStack = (0, middleware_stack_1.constructStack)(); | |
this.config = config; | |
} | |
send(command, optionsOrCb, cb) { | |
const options = typeof optionsOrCb !== "function" ? optionsOrCb : void 0; | |
const callback = typeof optionsOrCb === "function" ? optionsOrCb : cb; | |
const 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() { | |
if (this.config.requestHandler.destroy) | |
this.config.requestHandler.destroy(); | |
} | |
}; | |
exports.Client = Client; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/command.js | |
var require_command = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/command.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.Command = void 0; | |
var middleware_stack_1 = require_dist_cjs6(); | |
var Command = class { | |
constructor() { | |
this.middlewareStack = (0, middleware_stack_1.constructStack)(); | |
} | |
}; | |
exports.Command = Command; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/constants.js | |
var require_constants = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/constants.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.SENSITIVE_STRING = void 0; | |
exports.SENSITIVE_STRING = "***SensitiveInformation***"; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/parse-utils.js | |
var require_parse_utils = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/parse-utils.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.logger = exports.strictParseByte = exports.strictParseShort = exports.strictParseInt32 = exports.strictParseInt = exports.strictParseLong = exports.limitedParseFloat32 = exports.limitedParseFloat = exports.handleFloat = exports.limitedParseDouble = exports.strictParseFloat32 = exports.strictParseFloat = exports.strictParseDouble = exports.expectUnion = exports.expectString = exports.expectObject = exports.expectNonNull = exports.expectByte = exports.expectShort = exports.expectInt32 = exports.expectInt = exports.expectLong = exports.expectFloat32 = exports.expectNumber = exports.expectBoolean = exports.parseBoolean = void 0; | |
var parseBoolean = (value) => { | |
switch (value) { | |
case "true": | |
return true; | |
case "false": | |
return false; | |
default: | |
throw new Error(`Unable to parse boolean value "${value}"`); | |
} | |
}; | |
exports.parseBoolean = parseBoolean; | |
var expectBoolean = (value) => { | |
if (value === null || value === void 0) { | |
return void 0; | |
} | |
if (typeof value === "number") { | |
if (value === 0 || value === 1) { | |
exports.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") { | |
exports.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}`); | |
}; | |
exports.expectBoolean = expectBoolean; | |
var expectNumber = (value) => { | |
if (value === null || value === void 0) { | |
return void 0; | |
} | |
if (typeof value === "string") { | |
const parsed = parseFloat(value); | |
if (!Number.isNaN(parsed)) { | |
if (String(parsed) !== String(value)) { | |
exports.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}`); | |
}; | |
exports.expectNumber = expectNumber; | |
var MAX_FLOAT = Math.ceil(2 ** 127 * (2 - 2 ** -23)); | |
var expectFloat32 = (value) => { | |
const expected = (0, exports.expectNumber)(value); | |
if (expected !== void 0 && !Number.isNaN(expected) && expected !== Infinity && expected !== -Infinity) { | |
if (Math.abs(expected) > MAX_FLOAT) { | |
throw new TypeError(`Expected 32-bit float, got ${value}`); | |
} | |
} | |
return expected; | |
}; | |
exports.expectFloat32 = expectFloat32; | |
var expectLong = (value) => { | |
if (value === null || value === void 0) { | |
return void 0; | |
} | |
if (Number.isInteger(value) && !Number.isNaN(value)) { | |
return value; | |
} | |
throw new TypeError(`Expected integer, got ${typeof value}: ${value}`); | |
}; | |
exports.expectLong = expectLong; | |
exports.expectInt = exports.expectLong; | |
var expectInt32 = (value) => expectSizedInt(value, 32); | |
exports.expectInt32 = expectInt32; | |
var expectShort = (value) => expectSizedInt(value, 16); | |
exports.expectShort = expectShort; | |
var expectByte = (value) => expectSizedInt(value, 8); | |
exports.expectByte = expectByte; | |
var expectSizedInt = (value, size) => { | |
const expected = (0, exports.expectLong)(value); | |
if (expected !== void 0 && 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 === void 0) { | |
if (location) { | |
throw new TypeError(`Expected a non-null value for ${location}`); | |
} | |
throw new TypeError("Expected a non-null value"); | |
} | |
return value; | |
}; | |
exports.expectNonNull = expectNonNull; | |
var expectObject = (value) => { | |
if (value === null || value === void 0) { | |
return void 0; | |
} | |
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}`); | |
}; | |
exports.expectObject = expectObject; | |
var expectString = (value) => { | |
if (value === null || value === void 0) { | |
return void 0; | |
} | |
if (typeof value === "string") { | |
return value; | |
} | |
if (["boolean", "number", "bigint"].includes(typeof value)) { | |
exports.logger.warn(stackTraceWarning(`Expected string, got ${typeof value}: ${value}`)); | |
return String(value); | |
} | |
throw new TypeError(`Expected string, got ${typeof value}: ${value}`); | |
}; | |
exports.expectString = expectString; | |
var expectUnion = (value) => { | |
if (value === null || value === void 0) { | |
return void 0; | |
} | |
const asObject = (0, exports.expectObject)(value); | |
const setKeys = Object.entries(asObject).filter(([, v]) => v != null).map(([k]) => 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; | |
}; | |
exports.expectUnion = expectUnion; | |
var strictParseDouble = (value) => { | |
if (typeof value == "string") { | |
return (0, exports.expectNumber)(parseNumber(value)); | |
} | |
return (0, exports.expectNumber)(value); | |
}; | |
exports.strictParseDouble = strictParseDouble; | |
exports.strictParseFloat = exports.strictParseDouble; | |
var strictParseFloat32 = (value) => { | |
if (typeof value == "string") { | |
return (0, exports.expectFloat32)(parseNumber(value)); | |
} | |
return (0, exports.expectFloat32)(value); | |
}; | |
exports.strictParseFloat32 = strictParseFloat32; | |
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 (0, exports.expectNumber)(value); | |
}; | |
exports.limitedParseDouble = limitedParseDouble; | |
exports.handleFloat = exports.limitedParseDouble; | |
exports.limitedParseFloat = exports.limitedParseDouble; | |
var limitedParseFloat32 = (value) => { | |
if (typeof value == "string") { | |
return parseFloatString(value); | |
} | |
return (0, exports.expectFloat32)(value); | |
}; | |
exports.limitedParseFloat32 = limitedParseFloat32; | |
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 (0, exports.expectLong)(parseNumber(value)); | |
} | |
return (0, exports.expectLong)(value); | |
}; | |
exports.strictParseLong = strictParseLong; | |
exports.strictParseInt = exports.strictParseLong; | |
var strictParseInt32 = (value) => { | |
if (typeof value === "string") { | |
return (0, exports.expectInt32)(parseNumber(value)); | |
} | |
return (0, exports.expectInt32)(value); | |
}; | |
exports.strictParseInt32 = strictParseInt32; | |
var strictParseShort = (value) => { | |
if (typeof value === "string") { | |
return (0, exports.expectShort)(parseNumber(value)); | |
} | |
return (0, exports.expectShort)(value); | |
}; | |
exports.strictParseShort = strictParseShort; | |
var strictParseByte = (value) => { | |
if (typeof value === "string") { | |
return (0, exports.expectByte)(parseNumber(value)); | |
} | |
return (0, exports.expectByte)(value); | |
}; | |
exports.strictParseByte = strictParseByte; | |
var stackTraceWarning = (message) => { | |
return String(new TypeError(message).stack || message).split("\n").slice(0, 5).filter((s) => !s.includes("stackTraceWarning")).join("\n"); | |
}; | |
exports.logger = { | |
warn: console.warn | |
}; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/date-utils.js | |
var require_date_utils = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/date-utils.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.parseEpochTimestamp = exports.parseRfc7231DateTime = exports.parseRfc3339DateTimeWithOffset = exports.parseRfc3339DateTime = exports.dateToUtcString = void 0; | |
var parse_utils_1 = require_parse_utils(); | |
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`; | |
} | |
exports.dateToUtcString = dateToUtcString; | |
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 === void 0) { | |
return void 0; | |
} | |
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 = (0, parse_utils_1.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 }); | |
}; | |
exports.parseRfc3339DateTime = parseRfc3339DateTime; | |
var RFC3339_WITH_OFFSET = 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 === void 0) { | |
return void 0; | |
} | |
if (typeof value !== "string") { | |
throw new TypeError("RFC-3339 date-times must be expressed as strings"); | |
} | |
const match = RFC3339_WITH_OFFSET.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 = (0, parse_utils_1.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; | |
}; | |
exports.parseRfc3339DateTimeWithOffset = parseRfc3339DateTimeWithOffset; | |
var IMF_FIXDATE = 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 = 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 = 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 === void 0) { | |
return void 0; | |
} | |
if (typeof value !== "string") { | |
throw new TypeError("RFC-7231 date-times must be expressed as strings"); | |
} | |
let match = IMF_FIXDATE.exec(value); | |
if (match) { | |
const [_, dayStr, monthStr, yearStr, hours, minutes, seconds, fractionalMilliseconds] = match; | |
return buildDate((0, parse_utils_1.strictParseShort)(stripLeadingZeroes(yearStr)), parseMonthByShortName(monthStr), parseDateValue(dayStr, "day", 1, 31), { hours, minutes, seconds, fractionalMilliseconds }); | |
} | |
match = RFC_850_DATE.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.exec(value); | |
if (match) { | |
const [_, monthStr, dayStr, hours, minutes, seconds, fractionalMilliseconds, yearStr] = match; | |
return buildDate((0, parse_utils_1.strictParseShort)(stripLeadingZeroes(yearStr)), parseMonthByShortName(monthStr), parseDateValue(dayStr.trimLeft(), "day", 1, 31), { hours, minutes, seconds, fractionalMilliseconds }); | |
} | |
throw new TypeError("Invalid RFC-7231 date-time value"); | |
}; | |
exports.parseRfc7231DateTime = parseRfc7231DateTime; | |
var parseEpochTimestamp = (value) => { | |
if (value === null || value === void 0) { | |
return void 0; | |
} | |
let valueAsDouble; | |
if (typeof value === "number") { | |
valueAsDouble = value; | |
} else if (typeof value === "string") { | |
valueAsDouble = (0, parse_utils_1.strictParseDouble)(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 * 1e3)); | |
}; | |
exports.parseEpochTimestamp = parseEpochTimestamp; | |
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 = (/* @__PURE__ */ new Date()).getUTCFullYear(); | |
const valueInThisCentury = Math.floor(thisYear / 100) * 100 + (0, parse_utils_1.strictParseShort)(stripLeadingZeroes(value)); | |
if (valueInThisCentury < thisYear) { | |
return valueInThisCentury + 100; | |
} | |
return valueInThisCentury; | |
}; | |
var FIFTY_YEARS_IN_MILLIS = 50 * 365 * 24 * 60 * 60 * 1e3; | |
var adjustRfc850Year = (input) => { | |
if (input.getTime() - (/* @__PURE__ */ 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 = (0, parse_utils_1.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 === void 0) { | |
return 0; | |
} | |
return (0, parse_utils_1.strictParseFloat32)("0." + value) * 1e3; | |
}; | |
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 * 1e3; | |
}; | |
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); | |
}; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/exceptions.js | |
var require_exceptions = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/exceptions.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.decorateServiceException = exports.ServiceException = void 0; | |
var ServiceException = class extends Error { | |
constructor(options) { | |
super(options.message); | |
Object.setPrototypeOf(this, ServiceException.prototype); | |
this.name = options.name; | |
this.$fault = options.$fault; | |
this.$metadata = options.$metadata; | |
} | |
}; | |
exports.ServiceException = ServiceException; | |
var decorateServiceException = (exception, additions = {}) => { | |
Object.entries(additions).filter(([, v]) => v !== void 0).forEach(([k, v]) => { | |
if (exception[k] == void 0 || exception[k] === "") { | |
exception[k] = v; | |
} | |
}); | |
const message = exception.message || exception.Message || "UnknownError"; | |
exception.message = message; | |
delete exception.Message; | |
return exception; | |
}; | |
exports.decorateServiceException = decorateServiceException; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/default-error-handler.js | |
var require_default_error_handler = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/default-error-handler.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.throwDefaultError = void 0; | |
var exceptions_1 = require_exceptions(); | |
var throwDefaultError = ({ output, parsedBody, exceptionCtor, errorCode }) => { | |
const $metadata = deserializeMetadata(output); | |
const statusCode = $metadata.httpStatusCode ? $metadata.httpStatusCode + "" : void 0; | |
const response = new exceptionCtor({ | |
name: parsedBody.code || parsedBody.Code || errorCode || statusCode || "UnknownError", | |
$fault: "client", | |
$metadata | |
}); | |
throw (0, exceptions_1.decorateServiceException)(response, parsedBody); | |
}; | |
exports.throwDefaultError = throwDefaultError; | |
var deserializeMetadata = (output) => { | |
var _a, _b; | |
return { | |
httpStatusCode: output.statusCode, | |
requestId: (_b = (_a = output.headers["x-amzn-requestid"]) !== null && _a !== void 0 ? _a : output.headers["x-amzn-request-id"]) !== null && _b !== void 0 ? _b : output.headers["x-amz-request-id"], | |
extendedRequestId: output.headers["x-amz-id-2"], | |
cfId: output.headers["x-amz-cf-id"] | |
}; | |
}; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/defaults-mode.js | |
var require_defaults_mode = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/defaults-mode.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.loadConfigsForDefaultMode = void 0; | |
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: 3e4 | |
}; | |
default: | |
return {}; | |
} | |
}; | |
exports.loadConfigsForDefaultMode = loadConfigsForDefaultMode; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/emitWarningIfUnsupportedVersion.js | |
var require_emitWarningIfUnsupportedVersion = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/emitWarningIfUnsupportedVersion.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.emitWarningIfUnsupportedVersion = void 0; | |
var warningEmitted = false; | |
var emitWarningIfUnsupportedVersion = (version2) => { | |
if (version2 && !warningEmitted && parseInt(version2.substring(1, version2.indexOf("."))) < 14) { | |
warningEmitted = true; | |
} | |
}; | |
exports.emitWarningIfUnsupportedVersion = emitWarningIfUnsupportedVersion; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/extended-encode-uri-component.js | |
var require_extended_encode_uri_component = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/extended-encode-uri-component.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.extendedEncodeURIComponent = void 0; | |
function extendedEncodeURIComponent(str) { | |
return encodeURIComponent(str).replace(/[!'()*]/g, function(c) { | |
return "%" + c.charCodeAt(0).toString(16).toUpperCase(); | |
}); | |
} | |
exports.extendedEncodeURIComponent = extendedEncodeURIComponent; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/get-array-if-single-item.js | |
var require_get_array_if_single_item = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/get-array-if-single-item.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.getArrayIfSingleItem = void 0; | |
var getArrayIfSingleItem = (mayBeArray) => Array.isArray(mayBeArray) ? mayBeArray : [mayBeArray]; | |
exports.getArrayIfSingleItem = getArrayIfSingleItem; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/get-value-from-text-node.js | |
var require_get_value_from_text_node = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/get-value-from-text-node.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.getValueFromTextNode = void 0; | |
var getValueFromTextNode = (obj) => { | |
const textNodeName = "#text"; | |
for (const key in obj) { | |
if (obj.hasOwnProperty(key) && obj[key][textNodeName] !== void 0) { | |
obj[key] = obj[key][textNodeName]; | |
} else if (typeof obj[key] === "object" && obj[key] !== null) { | |
obj[key] = (0, exports.getValueFromTextNode)(obj[key]); | |
} | |
} | |
return obj; | |
}; | |
exports.getValueFromTextNode = getValueFromTextNode; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/lazy-json.js | |
var require_lazy_json = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/lazy-json.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.LazyJsonString = exports.StringWrapper = void 0; | |
var StringWrapper = function() { | |
const Class = Object.getPrototypeOf(this).constructor; | |
const Constructor = Function.bind.apply(String, [null, ...arguments]); | |
const instance = new Constructor(); | |
Object.setPrototypeOf(instance, Class.prototype); | |
return instance; | |
}; | |
exports.StringWrapper = StringWrapper; | |
exports.StringWrapper.prototype = Object.create(String.prototype, { | |
constructor: { | |
value: exports.StringWrapper, | |
enumerable: false, | |
writable: true, | |
configurable: true | |
} | |
}); | |
Object.setPrototypeOf(exports.StringWrapper, String); | |
var LazyJsonString = class extends exports.StringWrapper { | |
deserializeJSON() { | |
return JSON.parse(super.toString()); | |
} | |
toJSON() { | |
return super.toString(); | |
} | |
static fromObject(object) { | |
if (object instanceof LazyJsonString) { | |
return object; | |
} else if (object instanceof String || typeof object === "string") { | |
return new LazyJsonString(object); | |
} | |
return new LazyJsonString(JSON.stringify(object)); | |
} | |
}; | |
exports.LazyJsonString = LazyJsonString; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/object-mapping.js | |
var require_object_mapping = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/object-mapping.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.convertMap = exports.map = void 0; | |
function map(arg0, arg1, arg2) { | |
let target; | |
let filter2; | |
let instructions; | |
if (typeof arg1 === "undefined" && typeof arg2 === "undefined") { | |
target = {}; | |
instructions = arg0; | |
} else { | |
target = arg0; | |
if (typeof arg1 === "function") { | |
filter2 = arg1; | |
instructions = arg2; | |
return mapWithFilter(target, filter2, instructions); | |
} else { | |
instructions = arg1; | |
} | |
} | |
for (const key of Object.keys(instructions)) { | |
if (!Array.isArray(instructions[key])) { | |
target[key] = instructions[key]; | |
continue; | |
} | |
let [filter3, value] = instructions[key]; | |
if (typeof value === "function") { | |
let _value; | |
const defaultFilterPassed = filter3 === void 0 && (_value = value()) != null; | |
const customFilterPassed = typeof filter3 === "function" && !!filter3(void 0) || typeof filter3 !== "function" && !!filter3; | |
if (defaultFilterPassed) { | |
target[key] = _value; | |
} else if (customFilterPassed) { | |
target[key] = value(); | |
} | |
} else { | |
const defaultFilterPassed = filter3 === void 0 && value != null; | |
const customFilterPassed = typeof filter3 === "function" && !!filter3(value) || typeof filter3 !== "function" && !!filter3; | |
if (defaultFilterPassed || customFilterPassed) { | |
target[key] = value; | |
} | |
} | |
} | |
return target; | |
} | |
exports.map = map; | |
var convertMap = (target) => { | |
const output = {}; | |
for (const [k, v] of Object.entries(target || {})) { | |
output[k] = [, v]; | |
} | |
return output; | |
}; | |
exports.convertMap = convertMap; | |
var mapWithFilter = (target, filter2, 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] = [filter2, value()]; | |
} else { | |
_instructions[key] = [filter2, value]; | |
} | |
} | |
return _instructions; | |
}, {})); | |
}; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/resolve-path.js | |
var require_resolve_path = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/resolve-path.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.resolvedPath = void 0; | |
var extended_encode_uri_component_1 = require_extended_encode_uri_component(); | |
var resolvedPath = (resolvedPath2, input, memberName, labelValueProvider, uriLabel, isGreedyLabel) => { | |
if (input != null && input[memberName] !== void 0) { | |
const labelValue = labelValueProvider(); | |
if (labelValue.length <= 0) { | |
throw new Error("Empty value provided for input HTTP label: " + memberName + "."); | |
} | |
resolvedPath2 = resolvedPath2.replace(uriLabel, isGreedyLabel ? labelValue.split("/").map((segment) => (0, extended_encode_uri_component_1.extendedEncodeURIComponent)(segment)).join("/") : (0, extended_encode_uri_component_1.extendedEncodeURIComponent)(labelValue)); | |
} else { | |
throw new Error("No value provided for input HTTP label: " + memberName + "."); | |
} | |
return resolvedPath2; | |
}; | |
exports.resolvedPath = resolvedPath; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/ser-utils.js | |
var require_ser_utils = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/ser-utils.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.serializeFloat = void 0; | |
var serializeFloat = (value) => { | |
if (value !== value) { | |
return "NaN"; | |
} | |
switch (value) { | |
case Infinity: | |
return "Infinity"; | |
case -Infinity: | |
return "-Infinity"; | |
default: | |
return value; | |
} | |
}; | |
exports.serializeFloat = serializeFloat; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/split-every.js | |
var require_split_every = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/split-every.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.splitEvery = void 0; | |
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; | |
} | |
exports.splitEvery = splitEvery; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/index.js | |
var require_dist_cjs7 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+smithy-client@3.272.0/node_modules/@aws-sdk/smithy-client/dist-cjs/index.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); | |
tslib_1.__exportStar(require_NoOpLogger(), exports); | |
tslib_1.__exportStar(require_client(), exports); | |
tslib_1.__exportStar(require_command(), exports); | |
tslib_1.__exportStar(require_constants(), exports); | |
tslib_1.__exportStar(require_date_utils(), exports); | |
tslib_1.__exportStar(require_default_error_handler(), exports); | |
tslib_1.__exportStar(require_defaults_mode(), exports); | |
tslib_1.__exportStar(require_emitWarningIfUnsupportedVersion(), exports); | |
tslib_1.__exportStar(require_exceptions(), exports); | |
tslib_1.__exportStar(require_extended_encode_uri_component(), exports); | |
tslib_1.__exportStar(require_get_array_if_single_item(), exports); | |
tslib_1.__exportStar(require_get_value_from_text_node(), exports); | |
tslib_1.__exportStar(require_lazy_json(), exports); | |
tslib_1.__exportStar(require_object_mapping(), exports); | |
tslib_1.__exportStar(require_parse_utils(), exports); | |
tslib_1.__exportStar(require_resolve_path(), exports); | |
tslib_1.__exportStar(require_ser_utils(), exports); | |
tslib_1.__exportStar(require_split_every(), exports); | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/models/S3ServiceException.js | |
var require_S3ServiceException = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/models/S3ServiceException.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.S3ServiceException = void 0; | |
var smithy_client_1 = require_dist_cjs7(); | |
var S3ServiceException = class extends smithy_client_1.ServiceException { | |
constructor(options) { | |
super(options); | |
Object.setPrototypeOf(this, S3ServiceException.prototype); | |
} | |
}; | |
exports.S3ServiceException = S3ServiceException; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/models/models_0.js | |
var require_models_0 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/models/models_0.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.ChecksumMode = exports.ReplicationStatus = exports.Protocol = exports.BucketVersioningStatus = exports.MFADeleteStatus = exports.Payer = exports.ReplicationRuleStatus = exports.SseKmsEncryptedObjectsStatus = exports.ReplicaModificationsStatus = exports.ReplicationRuleFilter = exports.ExistingObjectReplicationStatus = exports.ReplicationTimeStatus = exports.MetricsStatus = exports.DeleteMarkerReplicationStatus = exports.FilterRuleName = exports.MetricsFilter = exports.BucketLogsPermission = exports.ExpirationStatus = exports.TransitionStorageClass = exports.LifecycleRuleFilter = exports.InventoryFrequency = exports.InventoryOptionalField = exports.InventoryIncludedObjectVersions = exports.InventoryFormat = exports.IntelligentTieringAccessTier = exports.IntelligentTieringStatus = exports.StorageClassAnalysisSchemaVersion = exports.AnalyticsS3ExportFileFormat = exports.AnalyticsFilter = exports.ObjectOwnership = exports.BucketLocationConstraint = exports.BucketCannedACL = exports.BucketAlreadyOwnedByYou = exports.BucketAlreadyExists = exports.ObjectNotInActiveTierError = exports.TaggingDirective = exports.StorageClass = exports.ObjectLockMode = exports.ObjectLockLegalHoldStatus = exports.MetadataDirective = exports.ChecksumAlgorithm = exports.ObjectCannedACL = exports.ServerSideEncryption = exports.OwnerOverride = exports.Permission = exports.Type = exports.BucketAccelerateStatus = exports.NoSuchUpload = exports.RequestPayer = exports.RequestCharged = void 0; | |
exports._ErrorFilterSensitiveLog = exports.DeletedObjectFilterSensitiveLog = exports.DeleteObjectRequestFilterSensitiveLog = exports.DeleteObjectOutputFilterSensitiveLog = exports.DeleteBucketWebsiteRequestFilterSensitiveLog = exports.DeleteBucketTaggingRequestFilterSensitiveLog = exports.DeleteBucketReplicationRequestFilterSensitiveLog = exports.DeleteBucketPolicyRequestFilterSensitiveLog = exports.DeleteBucketOwnershipControlsRequestFilterSensitiveLog = exports.DeleteBucketMetricsConfigurationRequestFilterSensitiveLog = exports.DeleteBucketLifecycleRequestFilterSensitiveLog = exports.DeleteBucketInventoryConfigurationRequestFilterSensitiveLog = exports.DeleteBucketIntelligentTieringConfigurationRequestFilterSensitiveLog = exports.DeleteBucketEncryptionRequestFilterSensitiveLog = exports.DeleteBucketCorsRequestFilterSensitiveLog = exports.DeleteBucketAnalyticsConfigurationRequestFilterSensitiveLog = exports.DeleteBucketRequestFilterSensitiveLog = exports.CreateMultipartUploadRequestFilterSensitiveLog = exports.CreateMultipartUploadOutputFilterSensitiveLog = exports.CreateBucketRequestFilterSensitiveLog = exports.CreateBucketConfigurationFilterSensitiveLog = exports.CreateBucketOutputFilterSensitiveLog = exports.CopyObjectRequestFilterSensitiveLog = exports.CopyObjectOutputFilterSensitiveLog = exports.CopyObjectResultFilterSensitiveLog = exports.CompleteMultipartUploadRequestFilterSensitiveLog = exports.CompletedMultipartUploadFilterSensitiveLog = exports.CompletedPartFilterSensitiveLog = exports.CompleteMultipartUploadOutputFilterSensitiveLog = exports.AccessControlTranslationFilterSensitiveLog = exports.AccessControlPolicyFilterSensitiveLog = exports.OwnerFilterSensitiveLog = exports.GrantFilterSensitiveLog = exports.GranteeFilterSensitiveLog = exports.AccelerateConfigurationFilterSensitiveLog = exports.AbortMultipartUploadRequestFilterSensitiveLog = exports.AbortMultipartUploadOutputFilterSensitiveLog = exports.AbortIncompleteMultipartUploadFilterSensitiveLog = exports.MFADelete = exports.ObjectVersionStorageClass = exports.NoSuchBucket = exports.ObjectStorageClass = exports.EncodingType = exports.ArchiveStatus = exports.NotFound = exports.ObjectLockRetentionMode = exports.ObjectLockEnabled = exports.ObjectAttributes = exports.NoSuchKey = exports.InvalidObjectState = void 0; | |
exports.NoncurrentVersionTransitionFilterSensitiveLog = exports.NoncurrentVersionExpirationFilterSensitiveLog = exports.LifecycleRuleFilterFilterSensitiveLog = exports.LifecycleRuleAndOperatorFilterSensitiveLog = exports.LifecycleExpirationFilterSensitiveLog = exports.GetBucketInventoryConfigurationRequestFilterSensitiveLog = exports.GetBucketInventoryConfigurationOutputFilterSensitiveLog = exports.InventoryConfigurationFilterSensitiveLog = exports.InventoryScheduleFilterSensitiveLog = exports.InventoryFilterFilterSensitiveLog = exports.InventoryDestinationFilterSensitiveLog = exports.InventoryS3BucketDestinationFilterSensitiveLog = exports.InventoryEncryptionFilterSensitiveLog = exports.SSES3FilterSensitiveLog = exports.SSEKMSFilterSensitiveLog = exports.GetBucketIntelligentTieringConfigurationRequestFilterSensitiveLog = exports.GetBucketIntelligentTieringConfigurationOutputFilterSensitiveLog = exports.IntelligentTieringConfigurationFilterSensitiveLog = exports.TieringFilterSensitiveLog = exports.IntelligentTieringFilterFilterSensitiveLog = exports.IntelligentTieringAndOperatorFilterSensitiveLog = exports.GetBucketEncryptionRequestFilterSensitiveLog = exports.GetBucketEncryptionOutputFilterSensitiveLog = exports.ServerSideEncryptionConfigurationFilterSensitiveLog = exports.ServerSideEncryptionRuleFilterSensitiveLog = exports.ServerSideEncryptionByDefaultFilterSensitiveLog = exports.GetBucketCorsRequestFilterSensitiveLog = exports.GetBucketCorsOutputFilterSensitiveLog = exports.CORSRuleFilterSensitiveLog = exports.GetBucketAnalyticsConfigurationRequestFilterSensitiveLog = exports.GetBucketAnalyticsConfigurationOutputFilterSensitiveLog = exports.AnalyticsConfigurationFilterSensitiveLog = exports.StorageClassAnalysisFilterSensitiveLog = exports.StorageClassAnalysisDataExportFilterSensitiveLog = exports.AnalyticsExportDestinationFilterSensitiveLog = exports.AnalyticsS3BucketDestinationFilterSensitiveLog = exports.AnalyticsFilterFilterSensitiveLog = exports.AnalyticsAndOperatorFilterSensitiveLog = exports.TagFilterSensitiveLog = exports.GetBucketAclRequestFilterSensitiveLog = exports.GetBucketAclOutputFilterSensitiveLog = exports.GetBucketAccelerateConfigurationRequestFilterSensitiveLog = exports.GetBucketAccelerateConfigurationOutputFilterSensitiveLog = exports.DeletePublicAccessBlockRequestFilterSensitiveLog = exports.DeleteObjectTaggingRequestFilterSensitiveLog = exports.DeleteObjectTaggingOutputFilterSensitiveLog = exports.DeleteObjectsRequestFilterSensitiveLog = exports.DeleteFilterSensitiveLog = exports.ObjectIdentifierFilterSensitiveLog = exports.DeleteObjectsOutputFilterSensitiveLog = void 0; | |
exports.GetBucketRequestPaymentOutputFilterSensitiveLog = exports.GetBucketReplicationRequestFilterSensitiveLog = exports.GetBucketReplicationOutputFilterSensitiveLog = exports.ReplicationConfigurationFilterSensitiveLog = exports.ReplicationRuleFilterSensitiveLog = exports.SourceSelectionCriteriaFilterSensitiveLog = exports.SseKmsEncryptedObjectsFilterSensitiveLog = exports.ReplicaModificationsFilterSensitiveLog = exports.ReplicationRuleFilterFilterSensitiveLog = exports.ReplicationRuleAndOperatorFilterSensitiveLog = exports.ExistingObjectReplicationFilterSensitiveLog = exports.DestinationFilterSensitiveLog = exports.ReplicationTimeFilterSensitiveLog = exports.MetricsFilterSensitiveLog = exports.ReplicationTimeValueFilterSensitiveLog = exports.EncryptionConfigurationFilterSensitiveLog = exports.DeleteMarkerReplicationFilterSensitiveLog = exports.GetBucketPolicyStatusRequestFilterSensitiveLog = exports.GetBucketPolicyStatusOutputFilterSensitiveLog = exports.PolicyStatusFilterSensitiveLog = exports.GetBucketPolicyRequestFilterSensitiveLog = exports.GetBucketPolicyOutputFilterSensitiveLog = exports.GetBucketOwnershipControlsRequestFilterSensitiveLog = exports.GetBucketOwnershipControlsOutputFilterSensitiveLog = exports.OwnershipControlsFilterSensitiveLog = exports.OwnershipControlsRuleFilterSensitiveLog = exports.NotificationConfigurationFilterSensitiveLog = exports.TopicConfigurationFilterSensitiveLog = exports.QueueConfigurationFilterSensitiveLog = exports.LambdaFunctionConfigurationFilterSensitiveLog = exports.NotificationConfigurationFilterFilterSensitiveLog = exports.S3KeyFilterFilterSensitiveLog = exports.FilterRuleFilterSensitiveLog = exports.EventBridgeConfigurationFilterSensitiveLog = exports.GetBucketNotificationConfigurationRequestFilterSensitiveLog = exports.GetBucketMetricsConfigurationRequestFilterSensitiveLog = exports.GetBucketMetricsConfigurationOutputFilterSensitiveLog = exports.MetricsConfigurationFilterSensitiveLog = exports.MetricsFilterFilterSensitiveLog = exports.MetricsAndOperatorFilterSensitiveLog = exports.GetBucketLoggingRequestFilterSensitiveLog = exports.GetBucketLoggingOutputFilterSensitiveLog = exports.LoggingEnabledFilterSensitiveLog = exports.TargetGrantFilterSensitiveLog = exports.GetBucketLocationRequestFilterSensitiveLog = exports.GetBucketLocationOutputFilterSensitiveLog = exports.GetBucketLifecycleConfigurationRequestFilterSensitiveLog = exports.GetBucketLifecycleConfigurationOutputFilterSensitiveLog = exports.LifecycleRuleFilterSensitiveLog = exports.TransitionFilterSensitiveLog = void 0; | |
exports.ListBucketMetricsConfigurationsOutputFilterSensitiveLog = exports.ListBucketInventoryConfigurationsRequestFilterSensitiveLog = exports.ListBucketInventoryConfigurationsOutputFilterSensitiveLog = exports.ListBucketIntelligentTieringConfigurationsRequestFilterSensitiveLog = exports.ListBucketIntelligentTieringConfigurationsOutputFilterSensitiveLog = exports.ListBucketAnalyticsConfigurationsRequestFilterSensitiveLog = exports.ListBucketAnalyticsConfigurationsOutputFilterSensitiveLog = exports.HeadObjectRequestFilterSensitiveLog = exports.HeadObjectOutputFilterSensitiveLog = exports.HeadBucketRequestFilterSensitiveLog = exports.GetPublicAccessBlockRequestFilterSensitiveLog = exports.GetPublicAccessBlockOutputFilterSensitiveLog = exports.PublicAccessBlockConfigurationFilterSensitiveLog = exports.GetObjectTorrentRequestFilterSensitiveLog = exports.GetObjectTorrentOutputFilterSensitiveLog = exports.GetObjectTaggingRequestFilterSensitiveLog = exports.GetObjectTaggingOutputFilterSensitiveLog = exports.GetObjectRetentionRequestFilterSensitiveLog = exports.GetObjectRetentionOutputFilterSensitiveLog = exports.ObjectLockRetentionFilterSensitiveLog = exports.GetObjectLockConfigurationRequestFilterSensitiveLog = exports.GetObjectLockConfigurationOutputFilterSensitiveLog = exports.ObjectLockConfigurationFilterSensitiveLog = exports.ObjectLockRuleFilterSensitiveLog = exports.DefaultRetentionFilterSensitiveLog = exports.GetObjectLegalHoldRequestFilterSensitiveLog = exports.GetObjectLegalHoldOutputFilterSensitiveLog = exports.ObjectLockLegalHoldFilterSensitiveLog = exports.GetObjectAttributesRequestFilterSensitiveLog = exports.GetObjectAttributesOutputFilterSensitiveLog = exports.GetObjectAttributesPartsFilterSensitiveLog = exports.ObjectPartFilterSensitiveLog = exports.ChecksumFilterSensitiveLog = exports.GetObjectAclRequestFilterSensitiveLog = exports.GetObjectAclOutputFilterSensitiveLog = exports.GetObjectRequestFilterSensitiveLog = exports.GetObjectOutputFilterSensitiveLog = exports.GetBucketWebsiteRequestFilterSensitiveLog = exports.GetBucketWebsiteOutputFilterSensitiveLog = exports.RoutingRuleFilterSensitiveLog = exports.RedirectFilterSensitiveLog = exports.ConditionFilterSensitiveLog = exports.RedirectAllRequestsToFilterSensitiveLog = exports.IndexDocumentFilterSensitiveLog = exports.ErrorDocumentFilterSensitiveLog = exports.GetBucketVersioningRequestFilterSensitiveLog = exports.GetBucketVersioningOutputFilterSensitiveLog = exports.GetBucketTaggingRequestFilterSensitiveLog = exports.GetBucketTaggingOutputFilterSensitiveLog = exports.GetBucketRequestPaymentRequestFilterSensitiveLog = void 0; | |
exports.PutObjectLegalHoldOutputFilterSensitiveLog = exports.PutObjectAclRequestFilterSensitiveLog = exports.PutObjectAclOutputFilterSensitiveLog = exports.PutObjectRequestFilterSensitiveLog = exports.PutObjectOutputFilterSensitiveLog = exports.PutBucketWebsiteRequestFilterSensitiveLog = exports.WebsiteConfigurationFilterSensitiveLog = exports.PutBucketVersioningRequestFilterSensitiveLog = exports.VersioningConfigurationFilterSensitiveLog = exports.PutBucketTaggingRequestFilterSensitiveLog = exports.TaggingFilterSensitiveLog = exports.PutBucketRequestPaymentRequestFilterSensitiveLog = exports.RequestPaymentConfigurationFilterSensitiveLog = exports.PutBucketReplicationRequestFilterSensitiveLog = exports.PutBucketPolicyRequestFilterSensitiveLog = exports.PutBucketOwnershipControlsRequestFilterSensitiveLog = exports.PutBucketNotificationConfigurationRequestFilterSensitiveLog = exports.PutBucketMetricsConfigurationRequestFilterSensitiveLog = exports.PutBucketLoggingRequestFilterSensitiveLog = exports.BucketLoggingStatusFilterSensitiveLog = exports.PutBucketLifecycleConfigurationRequestFilterSensitiveLog = exports.BucketLifecycleConfigurationFilterSensitiveLog = exports.PutBucketInventoryConfigurationRequestFilterSensitiveLog = exports.PutBucketIntelligentTieringConfigurationRequestFilterSensitiveLog = exports.PutBucketEncryptionRequestFilterSensitiveLog = exports.PutBucketCorsRequestFilterSensitiveLog = exports.CORSConfigurationFilterSensitiveLog = exports.PutBucketAnalyticsConfigurationRequestFilterSensitiveLog = exports.PutBucketAclRequestFilterSensitiveLog = exports.PutBucketAccelerateConfigurationRequestFilterSensitiveLog = exports.ListPartsRequestFilterSensitiveLog = exports.ListPartsOutputFilterSensitiveLog = exports.PartFilterSensitiveLog = exports.ListObjectVersionsRequestFilterSensitiveLog = exports.ListObjectVersionsOutputFilterSensitiveLog = exports.ObjectVersionFilterSensitiveLog = exports.DeleteMarkerEntryFilterSensitiveLog = exports.ListObjectsV2RequestFilterSensitiveLog = exports.ListObjectsV2OutputFilterSensitiveLog = exports.ListObjectsRequestFilterSensitiveLog = exports.ListObjectsOutputFilterSensitiveLog = exports._ObjectFilterSensitiveLog = exports.ListMultipartUploadsRequestFilterSensitiveLog = exports.ListMultipartUploadsOutputFilterSensitiveLog = exports.MultipartUploadFilterSensitiveLog = exports.InitiatorFilterSensitiveLog = exports.CommonPrefixFilterSensitiveLog = exports.ListBucketsOutputFilterSensitiveLog = exports.BucketFilterSensitiveLog = exports.ListBucketMetricsConfigurationsRequestFilterSensitiveLog = void 0; | |
exports.PutObjectLockConfigurationRequestFilterSensitiveLog = exports.PutObjectLockConfigurationOutputFilterSensitiveLog = exports.PutObjectLegalHoldRequestFilterSensitiveLog = void 0; | |
var smithy_client_1 = require_dist_cjs7(); | |
var S3ServiceException_1 = require_S3ServiceException(); | |
var RequestCharged; | |
(function(RequestCharged2) { | |
RequestCharged2["requester"] = "requester"; | |
})(RequestCharged = exports.RequestCharged || (exports.RequestCharged = {})); | |
var RequestPayer; | |
(function(RequestPayer2) { | |
RequestPayer2["requester"] = "requester"; | |
})(RequestPayer = exports.RequestPayer || (exports.RequestPayer = {})); | |
var NoSuchUpload = class extends S3ServiceException_1.S3ServiceException { | |
constructor(opts) { | |
super({ | |
name: "NoSuchUpload", | |
$fault: "client", | |
...opts | |
}); | |
this.name = "NoSuchUpload"; | |
this.$fault = "client"; | |
Object.setPrototypeOf(this, NoSuchUpload.prototype); | |
} | |
}; | |
exports.NoSuchUpload = NoSuchUpload; | |
var BucketAccelerateStatus; | |
(function(BucketAccelerateStatus2) { | |
BucketAccelerateStatus2["Enabled"] = "Enabled"; | |
BucketAccelerateStatus2["Suspended"] = "Suspended"; | |
})(BucketAccelerateStatus = exports.BucketAccelerateStatus || (exports.BucketAccelerateStatus = {})); | |
var Type; | |
(function(Type2) { | |
Type2["AmazonCustomerByEmail"] = "AmazonCustomerByEmail"; | |
Type2["CanonicalUser"] = "CanonicalUser"; | |
Type2["Group"] = "Group"; | |
})(Type = exports.Type || (exports.Type = {})); | |
var Permission; | |
(function(Permission2) { | |
Permission2["FULL_CONTROL"] = "FULL_CONTROL"; | |
Permission2["READ"] = "READ"; | |
Permission2["READ_ACP"] = "READ_ACP"; | |
Permission2["WRITE"] = "WRITE"; | |
Permission2["WRITE_ACP"] = "WRITE_ACP"; | |
})(Permission = exports.Permission || (exports.Permission = {})); | |
var OwnerOverride; | |
(function(OwnerOverride2) { | |
OwnerOverride2["Destination"] = "Destination"; | |
})(OwnerOverride = exports.OwnerOverride || (exports.OwnerOverride = {})); | |
var ServerSideEncryption; | |
(function(ServerSideEncryption2) { | |
ServerSideEncryption2["AES256"] = "AES256"; | |
ServerSideEncryption2["aws_kms"] = "aws:kms"; | |
})(ServerSideEncryption = exports.ServerSideEncryption || (exports.ServerSideEncryption = {})); | |
var ObjectCannedACL; | |
(function(ObjectCannedACL2) { | |
ObjectCannedACL2["authenticated_read"] = "authenticated-read"; | |
ObjectCannedACL2["aws_exec_read"] = "aws-exec-read"; | |
ObjectCannedACL2["bucket_owner_full_control"] = "bucket-owner-full-control"; | |
ObjectCannedACL2["bucket_owner_read"] = "bucket-owner-read"; | |
ObjectCannedACL2["private"] = "private"; | |
ObjectCannedACL2["public_read"] = "public-read"; | |
ObjectCannedACL2["public_read_write"] = "public-read-write"; | |
})(ObjectCannedACL = exports.ObjectCannedACL || (exports.ObjectCannedACL = {})); | |
var ChecksumAlgorithm; | |
(function(ChecksumAlgorithm2) { | |
ChecksumAlgorithm2["CRC32"] = "CRC32"; | |
ChecksumAlgorithm2["CRC32C"] = "CRC32C"; | |
ChecksumAlgorithm2["SHA1"] = "SHA1"; | |
ChecksumAlgorithm2["SHA256"] = "SHA256"; | |
})(ChecksumAlgorithm = exports.ChecksumAlgorithm || (exports.ChecksumAlgorithm = {})); | |
var MetadataDirective; | |
(function(MetadataDirective2) { | |
MetadataDirective2["COPY"] = "COPY"; | |
MetadataDirective2["REPLACE"] = "REPLACE"; | |
})(MetadataDirective = exports.MetadataDirective || (exports.MetadataDirective = {})); | |
var ObjectLockLegalHoldStatus; | |
(function(ObjectLockLegalHoldStatus2) { | |
ObjectLockLegalHoldStatus2["OFF"] = "OFF"; | |
ObjectLockLegalHoldStatus2["ON"] = "ON"; | |
})(ObjectLockLegalHoldStatus = exports.ObjectLockLegalHoldStatus || (exports.ObjectLockLegalHoldStatus = {})); | |
var ObjectLockMode; | |
(function(ObjectLockMode2) { | |
ObjectLockMode2["COMPLIANCE"] = "COMPLIANCE"; | |
ObjectLockMode2["GOVERNANCE"] = "GOVERNANCE"; | |
})(ObjectLockMode = exports.ObjectLockMode || (exports.ObjectLockMode = {})); | |
var StorageClass; | |
(function(StorageClass2) { | |
StorageClass2["DEEP_ARCHIVE"] = "DEEP_ARCHIVE"; | |
StorageClass2["GLACIER"] = "GLACIER"; | |
StorageClass2["GLACIER_IR"] = "GLACIER_IR"; | |
StorageClass2["INTELLIGENT_TIERING"] = "INTELLIGENT_TIERING"; | |
StorageClass2["ONEZONE_IA"] = "ONEZONE_IA"; | |
StorageClass2["OUTPOSTS"] = "OUTPOSTS"; | |
StorageClass2["REDUCED_REDUNDANCY"] = "REDUCED_REDUNDANCY"; | |
StorageClass2["STANDARD"] = "STANDARD"; | |
StorageClass2["STANDARD_IA"] = "STANDARD_IA"; | |
})(StorageClass = exports.StorageClass || (exports.StorageClass = {})); | |
var TaggingDirective; | |
(function(TaggingDirective2) { | |
TaggingDirective2["COPY"] = "COPY"; | |
TaggingDirective2["REPLACE"] = "REPLACE"; | |
})(TaggingDirective = exports.TaggingDirective || (exports.TaggingDirective = {})); | |
var ObjectNotInActiveTierError = class extends S3ServiceException_1.S3ServiceException { | |
constructor(opts) { | |
super({ | |
name: "ObjectNotInActiveTierError", | |
$fault: "client", | |
...opts | |
}); | |
this.name = "ObjectNotInActiveTierError"; | |
this.$fault = "client"; | |
Object.setPrototypeOf(this, ObjectNotInActiveTierError.prototype); | |
} | |
}; | |
exports.ObjectNotInActiveTierError = ObjectNotInActiveTierError; | |
var BucketAlreadyExists = class extends S3ServiceException_1.S3ServiceException { | |
constructor(opts) { | |
super({ | |
name: "BucketAlreadyExists", | |
$fault: "client", | |
...opts | |
}); | |
this.name = "BucketAlreadyExists"; | |
this.$fault = "client"; | |
Object.setPrototypeOf(this, BucketAlreadyExists.prototype); | |
} | |
}; | |
exports.BucketAlreadyExists = BucketAlreadyExists; | |
var BucketAlreadyOwnedByYou = class extends S3ServiceException_1.S3ServiceException { | |
constructor(opts) { | |
super({ | |
name: "BucketAlreadyOwnedByYou", | |
$fault: "client", | |
...opts | |
}); | |
this.name = "BucketAlreadyOwnedByYou"; | |
this.$fault = "client"; | |
Object.setPrototypeOf(this, BucketAlreadyOwnedByYou.prototype); | |
} | |
}; | |
exports.BucketAlreadyOwnedByYou = BucketAlreadyOwnedByYou; | |
var BucketCannedACL; | |
(function(BucketCannedACL2) { | |
BucketCannedACL2["authenticated_read"] = "authenticated-read"; | |
BucketCannedACL2["private"] = "private"; | |
BucketCannedACL2["public_read"] = "public-read"; | |
BucketCannedACL2["public_read_write"] = "public-read-write"; | |
})(BucketCannedACL = exports.BucketCannedACL || (exports.BucketCannedACL = {})); | |
var BucketLocationConstraint; | |
(function(BucketLocationConstraint2) { | |
BucketLocationConstraint2["EU"] = "EU"; | |
BucketLocationConstraint2["af_south_1"] = "af-south-1"; | |
BucketLocationConstraint2["ap_east_1"] = "ap-east-1"; | |
BucketLocationConstraint2["ap_northeast_1"] = "ap-northeast-1"; | |
BucketLocationConstraint2["ap_northeast_2"] = "ap-northeast-2"; | |
BucketLocationConstraint2["ap_northeast_3"] = "ap-northeast-3"; | |
BucketLocationConstraint2["ap_south_1"] = "ap-south-1"; | |
BucketLocationConstraint2["ap_southeast_1"] = "ap-southeast-1"; | |
BucketLocationConstraint2["ap_southeast_2"] = "ap-southeast-2"; | |
BucketLocationConstraint2["ap_southeast_3"] = "ap-southeast-3"; | |
BucketLocationConstraint2["ca_central_1"] = "ca-central-1"; | |
BucketLocationConstraint2["cn_north_1"] = "cn-north-1"; | |
BucketLocationConstraint2["cn_northwest_1"] = "cn-northwest-1"; | |
BucketLocationConstraint2["eu_central_1"] = "eu-central-1"; | |
BucketLocationConstraint2["eu_north_1"] = "eu-north-1"; | |
BucketLocationConstraint2["eu_south_1"] = "eu-south-1"; | |
BucketLocationConstraint2["eu_west_1"] = "eu-west-1"; | |
BucketLocationConstraint2["eu_west_2"] = "eu-west-2"; | |
BucketLocationConstraint2["eu_west_3"] = "eu-west-3"; | |
BucketLocationConstraint2["me_south_1"] = "me-south-1"; | |
BucketLocationConstraint2["sa_east_1"] = "sa-east-1"; | |
BucketLocationConstraint2["us_east_2"] = "us-east-2"; | |
BucketLocationConstraint2["us_gov_east_1"] = "us-gov-east-1"; | |
BucketLocationConstraint2["us_gov_west_1"] = "us-gov-west-1"; | |
BucketLocationConstraint2["us_west_1"] = "us-west-1"; | |
BucketLocationConstraint2["us_west_2"] = "us-west-2"; | |
})(BucketLocationConstraint = exports.BucketLocationConstraint || (exports.BucketLocationConstraint = {})); | |
var ObjectOwnership; | |
(function(ObjectOwnership2) { | |
ObjectOwnership2["BucketOwnerEnforced"] = "BucketOwnerEnforced"; | |
ObjectOwnership2["BucketOwnerPreferred"] = "BucketOwnerPreferred"; | |
ObjectOwnership2["ObjectWriter"] = "ObjectWriter"; | |
})(ObjectOwnership = exports.ObjectOwnership || (exports.ObjectOwnership = {})); | |
var AnalyticsFilter; | |
(function(AnalyticsFilter2) { | |
AnalyticsFilter2.visit = (value, visitor) => { | |
if (value.Prefix !== void 0) | |
return visitor.Prefix(value.Prefix); | |
if (value.Tag !== void 0) | |
return visitor.Tag(value.Tag); | |
if (value.And !== void 0) | |
return visitor.And(value.And); | |
return visitor._(value.$unknown[0], value.$unknown[1]); | |
}; | |
})(AnalyticsFilter = exports.AnalyticsFilter || (exports.AnalyticsFilter = {})); | |
var AnalyticsS3ExportFileFormat; | |
(function(AnalyticsS3ExportFileFormat2) { | |
AnalyticsS3ExportFileFormat2["CSV"] = "CSV"; | |
})(AnalyticsS3ExportFileFormat = exports.AnalyticsS3ExportFileFormat || (exports.AnalyticsS3ExportFileFormat = {})); | |
var StorageClassAnalysisSchemaVersion; | |
(function(StorageClassAnalysisSchemaVersion2) { | |
StorageClassAnalysisSchemaVersion2["V_1"] = "V_1"; | |
})(StorageClassAnalysisSchemaVersion = exports.StorageClassAnalysisSchemaVersion || (exports.StorageClassAnalysisSchemaVersion = {})); | |
var IntelligentTieringStatus; | |
(function(IntelligentTieringStatus2) { | |
IntelligentTieringStatus2["Disabled"] = "Disabled"; | |
IntelligentTieringStatus2["Enabled"] = "Enabled"; | |
})(IntelligentTieringStatus = exports.IntelligentTieringStatus || (exports.IntelligentTieringStatus = {})); | |
var IntelligentTieringAccessTier; | |
(function(IntelligentTieringAccessTier2) { | |
IntelligentTieringAccessTier2["ARCHIVE_ACCESS"] = "ARCHIVE_ACCESS"; | |
IntelligentTieringAccessTier2["DEEP_ARCHIVE_ACCESS"] = "DEEP_ARCHIVE_ACCESS"; | |
})(IntelligentTieringAccessTier = exports.IntelligentTieringAccessTier || (exports.IntelligentTieringAccessTier = {})); | |
var InventoryFormat; | |
(function(InventoryFormat2) { | |
InventoryFormat2["CSV"] = "CSV"; | |
InventoryFormat2["ORC"] = "ORC"; | |
InventoryFormat2["Parquet"] = "Parquet"; | |
})(InventoryFormat = exports.InventoryFormat || (exports.InventoryFormat = {})); | |
var InventoryIncludedObjectVersions; | |
(function(InventoryIncludedObjectVersions2) { | |
InventoryIncludedObjectVersions2["All"] = "All"; | |
InventoryIncludedObjectVersions2["Current"] = "Current"; | |
})(InventoryIncludedObjectVersions = exports.InventoryIncludedObjectVersions || (exports.InventoryIncludedObjectVersions = {})); | |
var InventoryOptionalField; | |
(function(InventoryOptionalField2) { | |
InventoryOptionalField2["BucketKeyStatus"] = "BucketKeyStatus"; | |
InventoryOptionalField2["ChecksumAlgorithm"] = "ChecksumAlgorithm"; | |
InventoryOptionalField2["ETag"] = "ETag"; | |
InventoryOptionalField2["EncryptionStatus"] = "EncryptionStatus"; | |
InventoryOptionalField2["IntelligentTieringAccessTier"] = "IntelligentTieringAccessTier"; | |
InventoryOptionalField2["IsMultipartUploaded"] = "IsMultipartUploaded"; | |
InventoryOptionalField2["LastModifiedDate"] = "LastModifiedDate"; | |
InventoryOptionalField2["ObjectLockLegalHoldStatus"] = "ObjectLockLegalHoldStatus"; | |
InventoryOptionalField2["ObjectLockMode"] = "ObjectLockMode"; | |
InventoryOptionalField2["ObjectLockRetainUntilDate"] = "ObjectLockRetainUntilDate"; | |
InventoryOptionalField2["ReplicationStatus"] = "ReplicationStatus"; | |
InventoryOptionalField2["Size"] = "Size"; | |
InventoryOptionalField2["StorageClass"] = "StorageClass"; | |
})(InventoryOptionalField = exports.InventoryOptionalField || (exports.InventoryOptionalField = {})); | |
var InventoryFrequency; | |
(function(InventoryFrequency2) { | |
InventoryFrequency2["Daily"] = "Daily"; | |
InventoryFrequency2["Weekly"] = "Weekly"; | |
})(InventoryFrequency = exports.InventoryFrequency || (exports.InventoryFrequency = {})); | |
var LifecycleRuleFilter; | |
(function(LifecycleRuleFilter2) { | |
LifecycleRuleFilter2.visit = (value, visitor) => { | |
if (value.Prefix !== void 0) | |
return visitor.Prefix(value.Prefix); | |
if (value.Tag !== void 0) | |
return visitor.Tag(value.Tag); | |
if (value.ObjectSizeGreaterThan !== void 0) | |
return visitor.ObjectSizeGreaterThan(value.ObjectSizeGreaterThan); | |
if (value.ObjectSizeLessThan !== void 0) | |
return visitor.ObjectSizeLessThan(value.ObjectSizeLessThan); | |
if (value.And !== void 0) | |
return visitor.And(value.And); | |
return visitor._(value.$unknown[0], value.$unknown[1]); | |
}; | |
})(LifecycleRuleFilter = exports.LifecycleRuleFilter || (exports.LifecycleRuleFilter = {})); | |
var TransitionStorageClass; | |
(function(TransitionStorageClass2) { | |
TransitionStorageClass2["DEEP_ARCHIVE"] = "DEEP_ARCHIVE"; | |
TransitionStorageClass2["GLACIER"] = "GLACIER"; | |
TransitionStorageClass2["GLACIER_IR"] = "GLACIER_IR"; | |
TransitionStorageClass2["INTELLIGENT_TIERING"] = "INTELLIGENT_TIERING"; | |
TransitionStorageClass2["ONEZONE_IA"] = "ONEZONE_IA"; | |
TransitionStorageClass2["STANDARD_IA"] = "STANDARD_IA"; | |
})(TransitionStorageClass = exports.TransitionStorageClass || (exports.TransitionStorageClass = {})); | |
var ExpirationStatus; | |
(function(ExpirationStatus2) { | |
ExpirationStatus2["Disabled"] = "Disabled"; | |
ExpirationStatus2["Enabled"] = "Enabled"; | |
})(ExpirationStatus = exports.ExpirationStatus || (exports.ExpirationStatus = {})); | |
var BucketLogsPermission; | |
(function(BucketLogsPermission2) { | |
BucketLogsPermission2["FULL_CONTROL"] = "FULL_CONTROL"; | |
BucketLogsPermission2["READ"] = "READ"; | |
BucketLogsPermission2["WRITE"] = "WRITE"; | |
})(BucketLogsPermission = exports.BucketLogsPermission || (exports.BucketLogsPermission = {})); | |
var MetricsFilter; | |
(function(MetricsFilter2) { | |
MetricsFilter2.visit = (value, visitor) => { | |
if (value.Prefix !== void 0) | |
return visitor.Prefix(value.Prefix); | |
if (value.Tag !== void 0) | |
return visitor.Tag(value.Tag); | |
if (value.AccessPointArn !== void 0) | |
return visitor.AccessPointArn(value.AccessPointArn); | |
if (value.And !== void 0) | |
return visitor.And(value.And); | |
return visitor._(value.$unknown[0], value.$unknown[1]); | |
}; | |
})(MetricsFilter = exports.MetricsFilter || (exports.MetricsFilter = {})); | |
var FilterRuleName; | |
(function(FilterRuleName2) { | |
FilterRuleName2["prefix"] = "prefix"; | |
FilterRuleName2["suffix"] = "suffix"; | |
})(FilterRuleName = exports.FilterRuleName || (exports.FilterRuleName = {})); | |
var DeleteMarkerReplicationStatus; | |
(function(DeleteMarkerReplicationStatus2) { | |
DeleteMarkerReplicationStatus2["Disabled"] = "Disabled"; | |
DeleteMarkerReplicationStatus2["Enabled"] = "Enabled"; | |
})(DeleteMarkerReplicationStatus = exports.DeleteMarkerReplicationStatus || (exports.DeleteMarkerReplicationStatus = {})); | |
var MetricsStatus; | |
(function(MetricsStatus2) { | |
MetricsStatus2["Disabled"] = "Disabled"; | |
MetricsStatus2["Enabled"] = "Enabled"; | |
})(MetricsStatus = exports.MetricsStatus || (exports.MetricsStatus = {})); | |
var ReplicationTimeStatus; | |
(function(ReplicationTimeStatus2) { | |
ReplicationTimeStatus2["Disabled"] = "Disabled"; | |
ReplicationTimeStatus2["Enabled"] = "Enabled"; | |
})(ReplicationTimeStatus = exports.ReplicationTimeStatus || (exports.ReplicationTimeStatus = {})); | |
var ExistingObjectReplicationStatus; | |
(function(ExistingObjectReplicationStatus2) { | |
ExistingObjectReplicationStatus2["Disabled"] = "Disabled"; | |
ExistingObjectReplicationStatus2["Enabled"] = "Enabled"; | |
})(ExistingObjectReplicationStatus = exports.ExistingObjectReplicationStatus || (exports.ExistingObjectReplicationStatus = {})); | |
var ReplicationRuleFilter; | |
(function(ReplicationRuleFilter2) { | |
ReplicationRuleFilter2.visit = (value, visitor) => { | |
if (value.Prefix !== void 0) | |
return visitor.Prefix(value.Prefix); | |
if (value.Tag !== void 0) | |
return visitor.Tag(value.Tag); | |
if (value.And !== void 0) | |
return visitor.And(value.And); | |
return visitor._(value.$unknown[0], value.$unknown[1]); | |
}; | |
})(ReplicationRuleFilter = exports.ReplicationRuleFilter || (exports.ReplicationRuleFilter = {})); | |
var ReplicaModificationsStatus; | |
(function(ReplicaModificationsStatus2) { | |
ReplicaModificationsStatus2["Disabled"] = "Disabled"; | |
ReplicaModificationsStatus2["Enabled"] = "Enabled"; | |
})(ReplicaModificationsStatus = exports.ReplicaModificationsStatus || (exports.ReplicaModificationsStatus = {})); | |
var SseKmsEncryptedObjectsStatus; | |
(function(SseKmsEncryptedObjectsStatus2) { | |
SseKmsEncryptedObjectsStatus2["Disabled"] = "Disabled"; | |
SseKmsEncryptedObjectsStatus2["Enabled"] = "Enabled"; | |
})(SseKmsEncryptedObjectsStatus = exports.SseKmsEncryptedObjectsStatus || (exports.SseKmsEncryptedObjectsStatus = {})); | |
var ReplicationRuleStatus; | |
(function(ReplicationRuleStatus2) { | |
ReplicationRuleStatus2["Disabled"] = "Disabled"; | |
ReplicationRuleStatus2["Enabled"] = "Enabled"; | |
})(ReplicationRuleStatus = exports.ReplicationRuleStatus || (exports.ReplicationRuleStatus = {})); | |
var Payer; | |
(function(Payer2) { | |
Payer2["BucketOwner"] = "BucketOwner"; | |
Payer2["Requester"] = "Requester"; | |
})(Payer = exports.Payer || (exports.Payer = {})); | |
var MFADeleteStatus; | |
(function(MFADeleteStatus2) { | |
MFADeleteStatus2["Disabled"] = "Disabled"; | |
MFADeleteStatus2["Enabled"] = "Enabled"; | |
})(MFADeleteStatus = exports.MFADeleteStatus || (exports.MFADeleteStatus = {})); | |
var BucketVersioningStatus; | |
(function(BucketVersioningStatus2) { | |
BucketVersioningStatus2["Enabled"] = "Enabled"; | |
BucketVersioningStatus2["Suspended"] = "Suspended"; | |
})(BucketVersioningStatus = exports.BucketVersioningStatus || (exports.BucketVersioningStatus = {})); | |
var Protocol; | |
(function(Protocol2) { | |
Protocol2["http"] = "http"; | |
Protocol2["https"] = "https"; | |
})(Protocol = exports.Protocol || (exports.Protocol = {})); | |
var ReplicationStatus; | |
(function(ReplicationStatus2) { | |
ReplicationStatus2["COMPLETE"] = "COMPLETE"; | |
ReplicationStatus2["FAILED"] = "FAILED"; | |
ReplicationStatus2["PENDING"] = "PENDING"; | |
ReplicationStatus2["REPLICA"] = "REPLICA"; | |
})(ReplicationStatus = exports.ReplicationStatus || (exports.ReplicationStatus = {})); | |
var ChecksumMode; | |
(function(ChecksumMode2) { | |
ChecksumMode2["ENABLED"] = "ENABLED"; | |
})(ChecksumMode = exports.ChecksumMode || (exports.ChecksumMode = {})); | |
var InvalidObjectState = class extends S3ServiceException_1.S3ServiceException { | |
constructor(opts) { | |
super({ | |
name: "InvalidObjectState", | |
$fault: "client", | |
...opts | |
}); | |
this.name = "InvalidObjectState"; | |
this.$fault = "client"; | |
Object.setPrototypeOf(this, InvalidObjectState.prototype); | |
this.StorageClass = opts.StorageClass; | |
this.AccessTier = opts.AccessTier; | |
} | |
}; | |
exports.InvalidObjectState = InvalidObjectState; | |
var NoSuchKey = class extends S3ServiceException_1.S3ServiceException { | |
constructor(opts) { | |
super({ | |
name: "NoSuchKey", | |
$fault: "client", | |
...opts | |
}); | |
this.name = "NoSuchKey"; | |
this.$fault = "client"; | |
Object.setPrototypeOf(this, NoSuchKey.prototype); | |
} | |
}; | |
exports.NoSuchKey = NoSuchKey; | |
var ObjectAttributes; | |
(function(ObjectAttributes2) { | |
ObjectAttributes2["CHECKSUM"] = "Checksum"; | |
ObjectAttributes2["ETAG"] = "ETag"; | |
ObjectAttributes2["OBJECT_PARTS"] = "ObjectParts"; | |
ObjectAttributes2["OBJECT_SIZE"] = "ObjectSize"; | |
ObjectAttributes2["STORAGE_CLASS"] = "StorageClass"; | |
})(ObjectAttributes = exports.ObjectAttributes || (exports.ObjectAttributes = {})); | |
var ObjectLockEnabled; | |
(function(ObjectLockEnabled2) { | |
ObjectLockEnabled2["Enabled"] = "Enabled"; | |
})(ObjectLockEnabled = exports.ObjectLockEnabled || (exports.ObjectLockEnabled = {})); | |
var ObjectLockRetentionMode; | |
(function(ObjectLockRetentionMode2) { | |
ObjectLockRetentionMode2["COMPLIANCE"] = "COMPLIANCE"; | |
ObjectLockRetentionMode2["GOVERNANCE"] = "GOVERNANCE"; | |
})(ObjectLockRetentionMode = exports.ObjectLockRetentionMode || (exports.ObjectLockRetentionMode = {})); | |
var NotFound = class extends S3ServiceException_1.S3ServiceException { | |
constructor(opts) { | |
super({ | |
name: "NotFound", | |
$fault: "client", | |
...opts | |
}); | |
this.name = "NotFound"; | |
this.$fault = "client"; | |
Object.setPrototypeOf(this, NotFound.prototype); | |
} | |
}; | |
exports.NotFound = NotFound; | |
var ArchiveStatus; | |
(function(ArchiveStatus2) { | |
ArchiveStatus2["ARCHIVE_ACCESS"] = "ARCHIVE_ACCESS"; | |
ArchiveStatus2["DEEP_ARCHIVE_ACCESS"] = "DEEP_ARCHIVE_ACCESS"; | |
})(ArchiveStatus = exports.ArchiveStatus || (exports.ArchiveStatus = {})); | |
var EncodingType; | |
(function(EncodingType2) { | |
EncodingType2["url"] = "url"; | |
})(EncodingType = exports.EncodingType || (exports.EncodingType = {})); | |
var ObjectStorageClass; | |
(function(ObjectStorageClass2) { | |
ObjectStorageClass2["DEEP_ARCHIVE"] = "DEEP_ARCHIVE"; | |
ObjectStorageClass2["GLACIER"] = "GLACIER"; | |
ObjectStorageClass2["GLACIER_IR"] = "GLACIER_IR"; | |
ObjectStorageClass2["INTELLIGENT_TIERING"] = "INTELLIGENT_TIERING"; | |
ObjectStorageClass2["ONEZONE_IA"] = "ONEZONE_IA"; | |
ObjectStorageClass2["OUTPOSTS"] = "OUTPOSTS"; | |
ObjectStorageClass2["REDUCED_REDUNDANCY"] = "REDUCED_REDUNDANCY"; | |
ObjectStorageClass2["STANDARD"] = "STANDARD"; | |
ObjectStorageClass2["STANDARD_IA"] = "STANDARD_IA"; | |
})(ObjectStorageClass = exports.ObjectStorageClass || (exports.ObjectStorageClass = {})); | |
var NoSuchBucket = class extends S3ServiceException_1.S3ServiceException { | |
constructor(opts) { | |
super({ | |
name: "NoSuchBucket", | |
$fault: "client", | |
...opts | |
}); | |
this.name = "NoSuchBucket"; | |
this.$fault = "client"; | |
Object.setPrototypeOf(this, NoSuchBucket.prototype); | |
} | |
}; | |
exports.NoSuchBucket = NoSuchBucket; | |
var ObjectVersionStorageClass; | |
(function(ObjectVersionStorageClass2) { | |
ObjectVersionStorageClass2["STANDARD"] = "STANDARD"; | |
})(ObjectVersionStorageClass = exports.ObjectVersionStorageClass || (exports.ObjectVersionStorageClass = {})); | |
var MFADelete; | |
(function(MFADelete2) { | |
MFADelete2["Disabled"] = "Disabled"; | |
MFADelete2["Enabled"] = "Enabled"; | |
})(MFADelete = exports.MFADelete || (exports.MFADelete = {})); | |
var AbortIncompleteMultipartUploadFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.AbortIncompleteMultipartUploadFilterSensitiveLog = AbortIncompleteMultipartUploadFilterSensitiveLog; | |
var AbortMultipartUploadOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.AbortMultipartUploadOutputFilterSensitiveLog = AbortMultipartUploadOutputFilterSensitiveLog; | |
var AbortMultipartUploadRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.AbortMultipartUploadRequestFilterSensitiveLog = AbortMultipartUploadRequestFilterSensitiveLog; | |
var AccelerateConfigurationFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.AccelerateConfigurationFilterSensitiveLog = AccelerateConfigurationFilterSensitiveLog; | |
var GranteeFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GranteeFilterSensitiveLog = GranteeFilterSensitiveLog; | |
var GrantFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GrantFilterSensitiveLog = GrantFilterSensitiveLog; | |
var OwnerFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.OwnerFilterSensitiveLog = OwnerFilterSensitiveLog; | |
var AccessControlPolicyFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.AccessControlPolicyFilterSensitiveLog = AccessControlPolicyFilterSensitiveLog; | |
var AccessControlTranslationFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.AccessControlTranslationFilterSensitiveLog = AccessControlTranslationFilterSensitiveLog; | |
var CompleteMultipartUploadOutputFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.SSEKMSKeyId && { SSEKMSKeyId: smithy_client_1.SENSITIVE_STRING } | |
}); | |
exports.CompleteMultipartUploadOutputFilterSensitiveLog = CompleteMultipartUploadOutputFilterSensitiveLog; | |
var CompletedPartFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.CompletedPartFilterSensitiveLog = CompletedPartFilterSensitiveLog; | |
var CompletedMultipartUploadFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.CompletedMultipartUploadFilterSensitiveLog = CompletedMultipartUploadFilterSensitiveLog; | |
var CompleteMultipartUploadRequestFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.SSECustomerKey && { SSECustomerKey: smithy_client_1.SENSITIVE_STRING } | |
}); | |
exports.CompleteMultipartUploadRequestFilterSensitiveLog = CompleteMultipartUploadRequestFilterSensitiveLog; | |
var CopyObjectResultFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.CopyObjectResultFilterSensitiveLog = CopyObjectResultFilterSensitiveLog; | |
var CopyObjectOutputFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.SSEKMSKeyId && { SSEKMSKeyId: smithy_client_1.SENSITIVE_STRING }, | |
...obj.SSEKMSEncryptionContext && { SSEKMSEncryptionContext: smithy_client_1.SENSITIVE_STRING } | |
}); | |
exports.CopyObjectOutputFilterSensitiveLog = CopyObjectOutputFilterSensitiveLog; | |
var CopyObjectRequestFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.SSECustomerKey && { SSECustomerKey: smithy_client_1.SENSITIVE_STRING }, | |
...obj.SSEKMSKeyId && { SSEKMSKeyId: smithy_client_1.SENSITIVE_STRING }, | |
...obj.SSEKMSEncryptionContext && { SSEKMSEncryptionContext: smithy_client_1.SENSITIVE_STRING }, | |
...obj.CopySourceSSECustomerKey && { CopySourceSSECustomerKey: smithy_client_1.SENSITIVE_STRING } | |
}); | |
exports.CopyObjectRequestFilterSensitiveLog = CopyObjectRequestFilterSensitiveLog; | |
var CreateBucketOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.CreateBucketOutputFilterSensitiveLog = CreateBucketOutputFilterSensitiveLog; | |
var CreateBucketConfigurationFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.CreateBucketConfigurationFilterSensitiveLog = CreateBucketConfigurationFilterSensitiveLog; | |
var CreateBucketRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.CreateBucketRequestFilterSensitiveLog = CreateBucketRequestFilterSensitiveLog; | |
var CreateMultipartUploadOutputFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.SSEKMSKeyId && { SSEKMSKeyId: smithy_client_1.SENSITIVE_STRING }, | |
...obj.SSEKMSEncryptionContext && { SSEKMSEncryptionContext: smithy_client_1.SENSITIVE_STRING } | |
}); | |
exports.CreateMultipartUploadOutputFilterSensitiveLog = CreateMultipartUploadOutputFilterSensitiveLog; | |
var CreateMultipartUploadRequestFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.SSECustomerKey && { SSECustomerKey: smithy_client_1.SENSITIVE_STRING }, | |
...obj.SSEKMSKeyId && { SSEKMSKeyId: smithy_client_1.SENSITIVE_STRING }, | |
...obj.SSEKMSEncryptionContext && { SSEKMSEncryptionContext: smithy_client_1.SENSITIVE_STRING } | |
}); | |
exports.CreateMultipartUploadRequestFilterSensitiveLog = CreateMultipartUploadRequestFilterSensitiveLog; | |
var DeleteBucketRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.DeleteBucketRequestFilterSensitiveLog = DeleteBucketRequestFilterSensitiveLog; | |
var DeleteBucketAnalyticsConfigurationRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.DeleteBucketAnalyticsConfigurationRequestFilterSensitiveLog = DeleteBucketAnalyticsConfigurationRequestFilterSensitiveLog; | |
var DeleteBucketCorsRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.DeleteBucketCorsRequestFilterSensitiveLog = DeleteBucketCorsRequestFilterSensitiveLog; | |
var DeleteBucketEncryptionRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.DeleteBucketEncryptionRequestFilterSensitiveLog = DeleteBucketEncryptionRequestFilterSensitiveLog; | |
var DeleteBucketIntelligentTieringConfigurationRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.DeleteBucketIntelligentTieringConfigurationRequestFilterSensitiveLog = DeleteBucketIntelligentTieringConfigurationRequestFilterSensitiveLog; | |
var DeleteBucketInventoryConfigurationRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.DeleteBucketInventoryConfigurationRequestFilterSensitiveLog = DeleteBucketInventoryConfigurationRequestFilterSensitiveLog; | |
var DeleteBucketLifecycleRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.DeleteBucketLifecycleRequestFilterSensitiveLog = DeleteBucketLifecycleRequestFilterSensitiveLog; | |
var DeleteBucketMetricsConfigurationRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.DeleteBucketMetricsConfigurationRequestFilterSensitiveLog = DeleteBucketMetricsConfigurationRequestFilterSensitiveLog; | |
var DeleteBucketOwnershipControlsRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.DeleteBucketOwnershipControlsRequestFilterSensitiveLog = DeleteBucketOwnershipControlsRequestFilterSensitiveLog; | |
var DeleteBucketPolicyRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.DeleteBucketPolicyRequestFilterSensitiveLog = DeleteBucketPolicyRequestFilterSensitiveLog; | |
var DeleteBucketReplicationRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.DeleteBucketReplicationRequestFilterSensitiveLog = DeleteBucketReplicationRequestFilterSensitiveLog; | |
var DeleteBucketTaggingRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.DeleteBucketTaggingRequestFilterSensitiveLog = DeleteBucketTaggingRequestFilterSensitiveLog; | |
var DeleteBucketWebsiteRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.DeleteBucketWebsiteRequestFilterSensitiveLog = DeleteBucketWebsiteRequestFilterSensitiveLog; | |
var DeleteObjectOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.DeleteObjectOutputFilterSensitiveLog = DeleteObjectOutputFilterSensitiveLog; | |
var DeleteObjectRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.DeleteObjectRequestFilterSensitiveLog = DeleteObjectRequestFilterSensitiveLog; | |
var DeletedObjectFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.DeletedObjectFilterSensitiveLog = DeletedObjectFilterSensitiveLog; | |
var _ErrorFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports._ErrorFilterSensitiveLog = _ErrorFilterSensitiveLog; | |
var DeleteObjectsOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.DeleteObjectsOutputFilterSensitiveLog = DeleteObjectsOutputFilterSensitiveLog; | |
var ObjectIdentifierFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ObjectIdentifierFilterSensitiveLog = ObjectIdentifierFilterSensitiveLog; | |
var DeleteFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.DeleteFilterSensitiveLog = DeleteFilterSensitiveLog; | |
var DeleteObjectsRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.DeleteObjectsRequestFilterSensitiveLog = DeleteObjectsRequestFilterSensitiveLog; | |
var DeleteObjectTaggingOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.DeleteObjectTaggingOutputFilterSensitiveLog = DeleteObjectTaggingOutputFilterSensitiveLog; | |
var DeleteObjectTaggingRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.DeleteObjectTaggingRequestFilterSensitiveLog = DeleteObjectTaggingRequestFilterSensitiveLog; | |
var DeletePublicAccessBlockRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.DeletePublicAccessBlockRequestFilterSensitiveLog = DeletePublicAccessBlockRequestFilterSensitiveLog; | |
var GetBucketAccelerateConfigurationOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketAccelerateConfigurationOutputFilterSensitiveLog = GetBucketAccelerateConfigurationOutputFilterSensitiveLog; | |
var GetBucketAccelerateConfigurationRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketAccelerateConfigurationRequestFilterSensitiveLog = GetBucketAccelerateConfigurationRequestFilterSensitiveLog; | |
var GetBucketAclOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketAclOutputFilterSensitiveLog = GetBucketAclOutputFilterSensitiveLog; | |
var GetBucketAclRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketAclRequestFilterSensitiveLog = GetBucketAclRequestFilterSensitiveLog; | |
var TagFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.TagFilterSensitiveLog = TagFilterSensitiveLog; | |
var AnalyticsAndOperatorFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.AnalyticsAndOperatorFilterSensitiveLog = AnalyticsAndOperatorFilterSensitiveLog; | |
var AnalyticsFilterFilterSensitiveLog = (obj) => { | |
if (obj.Prefix !== void 0) | |
return { Prefix: obj.Prefix }; | |
if (obj.Tag !== void 0) | |
return { Tag: (0, exports.TagFilterSensitiveLog)(obj.Tag) }; | |
if (obj.And !== void 0) | |
return { And: (0, exports.AnalyticsAndOperatorFilterSensitiveLog)(obj.And) }; | |
if (obj.$unknown !== void 0) | |
return { [obj.$unknown[0]]: "UNKNOWN" }; | |
}; | |
exports.AnalyticsFilterFilterSensitiveLog = AnalyticsFilterFilterSensitiveLog; | |
var AnalyticsS3BucketDestinationFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.AnalyticsS3BucketDestinationFilterSensitiveLog = AnalyticsS3BucketDestinationFilterSensitiveLog; | |
var AnalyticsExportDestinationFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.AnalyticsExportDestinationFilterSensitiveLog = AnalyticsExportDestinationFilterSensitiveLog; | |
var StorageClassAnalysisDataExportFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.StorageClassAnalysisDataExportFilterSensitiveLog = StorageClassAnalysisDataExportFilterSensitiveLog; | |
var StorageClassAnalysisFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.StorageClassAnalysisFilterSensitiveLog = StorageClassAnalysisFilterSensitiveLog; | |
var AnalyticsConfigurationFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.Filter && { Filter: (0, exports.AnalyticsFilterFilterSensitiveLog)(obj.Filter) } | |
}); | |
exports.AnalyticsConfigurationFilterSensitiveLog = AnalyticsConfigurationFilterSensitiveLog; | |
var GetBucketAnalyticsConfigurationOutputFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.AnalyticsConfiguration && { | |
AnalyticsConfiguration: (0, exports.AnalyticsConfigurationFilterSensitiveLog)(obj.AnalyticsConfiguration) | |
} | |
}); | |
exports.GetBucketAnalyticsConfigurationOutputFilterSensitiveLog = GetBucketAnalyticsConfigurationOutputFilterSensitiveLog; | |
var GetBucketAnalyticsConfigurationRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketAnalyticsConfigurationRequestFilterSensitiveLog = GetBucketAnalyticsConfigurationRequestFilterSensitiveLog; | |
var CORSRuleFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.CORSRuleFilterSensitiveLog = CORSRuleFilterSensitiveLog; | |
var GetBucketCorsOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketCorsOutputFilterSensitiveLog = GetBucketCorsOutputFilterSensitiveLog; | |
var GetBucketCorsRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketCorsRequestFilterSensitiveLog = GetBucketCorsRequestFilterSensitiveLog; | |
var ServerSideEncryptionByDefaultFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.KMSMasterKeyID && { KMSMasterKeyID: smithy_client_1.SENSITIVE_STRING } | |
}); | |
exports.ServerSideEncryptionByDefaultFilterSensitiveLog = ServerSideEncryptionByDefaultFilterSensitiveLog; | |
var ServerSideEncryptionRuleFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.ApplyServerSideEncryptionByDefault && { | |
ApplyServerSideEncryptionByDefault: (0, exports.ServerSideEncryptionByDefaultFilterSensitiveLog)(obj.ApplyServerSideEncryptionByDefault) | |
} | |
}); | |
exports.ServerSideEncryptionRuleFilterSensitiveLog = ServerSideEncryptionRuleFilterSensitiveLog; | |
var ServerSideEncryptionConfigurationFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.Rules && { Rules: obj.Rules.map((item) => (0, exports.ServerSideEncryptionRuleFilterSensitiveLog)(item)) } | |
}); | |
exports.ServerSideEncryptionConfigurationFilterSensitiveLog = ServerSideEncryptionConfigurationFilterSensitiveLog; | |
var GetBucketEncryptionOutputFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.ServerSideEncryptionConfiguration && { | |
ServerSideEncryptionConfiguration: (0, exports.ServerSideEncryptionConfigurationFilterSensitiveLog)(obj.ServerSideEncryptionConfiguration) | |
} | |
}); | |
exports.GetBucketEncryptionOutputFilterSensitiveLog = GetBucketEncryptionOutputFilterSensitiveLog; | |
var GetBucketEncryptionRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketEncryptionRequestFilterSensitiveLog = GetBucketEncryptionRequestFilterSensitiveLog; | |
var IntelligentTieringAndOperatorFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.IntelligentTieringAndOperatorFilterSensitiveLog = IntelligentTieringAndOperatorFilterSensitiveLog; | |
var IntelligentTieringFilterFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.IntelligentTieringFilterFilterSensitiveLog = IntelligentTieringFilterFilterSensitiveLog; | |
var TieringFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.TieringFilterSensitiveLog = TieringFilterSensitiveLog; | |
var IntelligentTieringConfigurationFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.IntelligentTieringConfigurationFilterSensitiveLog = IntelligentTieringConfigurationFilterSensitiveLog; | |
var GetBucketIntelligentTieringConfigurationOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketIntelligentTieringConfigurationOutputFilterSensitiveLog = GetBucketIntelligentTieringConfigurationOutputFilterSensitiveLog; | |
var GetBucketIntelligentTieringConfigurationRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketIntelligentTieringConfigurationRequestFilterSensitiveLog = GetBucketIntelligentTieringConfigurationRequestFilterSensitiveLog; | |
var SSEKMSFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.KeyId && { KeyId: smithy_client_1.SENSITIVE_STRING } | |
}); | |
exports.SSEKMSFilterSensitiveLog = SSEKMSFilterSensitiveLog; | |
var SSES3FilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.SSES3FilterSensitiveLog = SSES3FilterSensitiveLog; | |
var InventoryEncryptionFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.SSEKMS && { SSEKMS: (0, exports.SSEKMSFilterSensitiveLog)(obj.SSEKMS) } | |
}); | |
exports.InventoryEncryptionFilterSensitiveLog = InventoryEncryptionFilterSensitiveLog; | |
var InventoryS3BucketDestinationFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.Encryption && { Encryption: (0, exports.InventoryEncryptionFilterSensitiveLog)(obj.Encryption) } | |
}); | |
exports.InventoryS3BucketDestinationFilterSensitiveLog = InventoryS3BucketDestinationFilterSensitiveLog; | |
var InventoryDestinationFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.S3BucketDestination && { | |
S3BucketDestination: (0, exports.InventoryS3BucketDestinationFilterSensitiveLog)(obj.S3BucketDestination) | |
} | |
}); | |
exports.InventoryDestinationFilterSensitiveLog = InventoryDestinationFilterSensitiveLog; | |
var InventoryFilterFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.InventoryFilterFilterSensitiveLog = InventoryFilterFilterSensitiveLog; | |
var InventoryScheduleFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.InventoryScheduleFilterSensitiveLog = InventoryScheduleFilterSensitiveLog; | |
var InventoryConfigurationFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.Destination && { Destination: (0, exports.InventoryDestinationFilterSensitiveLog)(obj.Destination) } | |
}); | |
exports.InventoryConfigurationFilterSensitiveLog = InventoryConfigurationFilterSensitiveLog; | |
var GetBucketInventoryConfigurationOutputFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.InventoryConfiguration && { | |
InventoryConfiguration: (0, exports.InventoryConfigurationFilterSensitiveLog)(obj.InventoryConfiguration) | |
} | |
}); | |
exports.GetBucketInventoryConfigurationOutputFilterSensitiveLog = GetBucketInventoryConfigurationOutputFilterSensitiveLog; | |
var GetBucketInventoryConfigurationRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketInventoryConfigurationRequestFilterSensitiveLog = GetBucketInventoryConfigurationRequestFilterSensitiveLog; | |
var LifecycleExpirationFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.LifecycleExpirationFilterSensitiveLog = LifecycleExpirationFilterSensitiveLog; | |
var LifecycleRuleAndOperatorFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.LifecycleRuleAndOperatorFilterSensitiveLog = LifecycleRuleAndOperatorFilterSensitiveLog; | |
var LifecycleRuleFilterFilterSensitiveLog = (obj) => { | |
if (obj.Prefix !== void 0) | |
return { Prefix: obj.Prefix }; | |
if (obj.Tag !== void 0) | |
return { Tag: (0, exports.TagFilterSensitiveLog)(obj.Tag) }; | |
if (obj.ObjectSizeGreaterThan !== void 0) | |
return { ObjectSizeGreaterThan: obj.ObjectSizeGreaterThan }; | |
if (obj.ObjectSizeLessThan !== void 0) | |
return { ObjectSizeLessThan: obj.ObjectSizeLessThan }; | |
if (obj.And !== void 0) | |
return { And: (0, exports.LifecycleRuleAndOperatorFilterSensitiveLog)(obj.And) }; | |
if (obj.$unknown !== void 0) | |
return { [obj.$unknown[0]]: "UNKNOWN" }; | |
}; | |
exports.LifecycleRuleFilterFilterSensitiveLog = LifecycleRuleFilterFilterSensitiveLog; | |
var NoncurrentVersionExpirationFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.NoncurrentVersionExpirationFilterSensitiveLog = NoncurrentVersionExpirationFilterSensitiveLog; | |
var NoncurrentVersionTransitionFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.NoncurrentVersionTransitionFilterSensitiveLog = NoncurrentVersionTransitionFilterSensitiveLog; | |
var TransitionFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.TransitionFilterSensitiveLog = TransitionFilterSensitiveLog; | |
var LifecycleRuleFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.Filter && { Filter: (0, exports.LifecycleRuleFilterFilterSensitiveLog)(obj.Filter) } | |
}); | |
exports.LifecycleRuleFilterSensitiveLog = LifecycleRuleFilterSensitiveLog; | |
var GetBucketLifecycleConfigurationOutputFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.Rules && { Rules: obj.Rules.map((item) => (0, exports.LifecycleRuleFilterSensitiveLog)(item)) } | |
}); | |
exports.GetBucketLifecycleConfigurationOutputFilterSensitiveLog = GetBucketLifecycleConfigurationOutputFilterSensitiveLog; | |
var GetBucketLifecycleConfigurationRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketLifecycleConfigurationRequestFilterSensitiveLog = GetBucketLifecycleConfigurationRequestFilterSensitiveLog; | |
var GetBucketLocationOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketLocationOutputFilterSensitiveLog = GetBucketLocationOutputFilterSensitiveLog; | |
var GetBucketLocationRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketLocationRequestFilterSensitiveLog = GetBucketLocationRequestFilterSensitiveLog; | |
var TargetGrantFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.TargetGrantFilterSensitiveLog = TargetGrantFilterSensitiveLog; | |
var LoggingEnabledFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.LoggingEnabledFilterSensitiveLog = LoggingEnabledFilterSensitiveLog; | |
var GetBucketLoggingOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketLoggingOutputFilterSensitiveLog = GetBucketLoggingOutputFilterSensitiveLog; | |
var GetBucketLoggingRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketLoggingRequestFilterSensitiveLog = GetBucketLoggingRequestFilterSensitiveLog; | |
var MetricsAndOperatorFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.MetricsAndOperatorFilterSensitiveLog = MetricsAndOperatorFilterSensitiveLog; | |
var MetricsFilterFilterSensitiveLog = (obj) => { | |
if (obj.Prefix !== void 0) | |
return { Prefix: obj.Prefix }; | |
if (obj.Tag !== void 0) | |
return { Tag: (0, exports.TagFilterSensitiveLog)(obj.Tag) }; | |
if (obj.AccessPointArn !== void 0) | |
return { AccessPointArn: obj.AccessPointArn }; | |
if (obj.And !== void 0) | |
return { And: (0, exports.MetricsAndOperatorFilterSensitiveLog)(obj.And) }; | |
if (obj.$unknown !== void 0) | |
return { [obj.$unknown[0]]: "UNKNOWN" }; | |
}; | |
exports.MetricsFilterFilterSensitiveLog = MetricsFilterFilterSensitiveLog; | |
var MetricsConfigurationFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.Filter && { Filter: (0, exports.MetricsFilterFilterSensitiveLog)(obj.Filter) } | |
}); | |
exports.MetricsConfigurationFilterSensitiveLog = MetricsConfigurationFilterSensitiveLog; | |
var GetBucketMetricsConfigurationOutputFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.MetricsConfiguration && { | |
MetricsConfiguration: (0, exports.MetricsConfigurationFilterSensitiveLog)(obj.MetricsConfiguration) | |
} | |
}); | |
exports.GetBucketMetricsConfigurationOutputFilterSensitiveLog = GetBucketMetricsConfigurationOutputFilterSensitiveLog; | |
var GetBucketMetricsConfigurationRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketMetricsConfigurationRequestFilterSensitiveLog = GetBucketMetricsConfigurationRequestFilterSensitiveLog; | |
var GetBucketNotificationConfigurationRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketNotificationConfigurationRequestFilterSensitiveLog = GetBucketNotificationConfigurationRequestFilterSensitiveLog; | |
var EventBridgeConfigurationFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.EventBridgeConfigurationFilterSensitiveLog = EventBridgeConfigurationFilterSensitiveLog; | |
var FilterRuleFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.FilterRuleFilterSensitiveLog = FilterRuleFilterSensitiveLog; | |
var S3KeyFilterFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.S3KeyFilterFilterSensitiveLog = S3KeyFilterFilterSensitiveLog; | |
var NotificationConfigurationFilterFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.NotificationConfigurationFilterFilterSensitiveLog = NotificationConfigurationFilterFilterSensitiveLog; | |
var LambdaFunctionConfigurationFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.LambdaFunctionConfigurationFilterSensitiveLog = LambdaFunctionConfigurationFilterSensitiveLog; | |
var QueueConfigurationFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.QueueConfigurationFilterSensitiveLog = QueueConfigurationFilterSensitiveLog; | |
var TopicConfigurationFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.TopicConfigurationFilterSensitiveLog = TopicConfigurationFilterSensitiveLog; | |
var NotificationConfigurationFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.NotificationConfigurationFilterSensitiveLog = NotificationConfigurationFilterSensitiveLog; | |
var OwnershipControlsRuleFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.OwnershipControlsRuleFilterSensitiveLog = OwnershipControlsRuleFilterSensitiveLog; | |
var OwnershipControlsFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.OwnershipControlsFilterSensitiveLog = OwnershipControlsFilterSensitiveLog; | |
var GetBucketOwnershipControlsOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketOwnershipControlsOutputFilterSensitiveLog = GetBucketOwnershipControlsOutputFilterSensitiveLog; | |
var GetBucketOwnershipControlsRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketOwnershipControlsRequestFilterSensitiveLog = GetBucketOwnershipControlsRequestFilterSensitiveLog; | |
var GetBucketPolicyOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketPolicyOutputFilterSensitiveLog = GetBucketPolicyOutputFilterSensitiveLog; | |
var GetBucketPolicyRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketPolicyRequestFilterSensitiveLog = GetBucketPolicyRequestFilterSensitiveLog; | |
var PolicyStatusFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.PolicyStatusFilterSensitiveLog = PolicyStatusFilterSensitiveLog; | |
var GetBucketPolicyStatusOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketPolicyStatusOutputFilterSensitiveLog = GetBucketPolicyStatusOutputFilterSensitiveLog; | |
var GetBucketPolicyStatusRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketPolicyStatusRequestFilterSensitiveLog = GetBucketPolicyStatusRequestFilterSensitiveLog; | |
var DeleteMarkerReplicationFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.DeleteMarkerReplicationFilterSensitiveLog = DeleteMarkerReplicationFilterSensitiveLog; | |
var EncryptionConfigurationFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.EncryptionConfigurationFilterSensitiveLog = EncryptionConfigurationFilterSensitiveLog; | |
var ReplicationTimeValueFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ReplicationTimeValueFilterSensitiveLog = ReplicationTimeValueFilterSensitiveLog; | |
var MetricsFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.MetricsFilterSensitiveLog = MetricsFilterSensitiveLog; | |
var ReplicationTimeFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ReplicationTimeFilterSensitiveLog = ReplicationTimeFilterSensitiveLog; | |
var DestinationFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.DestinationFilterSensitiveLog = DestinationFilterSensitiveLog; | |
var ExistingObjectReplicationFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ExistingObjectReplicationFilterSensitiveLog = ExistingObjectReplicationFilterSensitiveLog; | |
var ReplicationRuleAndOperatorFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ReplicationRuleAndOperatorFilterSensitiveLog = ReplicationRuleAndOperatorFilterSensitiveLog; | |
var ReplicationRuleFilterFilterSensitiveLog = (obj) => { | |
if (obj.Prefix !== void 0) | |
return { Prefix: obj.Prefix }; | |
if (obj.Tag !== void 0) | |
return { Tag: (0, exports.TagFilterSensitiveLog)(obj.Tag) }; | |
if (obj.And !== void 0) | |
return { And: (0, exports.ReplicationRuleAndOperatorFilterSensitiveLog)(obj.And) }; | |
if (obj.$unknown !== void 0) | |
return { [obj.$unknown[0]]: "UNKNOWN" }; | |
}; | |
exports.ReplicationRuleFilterFilterSensitiveLog = ReplicationRuleFilterFilterSensitiveLog; | |
var ReplicaModificationsFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ReplicaModificationsFilterSensitiveLog = ReplicaModificationsFilterSensitiveLog; | |
var SseKmsEncryptedObjectsFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.SseKmsEncryptedObjectsFilterSensitiveLog = SseKmsEncryptedObjectsFilterSensitiveLog; | |
var SourceSelectionCriteriaFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.SourceSelectionCriteriaFilterSensitiveLog = SourceSelectionCriteriaFilterSensitiveLog; | |
var ReplicationRuleFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.Filter && { Filter: (0, exports.ReplicationRuleFilterFilterSensitiveLog)(obj.Filter) } | |
}); | |
exports.ReplicationRuleFilterSensitiveLog = ReplicationRuleFilterSensitiveLog; | |
var ReplicationConfigurationFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.Rules && { Rules: obj.Rules.map((item) => (0, exports.ReplicationRuleFilterSensitiveLog)(item)) } | |
}); | |
exports.ReplicationConfigurationFilterSensitiveLog = ReplicationConfigurationFilterSensitiveLog; | |
var GetBucketReplicationOutputFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.ReplicationConfiguration && { | |
ReplicationConfiguration: (0, exports.ReplicationConfigurationFilterSensitiveLog)(obj.ReplicationConfiguration) | |
} | |
}); | |
exports.GetBucketReplicationOutputFilterSensitiveLog = GetBucketReplicationOutputFilterSensitiveLog; | |
var GetBucketReplicationRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketReplicationRequestFilterSensitiveLog = GetBucketReplicationRequestFilterSensitiveLog; | |
var GetBucketRequestPaymentOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketRequestPaymentOutputFilterSensitiveLog = GetBucketRequestPaymentOutputFilterSensitiveLog; | |
var GetBucketRequestPaymentRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketRequestPaymentRequestFilterSensitiveLog = GetBucketRequestPaymentRequestFilterSensitiveLog; | |
var GetBucketTaggingOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketTaggingOutputFilterSensitiveLog = GetBucketTaggingOutputFilterSensitiveLog; | |
var GetBucketTaggingRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketTaggingRequestFilterSensitiveLog = GetBucketTaggingRequestFilterSensitiveLog; | |
var GetBucketVersioningOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketVersioningOutputFilterSensitiveLog = GetBucketVersioningOutputFilterSensitiveLog; | |
var GetBucketVersioningRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketVersioningRequestFilterSensitiveLog = GetBucketVersioningRequestFilterSensitiveLog; | |
var ErrorDocumentFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ErrorDocumentFilterSensitiveLog = ErrorDocumentFilterSensitiveLog; | |
var IndexDocumentFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.IndexDocumentFilterSensitiveLog = IndexDocumentFilterSensitiveLog; | |
var RedirectAllRequestsToFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.RedirectAllRequestsToFilterSensitiveLog = RedirectAllRequestsToFilterSensitiveLog; | |
var ConditionFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ConditionFilterSensitiveLog = ConditionFilterSensitiveLog; | |
var RedirectFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.RedirectFilterSensitiveLog = RedirectFilterSensitiveLog; | |
var RoutingRuleFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.RoutingRuleFilterSensitiveLog = RoutingRuleFilterSensitiveLog; | |
var GetBucketWebsiteOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketWebsiteOutputFilterSensitiveLog = GetBucketWebsiteOutputFilterSensitiveLog; | |
var GetBucketWebsiteRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetBucketWebsiteRequestFilterSensitiveLog = GetBucketWebsiteRequestFilterSensitiveLog; | |
var GetObjectOutputFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.SSEKMSKeyId && { SSEKMSKeyId: smithy_client_1.SENSITIVE_STRING } | |
}); | |
exports.GetObjectOutputFilterSensitiveLog = GetObjectOutputFilterSensitiveLog; | |
var GetObjectRequestFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.SSECustomerKey && { SSECustomerKey: smithy_client_1.SENSITIVE_STRING } | |
}); | |
exports.GetObjectRequestFilterSensitiveLog = GetObjectRequestFilterSensitiveLog; | |
var GetObjectAclOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetObjectAclOutputFilterSensitiveLog = GetObjectAclOutputFilterSensitiveLog; | |
var GetObjectAclRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetObjectAclRequestFilterSensitiveLog = GetObjectAclRequestFilterSensitiveLog; | |
var ChecksumFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ChecksumFilterSensitiveLog = ChecksumFilterSensitiveLog; | |
var ObjectPartFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ObjectPartFilterSensitiveLog = ObjectPartFilterSensitiveLog; | |
var GetObjectAttributesPartsFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetObjectAttributesPartsFilterSensitiveLog = GetObjectAttributesPartsFilterSensitiveLog; | |
var GetObjectAttributesOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetObjectAttributesOutputFilterSensitiveLog = GetObjectAttributesOutputFilterSensitiveLog; | |
var GetObjectAttributesRequestFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.SSECustomerKey && { SSECustomerKey: smithy_client_1.SENSITIVE_STRING } | |
}); | |
exports.GetObjectAttributesRequestFilterSensitiveLog = GetObjectAttributesRequestFilterSensitiveLog; | |
var ObjectLockLegalHoldFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ObjectLockLegalHoldFilterSensitiveLog = ObjectLockLegalHoldFilterSensitiveLog; | |
var GetObjectLegalHoldOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetObjectLegalHoldOutputFilterSensitiveLog = GetObjectLegalHoldOutputFilterSensitiveLog; | |
var GetObjectLegalHoldRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetObjectLegalHoldRequestFilterSensitiveLog = GetObjectLegalHoldRequestFilterSensitiveLog; | |
var DefaultRetentionFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.DefaultRetentionFilterSensitiveLog = DefaultRetentionFilterSensitiveLog; | |
var ObjectLockRuleFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ObjectLockRuleFilterSensitiveLog = ObjectLockRuleFilterSensitiveLog; | |
var ObjectLockConfigurationFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ObjectLockConfigurationFilterSensitiveLog = ObjectLockConfigurationFilterSensitiveLog; | |
var GetObjectLockConfigurationOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetObjectLockConfigurationOutputFilterSensitiveLog = GetObjectLockConfigurationOutputFilterSensitiveLog; | |
var GetObjectLockConfigurationRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetObjectLockConfigurationRequestFilterSensitiveLog = GetObjectLockConfigurationRequestFilterSensitiveLog; | |
var ObjectLockRetentionFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ObjectLockRetentionFilterSensitiveLog = ObjectLockRetentionFilterSensitiveLog; | |
var GetObjectRetentionOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetObjectRetentionOutputFilterSensitiveLog = GetObjectRetentionOutputFilterSensitiveLog; | |
var GetObjectRetentionRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetObjectRetentionRequestFilterSensitiveLog = GetObjectRetentionRequestFilterSensitiveLog; | |
var GetObjectTaggingOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetObjectTaggingOutputFilterSensitiveLog = GetObjectTaggingOutputFilterSensitiveLog; | |
var GetObjectTaggingRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetObjectTaggingRequestFilterSensitiveLog = GetObjectTaggingRequestFilterSensitiveLog; | |
var GetObjectTorrentOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetObjectTorrentOutputFilterSensitiveLog = GetObjectTorrentOutputFilterSensitiveLog; | |
var GetObjectTorrentRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetObjectTorrentRequestFilterSensitiveLog = GetObjectTorrentRequestFilterSensitiveLog; | |
var PublicAccessBlockConfigurationFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.PublicAccessBlockConfigurationFilterSensitiveLog = PublicAccessBlockConfigurationFilterSensitiveLog; | |
var GetPublicAccessBlockOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetPublicAccessBlockOutputFilterSensitiveLog = GetPublicAccessBlockOutputFilterSensitiveLog; | |
var GetPublicAccessBlockRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GetPublicAccessBlockRequestFilterSensitiveLog = GetPublicAccessBlockRequestFilterSensitiveLog; | |
var HeadBucketRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.HeadBucketRequestFilterSensitiveLog = HeadBucketRequestFilterSensitiveLog; | |
var HeadObjectOutputFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.SSEKMSKeyId && { SSEKMSKeyId: smithy_client_1.SENSITIVE_STRING } | |
}); | |
exports.HeadObjectOutputFilterSensitiveLog = HeadObjectOutputFilterSensitiveLog; | |
var HeadObjectRequestFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.SSECustomerKey && { SSECustomerKey: smithy_client_1.SENSITIVE_STRING } | |
}); | |
exports.HeadObjectRequestFilterSensitiveLog = HeadObjectRequestFilterSensitiveLog; | |
var ListBucketAnalyticsConfigurationsOutputFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.AnalyticsConfigurationList && { | |
AnalyticsConfigurationList: obj.AnalyticsConfigurationList.map((item) => (0, exports.AnalyticsConfigurationFilterSensitiveLog)(item)) | |
} | |
}); | |
exports.ListBucketAnalyticsConfigurationsOutputFilterSensitiveLog = ListBucketAnalyticsConfigurationsOutputFilterSensitiveLog; | |
var ListBucketAnalyticsConfigurationsRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ListBucketAnalyticsConfigurationsRequestFilterSensitiveLog = ListBucketAnalyticsConfigurationsRequestFilterSensitiveLog; | |
var ListBucketIntelligentTieringConfigurationsOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ListBucketIntelligentTieringConfigurationsOutputFilterSensitiveLog = ListBucketIntelligentTieringConfigurationsOutputFilterSensitiveLog; | |
var ListBucketIntelligentTieringConfigurationsRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ListBucketIntelligentTieringConfigurationsRequestFilterSensitiveLog = ListBucketIntelligentTieringConfigurationsRequestFilterSensitiveLog; | |
var ListBucketInventoryConfigurationsOutputFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.InventoryConfigurationList && { | |
InventoryConfigurationList: obj.InventoryConfigurationList.map((item) => (0, exports.InventoryConfigurationFilterSensitiveLog)(item)) | |
} | |
}); | |
exports.ListBucketInventoryConfigurationsOutputFilterSensitiveLog = ListBucketInventoryConfigurationsOutputFilterSensitiveLog; | |
var ListBucketInventoryConfigurationsRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ListBucketInventoryConfigurationsRequestFilterSensitiveLog = ListBucketInventoryConfigurationsRequestFilterSensitiveLog; | |
var ListBucketMetricsConfigurationsOutputFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.MetricsConfigurationList && { | |
MetricsConfigurationList: obj.MetricsConfigurationList.map((item) => (0, exports.MetricsConfigurationFilterSensitiveLog)(item)) | |
} | |
}); | |
exports.ListBucketMetricsConfigurationsOutputFilterSensitiveLog = ListBucketMetricsConfigurationsOutputFilterSensitiveLog; | |
var ListBucketMetricsConfigurationsRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ListBucketMetricsConfigurationsRequestFilterSensitiveLog = ListBucketMetricsConfigurationsRequestFilterSensitiveLog; | |
var BucketFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.BucketFilterSensitiveLog = BucketFilterSensitiveLog; | |
var ListBucketsOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ListBucketsOutputFilterSensitiveLog = ListBucketsOutputFilterSensitiveLog; | |
var CommonPrefixFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.CommonPrefixFilterSensitiveLog = CommonPrefixFilterSensitiveLog; | |
var InitiatorFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.InitiatorFilterSensitiveLog = InitiatorFilterSensitiveLog; | |
var MultipartUploadFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.MultipartUploadFilterSensitiveLog = MultipartUploadFilterSensitiveLog; | |
var ListMultipartUploadsOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ListMultipartUploadsOutputFilterSensitiveLog = ListMultipartUploadsOutputFilterSensitiveLog; | |
var ListMultipartUploadsRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ListMultipartUploadsRequestFilterSensitiveLog = ListMultipartUploadsRequestFilterSensitiveLog; | |
var _ObjectFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports._ObjectFilterSensitiveLog = _ObjectFilterSensitiveLog; | |
var ListObjectsOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ListObjectsOutputFilterSensitiveLog = ListObjectsOutputFilterSensitiveLog; | |
var ListObjectsRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ListObjectsRequestFilterSensitiveLog = ListObjectsRequestFilterSensitiveLog; | |
var ListObjectsV2OutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ListObjectsV2OutputFilterSensitiveLog = ListObjectsV2OutputFilterSensitiveLog; | |
var ListObjectsV2RequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ListObjectsV2RequestFilterSensitiveLog = ListObjectsV2RequestFilterSensitiveLog; | |
var DeleteMarkerEntryFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.DeleteMarkerEntryFilterSensitiveLog = DeleteMarkerEntryFilterSensitiveLog; | |
var ObjectVersionFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ObjectVersionFilterSensitiveLog = ObjectVersionFilterSensitiveLog; | |
var ListObjectVersionsOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ListObjectVersionsOutputFilterSensitiveLog = ListObjectVersionsOutputFilterSensitiveLog; | |
var ListObjectVersionsRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ListObjectVersionsRequestFilterSensitiveLog = ListObjectVersionsRequestFilterSensitiveLog; | |
var PartFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.PartFilterSensitiveLog = PartFilterSensitiveLog; | |
var ListPartsOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ListPartsOutputFilterSensitiveLog = ListPartsOutputFilterSensitiveLog; | |
var ListPartsRequestFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.SSECustomerKey && { SSECustomerKey: smithy_client_1.SENSITIVE_STRING } | |
}); | |
exports.ListPartsRequestFilterSensitiveLog = ListPartsRequestFilterSensitiveLog; | |
var PutBucketAccelerateConfigurationRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.PutBucketAccelerateConfigurationRequestFilterSensitiveLog = PutBucketAccelerateConfigurationRequestFilterSensitiveLog; | |
var PutBucketAclRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.PutBucketAclRequestFilterSensitiveLog = PutBucketAclRequestFilterSensitiveLog; | |
var PutBucketAnalyticsConfigurationRequestFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.AnalyticsConfiguration && { | |
AnalyticsConfiguration: (0, exports.AnalyticsConfigurationFilterSensitiveLog)(obj.AnalyticsConfiguration) | |
} | |
}); | |
exports.PutBucketAnalyticsConfigurationRequestFilterSensitiveLog = PutBucketAnalyticsConfigurationRequestFilterSensitiveLog; | |
var CORSConfigurationFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.CORSConfigurationFilterSensitiveLog = CORSConfigurationFilterSensitiveLog; | |
var PutBucketCorsRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.PutBucketCorsRequestFilterSensitiveLog = PutBucketCorsRequestFilterSensitiveLog; | |
var PutBucketEncryptionRequestFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.ServerSideEncryptionConfiguration && { | |
ServerSideEncryptionConfiguration: (0, exports.ServerSideEncryptionConfigurationFilterSensitiveLog)(obj.ServerSideEncryptionConfiguration) | |
} | |
}); | |
exports.PutBucketEncryptionRequestFilterSensitiveLog = PutBucketEncryptionRequestFilterSensitiveLog; | |
var PutBucketIntelligentTieringConfigurationRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.PutBucketIntelligentTieringConfigurationRequestFilterSensitiveLog = PutBucketIntelligentTieringConfigurationRequestFilterSensitiveLog; | |
var PutBucketInventoryConfigurationRequestFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.InventoryConfiguration && { | |
InventoryConfiguration: (0, exports.InventoryConfigurationFilterSensitiveLog)(obj.InventoryConfiguration) | |
} | |
}); | |
exports.PutBucketInventoryConfigurationRequestFilterSensitiveLog = PutBucketInventoryConfigurationRequestFilterSensitiveLog; | |
var BucketLifecycleConfigurationFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.Rules && { Rules: obj.Rules.map((item) => (0, exports.LifecycleRuleFilterSensitiveLog)(item)) } | |
}); | |
exports.BucketLifecycleConfigurationFilterSensitiveLog = BucketLifecycleConfigurationFilterSensitiveLog; | |
var PutBucketLifecycleConfigurationRequestFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.LifecycleConfiguration && { | |
LifecycleConfiguration: (0, exports.BucketLifecycleConfigurationFilterSensitiveLog)(obj.LifecycleConfiguration) | |
} | |
}); | |
exports.PutBucketLifecycleConfigurationRequestFilterSensitiveLog = PutBucketLifecycleConfigurationRequestFilterSensitiveLog; | |
var BucketLoggingStatusFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.BucketLoggingStatusFilterSensitiveLog = BucketLoggingStatusFilterSensitiveLog; | |
var PutBucketLoggingRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.PutBucketLoggingRequestFilterSensitiveLog = PutBucketLoggingRequestFilterSensitiveLog; | |
var PutBucketMetricsConfigurationRequestFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.MetricsConfiguration && { | |
MetricsConfiguration: (0, exports.MetricsConfigurationFilterSensitiveLog)(obj.MetricsConfiguration) | |
} | |
}); | |
exports.PutBucketMetricsConfigurationRequestFilterSensitiveLog = PutBucketMetricsConfigurationRequestFilterSensitiveLog; | |
var PutBucketNotificationConfigurationRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.PutBucketNotificationConfigurationRequestFilterSensitiveLog = PutBucketNotificationConfigurationRequestFilterSensitiveLog; | |
var PutBucketOwnershipControlsRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.PutBucketOwnershipControlsRequestFilterSensitiveLog = PutBucketOwnershipControlsRequestFilterSensitiveLog; | |
var PutBucketPolicyRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.PutBucketPolicyRequestFilterSensitiveLog = PutBucketPolicyRequestFilterSensitiveLog; | |
var PutBucketReplicationRequestFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.ReplicationConfiguration && { | |
ReplicationConfiguration: (0, exports.ReplicationConfigurationFilterSensitiveLog)(obj.ReplicationConfiguration) | |
} | |
}); | |
exports.PutBucketReplicationRequestFilterSensitiveLog = PutBucketReplicationRequestFilterSensitiveLog; | |
var RequestPaymentConfigurationFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.RequestPaymentConfigurationFilterSensitiveLog = RequestPaymentConfigurationFilterSensitiveLog; | |
var PutBucketRequestPaymentRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.PutBucketRequestPaymentRequestFilterSensitiveLog = PutBucketRequestPaymentRequestFilterSensitiveLog; | |
var TaggingFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.TaggingFilterSensitiveLog = TaggingFilterSensitiveLog; | |
var PutBucketTaggingRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.PutBucketTaggingRequestFilterSensitiveLog = PutBucketTaggingRequestFilterSensitiveLog; | |
var VersioningConfigurationFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.VersioningConfigurationFilterSensitiveLog = VersioningConfigurationFilterSensitiveLog; | |
var PutBucketVersioningRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.PutBucketVersioningRequestFilterSensitiveLog = PutBucketVersioningRequestFilterSensitiveLog; | |
var WebsiteConfigurationFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.WebsiteConfigurationFilterSensitiveLog = WebsiteConfigurationFilterSensitiveLog; | |
var PutBucketWebsiteRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.PutBucketWebsiteRequestFilterSensitiveLog = PutBucketWebsiteRequestFilterSensitiveLog; | |
var PutObjectOutputFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.SSEKMSKeyId && { SSEKMSKeyId: smithy_client_1.SENSITIVE_STRING }, | |
...obj.SSEKMSEncryptionContext && { SSEKMSEncryptionContext: smithy_client_1.SENSITIVE_STRING } | |
}); | |
exports.PutObjectOutputFilterSensitiveLog = PutObjectOutputFilterSensitiveLog; | |
var PutObjectRequestFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.SSECustomerKey && { SSECustomerKey: smithy_client_1.SENSITIVE_STRING }, | |
...obj.SSEKMSKeyId && { SSEKMSKeyId: smithy_client_1.SENSITIVE_STRING }, | |
...obj.SSEKMSEncryptionContext && { SSEKMSEncryptionContext: smithy_client_1.SENSITIVE_STRING } | |
}); | |
exports.PutObjectRequestFilterSensitiveLog = PutObjectRequestFilterSensitiveLog; | |
var PutObjectAclOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.PutObjectAclOutputFilterSensitiveLog = PutObjectAclOutputFilterSensitiveLog; | |
var PutObjectAclRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.PutObjectAclRequestFilterSensitiveLog = PutObjectAclRequestFilterSensitiveLog; | |
var PutObjectLegalHoldOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.PutObjectLegalHoldOutputFilterSensitiveLog = PutObjectLegalHoldOutputFilterSensitiveLog; | |
var PutObjectLegalHoldRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.PutObjectLegalHoldRequestFilterSensitiveLog = PutObjectLegalHoldRequestFilterSensitiveLog; | |
var PutObjectLockConfigurationOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.PutObjectLockConfigurationOutputFilterSensitiveLog = PutObjectLockConfigurationOutputFilterSensitiveLog; | |
var PutObjectLockConfigurationRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.PutObjectLockConfigurationRequestFilterSensitiveLog = PutObjectLockConfigurationRequestFilterSensitiveLog; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/FieldPosition.js | |
var require_FieldPosition = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/FieldPosition.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.FieldPosition = void 0; | |
var FieldPosition; | |
(function(FieldPosition2) { | |
FieldPosition2[FieldPosition2["HEADER"] = 0] = "HEADER"; | |
FieldPosition2[FieldPosition2["TRAILER"] = 1] = "TRAILER"; | |
})(FieldPosition = exports.FieldPosition || (exports.FieldPosition = {})); | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/Field.js | |
var require_Field = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/Field.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.Field = void 0; | |
var FieldPosition_1 = require_FieldPosition(); | |
var Field = class { | |
constructor({ name, kind = FieldPosition_1.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; | |
} | |
}; | |
exports.Field = Field; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/Fields.js | |
var require_Fields = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/Fields.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.Fields = void 0; | |
var Fields = class { | |
constructor({ fields = [], encoding = "utf-8" }) { | |
this.entries = {}; | |
fields.forEach(this.setField.bind(this)); | |
this.encoding = encoding; | |
} | |
setField(field) { | |
this.entries[field.name] = field; | |
} | |
getField(name) { | |
return this.entries[name]; | |
} | |
removeField(name) { | |
delete this.entries[name]; | |
} | |
getByType(kind) { | |
return Object.values(this.entries).filter((field) => field.kind === kind); | |
} | |
}; | |
exports.Fields = Fields; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/httpHandler.js | |
var require_httpHandler = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/httpHandler.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/httpRequest.js | |
var require_httpRequest = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/httpRequest.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.HttpRequest = void 0; | |
var HttpRequest = class { | |
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 : "/"; | |
} | |
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() { | |
const cloned = new HttpRequest({ | |
...this, | |
headers: { ...this.headers } | |
}); | |
if (cloned.query) | |
cloned.query = cloneQuery(cloned.query); | |
return cloned; | |
} | |
}; | |
exports.HttpRequest = HttpRequest; | |
function cloneQuery(query) { | |
return Object.keys(query).reduce((carry, paramName) => { | |
const param = query[paramName]; | |
return { | |
...carry, | |
[paramName]: Array.isArray(param) ? [...param] : param | |
}; | |
}, {}); | |
} | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/httpResponse.js | |
var require_httpResponse = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/httpResponse.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.HttpResponse = void 0; | |
var HttpResponse = class { | |
constructor(options) { | |
this.statusCode = options.statusCode; | |
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"; | |
} | |
}; | |
exports.HttpResponse = HttpResponse; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/isValidHostname.js | |
var require_isValidHostname = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/isValidHostname.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.isValidHostname = void 0; | |
function isValidHostname(hostname) { | |
const hostPattern = /^[a-z0-9][a-z0-9\.\-]*[a-z0-9]$/; | |
return hostPattern.test(hostname); | |
} | |
exports.isValidHostname = isValidHostname; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/index.js | |
var require_dist_cjs8 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+protocol-http@3.272.0/node_modules/@aws-sdk/protocol-http/dist-cjs/index.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); | |
tslib_1.__exportStar(require_Field(), exports); | |
tslib_1.__exportStar(require_FieldPosition(), exports); | |
tslib_1.__exportStar(require_Fields(), exports); | |
tslib_1.__exportStar(require_httpHandler(), exports); | |
tslib_1.__exportStar(require_httpRequest(), exports); | |
tslib_1.__exportStar(require_httpResponse(), exports); | |
tslib_1.__exportStar(require_isValidHostname(), exports); | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+xml-builder@3.201.0/node_modules/@aws-sdk/xml-builder/dist-cjs/escape-attribute.js | |
var require_escape_attribute = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+xml-builder@3.201.0/node_modules/@aws-sdk/xml-builder/dist-cjs/escape-attribute.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.escapeAttribute = void 0; | |
function escapeAttribute(value) { | |
return value.replace(/&/g, "&").replace(/</g, "<").replace(/>/g, ">").replace(/"/g, """); | |
} | |
exports.escapeAttribute = escapeAttribute; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+xml-builder@3.201.0/node_modules/@aws-sdk/xml-builder/dist-cjs/escape-element.js | |
var require_escape_element = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+xml-builder@3.201.0/node_modules/@aws-sdk/xml-builder/dist-cjs/escape-element.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.escapeElement = void 0; | |
function escapeElement(value) { | |
return value.replace(/&/g, "&").replace(/"/g, """).replace(/'/g, "'").replace(/</g, "<").replace(/>/g, ">").replace(/\r/g, "
").replace(/\n/g, "
").replace(/\u0085/g, "…").replace(/\u2028/, "
"); | |
} | |
exports.escapeElement = escapeElement; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+xml-builder@3.201.0/node_modules/@aws-sdk/xml-builder/dist-cjs/XmlText.js | |
var require_XmlText = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+xml-builder@3.201.0/node_modules/@aws-sdk/xml-builder/dist-cjs/XmlText.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.XmlText = void 0; | |
var escape_element_1 = require_escape_element(); | |
var XmlText = class { | |
constructor(value) { | |
this.value = value; | |
} | |
toString() { | |
return (0, escape_element_1.escapeElement)("" + this.value); | |
} | |
}; | |
exports.XmlText = XmlText; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+xml-builder@3.201.0/node_modules/@aws-sdk/xml-builder/dist-cjs/XmlNode.js | |
var require_XmlNode = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+xml-builder@3.201.0/node_modules/@aws-sdk/xml-builder/dist-cjs/XmlNode.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.XmlNode = void 0; | |
var escape_attribute_1 = require_escape_attribute(); | |
var XmlText_1 = require_XmlText(); | |
var XmlNode = class { | |
constructor(name, children = []) { | |
this.name = name; | |
this.children = children; | |
this.attributes = {}; | |
} | |
static of(name, childText, withName) { | |
const node = new XmlNode(name); | |
if (childText !== void 0) { | |
node.addChildNode(new XmlText_1.XmlText(childText)); | |
} | |
if (withName !== void 0) { | |
node.withName(withName); | |
} | |
return node; | |
} | |
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; | |
} | |
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 (typeof attribute !== "undefined" && attribute !== null) { | |
xmlText += ` ${attributeName}="${(0, escape_attribute_1.escapeAttribute)("" + attribute)}"`; | |
} | |
} | |
return xmlText += !hasChildren ? "/>" : `>${this.children.map((c) => c.toString()).join("")}</${this.name}>`; | |
} | |
}; | |
exports.XmlNode = XmlNode; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+xml-builder@3.201.0/node_modules/@aws-sdk/xml-builder/dist-cjs/index.js | |
var require_dist_cjs9 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+xml-builder@3.201.0/node_modules/@aws-sdk/xml-builder/dist-cjs/index.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); | |
tslib_1.__exportStar(require_XmlNode(), exports); | |
tslib_1.__exportStar(require_XmlText(), exports); | |
} | |
}); | |
// ../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/util.js | |
var require_util = __commonJS({ | |
"../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/util.js"(exports) { | |
"use strict"; | |
var nameStartChar = ":A-Za-z_\\u00C0-\\u00D6\\u00D8-\\u00F6\\u00F8-\\u02FF\\u0370-\\u037D\\u037F-\\u1FFF\\u200C-\\u200D\\u2070-\\u218F\\u2C00-\\u2FEF\\u3001-\\uD7FF\\uF900-\\uFDCF\\uFDF0-\\uFFFD"; | |
var nameChar = nameStartChar + "\\-.\\d\\u00B7\\u0300-\\u036F\\u203F-\\u2040"; | |
var nameRegexp = "[" + nameStartChar + "][" + nameChar + "]*"; | |
var regexName = new RegExp("^" + nameRegexp + "$"); | |
var getAllMatches = function(string, regex) { | |
const matches = []; | |
let match = regex.exec(string); | |
while (match) { | |
const allmatches = []; | |
allmatches.startIndex = regex.lastIndex - match[0].length; | |
const len = match.length; | |
for (let index = 0; index < len; index++) { | |
allmatches.push(match[index]); | |
} | |
matches.push(allmatches); | |
match = regex.exec(string); | |
} | |
return matches; | |
}; | |
var isName = function(string) { | |
const match = regexName.exec(string); | |
return !(match === null || typeof match === "undefined"); | |
}; | |
exports.isExist = function(v) { | |
return typeof v !== "undefined"; | |
}; | |
exports.isEmptyObject = function(obj) { | |
return Object.keys(obj).length === 0; | |
}; | |
exports.merge = function(target, a, arrayMode) { | |
if (a) { | |
const keys = Object.keys(a); | |
const len = keys.length; | |
for (let i = 0; i < len; i++) { | |
if (arrayMode === "strict") { | |
target[keys[i]] = [a[keys[i]]]; | |
} else { | |
target[keys[i]] = a[keys[i]]; | |
} | |
} | |
} | |
}; | |
exports.getValue = function(v) { | |
if (exports.isExist(v)) { | |
return v; | |
} else { | |
return ""; | |
} | |
}; | |
exports.isName = isName; | |
exports.getAllMatches = getAllMatches; | |
exports.nameRegexp = nameRegexp; | |
} | |
}); | |
// ../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/validator.js | |
var require_validator = __commonJS({ | |
"../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/validator.js"(exports) { | |
"use strict"; | |
var util3 = require_util(); | |
var defaultOptions = { | |
allowBooleanAttributes: false, | |
//A tag can have attributes without any value | |
unpairedTags: [] | |
}; | |
exports.validate = function(xmlData, options) { | |
options = Object.assign({}, defaultOptions, options); | |
const tags = []; | |
let tagFound = false; | |
let reachedRoot = false; | |
if (xmlData[0] === "\uFEFF") { | |
xmlData = xmlData.substr(1); | |
} | |
for (let i = 0; i < xmlData.length; i++) { | |
if (xmlData[i] === "<" && xmlData[i + 1] === "?") { | |
i += 2; | |
i = readPI(xmlData, i); | |
if (i.err) | |
return i; | |
} else if (xmlData[i] === "<") { | |
let tagStartPos = i; | |
i++; | |
if (xmlData[i] === "!") { | |
i = readCommentAndCDATA(xmlData, i); | |
continue; | |
} else { | |
let closingTag = false; | |
if (xmlData[i] === "/") { | |
closingTag = true; | |
i++; | |
} | |
let tagName = ""; | |
for (; i < xmlData.length && xmlData[i] !== ">" && xmlData[i] !== " " && xmlData[i] !== " " && xmlData[i] !== "\n" && xmlData[i] !== "\r"; i++) { | |
tagName += xmlData[i]; | |
} | |
tagName = tagName.trim(); | |
if (tagName[tagName.length - 1] === "/") { | |
tagName = tagName.substring(0, tagName.length - 1); | |
i--; | |
} | |
if (!validateTagName(tagName)) { | |
let msg; | |
if (tagName.trim().length === 0) { | |
msg = "Invalid space after '<'."; | |
} else { | |
msg = "Tag '" + tagName + "' is an invalid name."; | |
} | |
return getErrorObject("InvalidTag", msg, getLineNumberForPosition(xmlData, i)); | |
} | |
const result = readAttributeStr(xmlData, i); | |
if (result === false) { | |
return getErrorObject("InvalidAttr", "Attributes for '" + tagName + "' have open quote.", getLineNumberForPosition(xmlData, i)); | |
} | |
let attrStr = result.value; | |
i = result.index; | |
if (attrStr[attrStr.length - 1] === "/") { | |
const attrStrStart = i - attrStr.length; | |
attrStr = attrStr.substring(0, attrStr.length - 1); | |
const isValid = validateAttributeString(attrStr, options); | |
if (isValid === true) { | |
tagFound = true; | |
} else { | |
return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, attrStrStart + isValid.err.line)); | |
} | |
} else if (closingTag) { | |
if (!result.tagClosed) { | |
return getErrorObject("InvalidTag", "Closing tag '" + tagName + "' doesn't have proper closing.", getLineNumberForPosition(xmlData, i)); | |
} else if (attrStr.trim().length > 0) { | |
return getErrorObject("InvalidTag", "Closing tag '" + tagName + "' can't have attributes or invalid starting.", getLineNumberForPosition(xmlData, tagStartPos)); | |
} else { | |
const otg = tags.pop(); | |
if (tagName !== otg.tagName) { | |
let openPos = getLineNumberForPosition(xmlData, otg.tagStartPos); | |
return getErrorObject( | |
"InvalidTag", | |
"Expected closing tag '" + otg.tagName + "' (opened in line " + openPos.line + ", col " + openPos.col + ") instead of closing tag '" + tagName + "'.", | |
getLineNumberForPosition(xmlData, tagStartPos) | |
); | |
} | |
if (tags.length == 0) { | |
reachedRoot = true; | |
} | |
} | |
} else { | |
const isValid = validateAttributeString(attrStr, options); | |
if (isValid !== true) { | |
return getErrorObject(isValid.err.code, isValid.err.msg, getLineNumberForPosition(xmlData, i - attrStr.length + isValid.err.line)); | |
} | |
if (reachedRoot === true) { | |
return getErrorObject("InvalidXml", "Multiple possible root nodes found.", getLineNumberForPosition(xmlData, i)); | |
} else if (options.unpairedTags.indexOf(tagName) !== -1) { | |
} else { | |
tags.push({ tagName, tagStartPos }); | |
} | |
tagFound = true; | |
} | |
for (i++; i < xmlData.length; i++) { | |
if (xmlData[i] === "<") { | |
if (xmlData[i + 1] === "!") { | |
i++; | |
i = readCommentAndCDATA(xmlData, i); | |
continue; | |
} else if (xmlData[i + 1] === "?") { | |
i = readPI(xmlData, ++i); | |
if (i.err) | |
return i; | |
} else { | |
break; | |
} | |
} else if (xmlData[i] === "&") { | |
const afterAmp = validateAmpersand(xmlData, i); | |
if (afterAmp == -1) | |
return getErrorObject("InvalidChar", "char '&' is not expected.", getLineNumberForPosition(xmlData, i)); | |
i = afterAmp; | |
} else { | |
if (reachedRoot === true && !isWhiteSpace(xmlData[i])) { | |
return getErrorObject("InvalidXml", "Extra text at the end", getLineNumberForPosition(xmlData, i)); | |
} | |
} | |
} | |
if (xmlData[i] === "<") { | |
i--; | |
} | |
} | |
} else { | |
if (isWhiteSpace(xmlData[i])) { | |
continue; | |
} | |
return getErrorObject("InvalidChar", "char '" + xmlData[i] + "' is not expected.", getLineNumberForPosition(xmlData, i)); | |
} | |
} | |
if (!tagFound) { | |
return getErrorObject("InvalidXml", "Start tag expected.", 1); | |
} else if (tags.length == 1) { | |
return getErrorObject("InvalidTag", "Unclosed tag '" + tags[0].tagName + "'.", getLineNumberForPosition(xmlData, tags[0].tagStartPos)); | |
} else if (tags.length > 0) { | |
return getErrorObject("InvalidXml", "Invalid '" + JSON.stringify(tags.map((t) => t.tagName), null, 4).replace(/\r?\n/g, "") + "' found.", { line: 1, col: 1 }); | |
} | |
return true; | |
}; | |
function isWhiteSpace(char) { | |
return char === " " || char === " " || char === "\n" || char === "\r"; | |
} | |
function readPI(xmlData, i) { | |
const start = i; | |
for (; i < xmlData.length; i++) { | |
if (xmlData[i] == "?" || xmlData[i] == " ") { | |
const tagname = xmlData.substr(start, i - start); | |
if (i > 5 && tagname === "xml") { | |
return getErrorObject("InvalidXml", "XML declaration allowed only at the start of the document.", getLineNumberForPosition(xmlData, i)); | |
} else if (xmlData[i] == "?" && xmlData[i + 1] == ">") { | |
i++; | |
break; | |
} else { | |
continue; | |
} | |
} | |
} | |
return i; | |
} | |
function readCommentAndCDATA(xmlData, i) { | |
if (xmlData.length > i + 5 && xmlData[i + 1] === "-" && xmlData[i + 2] === "-") { | |
for (i += 3; i < xmlData.length; i++) { | |
if (xmlData[i] === "-" && xmlData[i + 1] === "-" && xmlData[i + 2] === ">") { | |
i += 2; | |
break; | |
} | |
} | |
} else if (xmlData.length > i + 8 && xmlData[i + 1] === "D" && xmlData[i + 2] === "O" && xmlData[i + 3] === "C" && xmlData[i + 4] === "T" && xmlData[i + 5] === "Y" && xmlData[i + 6] === "P" && xmlData[i + 7] === "E") { | |
let angleBracketsCount = 1; | |
for (i += 8; i < xmlData.length; i++) { | |
if (xmlData[i] === "<") { | |
angleBracketsCount++; | |
} else if (xmlData[i] === ">") { | |
angleBracketsCount--; | |
if (angleBracketsCount === 0) { | |
break; | |
} | |
} | |
} | |
} else if (xmlData.length > i + 9 && xmlData[i + 1] === "[" && xmlData[i + 2] === "C" && xmlData[i + 3] === "D" && xmlData[i + 4] === "A" && xmlData[i + 5] === "T" && xmlData[i + 6] === "A" && xmlData[i + 7] === "[") { | |
for (i += 8; i < xmlData.length; i++) { | |
if (xmlData[i] === "]" && xmlData[i + 1] === "]" && xmlData[i + 2] === ">") { | |
i += 2; | |
break; | |
} | |
} | |
} | |
return i; | |
} | |
var doubleQuote = '"'; | |
var singleQuote = "'"; | |
function readAttributeStr(xmlData, i) { | |
let attrStr = ""; | |
let startChar = ""; | |
let tagClosed = false; | |
for (; i < xmlData.length; i++) { | |
if (xmlData[i] === doubleQuote || xmlData[i] === singleQuote) { | |
if (startChar === "") { | |
startChar = xmlData[i]; | |
} else if (startChar !== xmlData[i]) { | |
} else { | |
startChar = ""; | |
} | |
} else if (xmlData[i] === ">") { | |
if (startChar === "") { | |
tagClosed = true; | |
break; | |
} | |
} | |
attrStr += xmlData[i]; | |
} | |
if (startChar !== "") { | |
return false; | |
} | |
return { | |
value: attrStr, | |
index: i, | |
tagClosed | |
}; | |
} | |
var validAttrStrRegxp = new RegExp(`(\\s*)([^\\s=]+)(\\s*=)?(\\s*(['"])(([\\s\\S])*?)\\5)?`, "g"); | |
function validateAttributeString(attrStr, options) { | |
const matches = util3.getAllMatches(attrStr, validAttrStrRegxp); | |
const attrNames = {}; | |
for (let i = 0; i < matches.length; i++) { | |
if (matches[i][1].length === 0) { | |
return getErrorObject("InvalidAttr", "Attribute '" + matches[i][2] + "' has no space in starting.", getPositionFromMatch(matches[i])); | |
} else if (matches[i][3] !== void 0 && matches[i][4] === void 0) { | |
return getErrorObject("InvalidAttr", "Attribute '" + matches[i][2] + "' is without value.", getPositionFromMatch(matches[i])); | |
} else if (matches[i][3] === void 0 && !options.allowBooleanAttributes) { | |
return getErrorObject("InvalidAttr", "boolean attribute '" + matches[i][2] + "' is not allowed.", getPositionFromMatch(matches[i])); | |
} | |
const attrName = matches[i][2]; | |
if (!validateAttrName(attrName)) { | |
return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is an invalid name.", getPositionFromMatch(matches[i])); | |
} | |
if (!attrNames.hasOwnProperty(attrName)) { | |
attrNames[attrName] = 1; | |
} else { | |
return getErrorObject("InvalidAttr", "Attribute '" + attrName + "' is repeated.", getPositionFromMatch(matches[i])); | |
} | |
} | |
return true; | |
} | |
function validateNumberAmpersand(xmlData, i) { | |
let re = /\d/; | |
if (xmlData[i] === "x") { | |
i++; | |
re = /[\da-fA-F]/; | |
} | |
for (; i < xmlData.length; i++) { | |
if (xmlData[i] === ";") | |
return i; | |
if (!xmlData[i].match(re)) | |
break; | |
} | |
return -1; | |
} | |
function validateAmpersand(xmlData, i) { | |
i++; | |
if (xmlData[i] === ";") | |
return -1; | |
if (xmlData[i] === "#") { | |
i++; | |
return validateNumberAmpersand(xmlData, i); | |
} | |
let count = 0; | |
for (; i < xmlData.length; i++, count++) { | |
if (xmlData[i].match(/\w/) && count < 20) | |
continue; | |
if (xmlData[i] === ";") | |
break; | |
return -1; | |
} | |
return i; | |
} | |
function getErrorObject(code, message, lineNumber) { | |
return { | |
err: { | |
code, | |
msg: message, | |
line: lineNumber.line || lineNumber, | |
col: lineNumber.col | |
} | |
}; | |
} | |
function validateAttrName(attrName) { | |
return util3.isName(attrName); | |
} | |
function validateTagName(tagname) { | |
return util3.isName(tagname); | |
} | |
function getLineNumberForPosition(xmlData, index) { | |
const lines = xmlData.substring(0, index).split(/\r?\n/); | |
return { | |
line: lines.length, | |
// column number is last line's length + 1, because column numbering starts at 1: | |
col: lines[lines.length - 1].length + 1 | |
}; | |
} | |
function getPositionFromMatch(match) { | |
return match.startIndex + match[1].length; | |
} | |
} | |
}); | |
// ../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js | |
var require_OptionsBuilder = __commonJS({ | |
"../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlparser/OptionsBuilder.js"(exports) { | |
var defaultOptions = { | |
preserveOrder: false, | |
attributeNamePrefix: "@_", | |
attributesGroupName: false, | |
textNodeName: "#text", | |
ignoreAttributes: true, | |
removeNSPrefix: false, | |
// remove NS from tag name or attribute name if true | |
allowBooleanAttributes: false, | |
//a tag can have attributes without any value | |
//ignoreRootElement : false, | |
parseTagValue: true, | |
parseAttributeValue: false, | |
trimValues: true, | |
//Trim string values of tag and attributes | |
cdataPropName: false, | |
numberParseOptions: { | |
hex: true, | |
leadingZeros: true | |
}, | |
tagValueProcessor: function(tagName, val) { | |
return val; | |
}, | |
attributeValueProcessor: function(attrName, val) { | |
return val; | |
}, | |
stopNodes: [], | |
//nested tags will not be parsed even for errors | |
alwaysCreateTextNode: false, | |
isArray: () => false, | |
commentPropName: false, | |
unpairedTags: [], | |
processEntities: true, | |
htmlEntities: false, | |
ignoreDeclaration: false, | |
ignorePiTags: false, | |
transformTagName: false | |
}; | |
var buildOptions = function(options) { | |
return Object.assign({}, defaultOptions, options); | |
}; | |
exports.buildOptions = buildOptions; | |
exports.defaultOptions = defaultOptions; | |
} | |
}); | |
// ../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlparser/xmlNode.js | |
var require_xmlNode = __commonJS({ | |
"../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlparser/xmlNode.js"(exports, module2) { | |
"use strict"; | |
var XmlNode = class { | |
constructor(tagname) { | |
this.tagname = tagname; | |
this.child = []; | |
this[":@"] = {}; | |
} | |
add(key, val) { | |
this.child.push({ [key]: val }); | |
} | |
addChild(node) { | |
if (node[":@"] && Object.keys(node[":@"]).length > 0) { | |
this.child.push({ [node.tagname]: node.child, [":@"]: node[":@"] }); | |
} else { | |
this.child.push({ [node.tagname]: node.child }); | |
} | |
} | |
}; | |
module2.exports = XmlNode; | |
} | |
}); | |
// ../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js | |
var require_DocTypeReader = __commonJS({ | |
"../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlparser/DocTypeReader.js"(exports, module2) { | |
function readDocType(xmlData, i) { | |
const entities = {}; | |
if (xmlData[i + 3] === "O" && xmlData[i + 4] === "C" && xmlData[i + 5] === "T" && xmlData[i + 6] === "Y" && xmlData[i + 7] === "P" && xmlData[i + 8] === "E") { | |
i = i + 9; | |
let angleBracketsCount = 1; | |
let hasBody = false, entity = false, comment = false; | |
let exp = ""; | |
for (; i < xmlData.length; i++) { | |
if (xmlData[i] === "<") { | |
if (hasBody && xmlData[i + 1] === "!" && xmlData[i + 2] === "E" && xmlData[i + 3] === "N" && xmlData[i + 4] === "T" && xmlData[i + 5] === "I" && xmlData[i + 6] === "T" && xmlData[i + 7] === "Y") { | |
i += 7; | |
entity = true; | |
} else if (hasBody && xmlData[i + 1] === "!" && xmlData[i + 2] === "E" && xmlData[i + 3] === "L" && xmlData[i + 4] === "E" && xmlData[i + 5] === "M" && xmlData[i + 6] === "E" && xmlData[i + 7] === "N" && xmlData[i + 8] === "T") { | |
i += 8; | |
} else if (hasBody && xmlData[i + 1] === "!" && xmlData[i + 2] === "A" && xmlData[i + 3] === "T" && xmlData[i + 4] === "T" && xmlData[i + 5] === "L" && xmlData[i + 6] === "I" && xmlData[i + 7] === "S" && xmlData[i + 8] === "T") { | |
i += 8; | |
} else if (hasBody && xmlData[i + 1] === "!" && xmlData[i + 2] === "N" && xmlData[i + 3] === "O" && xmlData[i + 4] === "T" && xmlData[i + 5] === "A" && xmlData[i + 6] === "T" && xmlData[i + 7] === "I" && xmlData[i + 8] === "O" && xmlData[i + 9] === "N") { | |
i += 9; | |
} else if ( | |
//comment | |
xmlData[i + 1] === "!" && xmlData[i + 2] === "-" && xmlData[i + 3] === "-" | |
) { | |
comment = true; | |
} else { | |
throw new Error("Invalid DOCTYPE"); | |
} | |
angleBracketsCount++; | |
exp = ""; | |
} else if (xmlData[i] === ">") { | |
if (comment) { | |
if (xmlData[i - 1] === "-" && xmlData[i - 2] === "-") { | |
comment = false; | |
} else { | |
throw new Error(`Invalid XML comment in DOCTYPE`); | |
} | |
} else if (entity) { | |
parseEntityExp(exp, entities); | |
entity = false; | |
} | |
angleBracketsCount--; | |
if (angleBracketsCount === 0) { | |
break; | |
} | |
} else if (xmlData[i] === "[") { | |
hasBody = true; | |
} else { | |
exp += xmlData[i]; | |
} | |
} | |
if (angleBracketsCount !== 0) { | |
throw new Error(`Unclosed DOCTYPE`); | |
} | |
} else { | |
throw new Error(`Invalid Tag instead of DOCTYPE`); | |
} | |
return { entities, i }; | |
} | |
var entityRegex = RegExp(`^\\s([a-zA-z0-0]+)[ ](['"])([^&]+)\\2`); | |
function parseEntityExp(exp, entities) { | |
const match = entityRegex.exec(exp); | |
if (match) { | |
entities[match[1]] = { | |
regx: RegExp(`&${match[1]};`, "g"), | |
val: match[3] | |
}; | |
} | |
} | |
module2.exports = readDocType; | |
} | |
}); | |
// ../../node_modules/.pnpm/strnum@1.0.5/node_modules/strnum/strnum.js | |
var require_strnum = __commonJS({ | |
"../../node_modules/.pnpm/strnum@1.0.5/node_modules/strnum/strnum.js"(exports, module2) { | |
var hexRegex = /^[-+]?0x[a-fA-F0-9]+$/; | |
var numRegex = /^([\-\+])?(0*)(\.[0-9]+([eE]\-?[0-9]+)?|[0-9]+(\.[0-9]+([eE]\-?[0-9]+)?)?)$/; | |
if (!Number.parseInt && window.parseInt) { | |
Number.parseInt = window.parseInt; | |
} | |
if (!Number.parseFloat && window.parseFloat) { | |
Number.parseFloat = window.parseFloat; | |
} | |
var consider = { | |
hex: true, | |
leadingZeros: true, | |
decimalPoint: ".", | |
eNotation: true | |
//skipLike: /regex/ | |
}; | |
function toNumber(str, options = {}) { | |
options = Object.assign({}, consider, options); | |
if (!str || typeof str !== "string") | |
return str; | |
let trimmedStr = str.trim(); | |
if (options.skipLike !== void 0 && options.skipLike.test(trimmedStr)) | |
return str; | |
else if (options.hex && hexRegex.test(trimmedStr)) { | |
return Number.parseInt(trimmedStr, 16); | |
} else { | |
const match = numRegex.exec(trimmedStr); | |
if (match) { | |
const sign = match[1]; | |
const leadingZeros = match[2]; | |
let numTrimmedByZeros = trimZeros(match[3]); | |
const eNotation = match[4] || match[6]; | |
if (!options.leadingZeros && leadingZeros.length > 0 && sign && trimmedStr[2] !== ".") | |
return str; | |
else if (!options.leadingZeros && leadingZeros.length > 0 && !sign && trimmedStr[1] !== ".") | |
return str; | |
else { | |
const num = Number(trimmedStr); | |
const numStr = "" + num; | |
if (numStr.search(/[eE]/) !== -1) { | |
if (options.eNotation) | |
return num; | |
else | |
return str; | |
} else if (eNotation) { | |
if (options.eNotation) | |
return num; | |
else | |
return str; | |
} else if (trimmedStr.indexOf(".") !== -1) { | |
if (numStr === "0" && numTrimmedByZeros === "") | |
return num; | |
else if (numStr === numTrimmedByZeros) | |
return num; | |
else if (sign && numStr === "-" + numTrimmedByZeros) | |
return num; | |
else | |
return str; | |
} | |
if (leadingZeros) { | |
if (numTrimmedByZeros === numStr) | |
return num; | |
else if (sign + numTrimmedByZeros === numStr) | |
return num; | |
else | |
return str; | |
} | |
if (trimmedStr === numStr) | |
return num; | |
else if (trimmedStr === sign + numStr) | |
return num; | |
return str; | |
} | |
} else { | |
return str; | |
} | |
} | |
} | |
function trimZeros(numStr) { | |
if (numStr && numStr.indexOf(".") !== -1) { | |
numStr = numStr.replace(/0+$/, ""); | |
if (numStr === ".") | |
numStr = "0"; | |
else if (numStr[0] === ".") | |
numStr = "0" + numStr; | |
else if (numStr[numStr.length - 1] === ".") | |
numStr = numStr.substr(0, numStr.length - 1); | |
return numStr; | |
} | |
return numStr; | |
} | |
module2.exports = toNumber; | |
} | |
}); | |
// ../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlparser/OrderedObjParser.js | |
var require_OrderedObjParser = __commonJS({ | |
"../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlparser/OrderedObjParser.js"(exports, module2) { | |
"use strict"; | |
var util3 = require_util(); | |
var xmlNode = require_xmlNode(); | |
var readDocType = require_DocTypeReader(); | |
var toNumber = require_strnum(); | |
var regx = "<((!\\[CDATA\\[([\\s\\S]*?)(]]>))|((NAME:)?(NAME))([^>]*)>|((\\/)(NAME)\\s*>))([^<]*)".replace(/NAME/g, util3.nameRegexp); | |
var OrderedObjParser = class { | |
constructor(options) { | |
this.options = options; | |
this.currentNode = null; | |
this.tagsNodeStack = []; | |
this.docTypeEntities = {}; | |
this.lastEntities = { | |
"apos": { regex: /&(apos|#39|#x27);/g, val: "'" }, | |
"gt": { regex: /&(gt|#62|#x3E);/g, val: ">" }, | |
"lt": { regex: /&(lt|#60|#x3C);/g, val: "<" }, | |
"quot": { regex: /&(quot|#34|#x22);/g, val: '"' } | |
}; | |
this.ampEntity = { regex: /&(amp|#38|#x26);/g, val: "&" }; | |
this.htmlEntities = { | |
"space": { regex: /&(nbsp|#160);/g, val: " " }, | |
// "lt" : { regex: /&(lt|#60);/g, val: "<" }, | |
// "gt" : { regex: /&(gt|#62);/g, val: ">" }, | |
// "amp" : { regex: /&(amp|#38);/g, val: "&" }, | |
// "quot" : { regex: /&(quot|#34);/g, val: "\"" }, | |
// "apos" : { regex: /&(apos|#39);/g, val: "'" }, | |
"cent": { regex: /&(cent|#162);/g, val: "\xA2" }, | |
"pound": { regex: /&(pound|#163);/g, val: "\xA3" }, | |
"yen": { regex: /&(yen|#165);/g, val: "\xA5" }, | |
"euro": { regex: /&(euro|#8364);/g, val: "\u20AC" }, | |
"copyright": { regex: /&(copy|#169);/g, val: "\xA9" }, | |
"reg": { regex: /&(reg|#174);/g, val: "\xAE" }, | |
"inr": { regex: /&(inr|#8377);/g, val: "\u20B9" } | |
}; | |
this.addExternalEntities = addExternalEntities; | |
this.parseXml = parseXml; | |
this.parseTextData = parseTextData; | |
this.resolveNameSpace = resolveNameSpace; | |
this.buildAttributesMap = buildAttributesMap; | |
this.isItStopNode = isItStopNode; | |
this.replaceEntitiesValue = replaceEntitiesValue; | |
this.readStopNodeData = readStopNodeData; | |
this.saveTextToParentTag = saveTextToParentTag; | |
} | |
}; | |
function addExternalEntities(externalEntities) { | |
const entKeys = Object.keys(externalEntities); | |
for (let i = 0; i < entKeys.length; i++) { | |
const ent = entKeys[i]; | |
this.lastEntities[ent] = { | |
regex: new RegExp("&" + ent + ";", "g"), | |
val: externalEntities[ent] | |
}; | |
} | |
} | |
function parseTextData(val, tagName, jPath, dontTrim, hasAttributes, isLeafNode, escapeEntities) { | |
if (val !== void 0) { | |
if (this.options.trimValues && !dontTrim) { | |
val = val.trim(); | |
} | |
if (val.length > 0) { | |
if (!escapeEntities) | |
val = this.replaceEntitiesValue(val); | |
const newval = this.options.tagValueProcessor(tagName, val, jPath, hasAttributes, isLeafNode); | |
if (newval === null || newval === void 0) { | |
return val; | |
} else if (typeof newval !== typeof val || newval !== val) { | |
return newval; | |
} else if (this.options.trimValues) { | |
return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions); | |
} else { | |
const trimmedVal = val.trim(); | |
if (trimmedVal === val) { | |
return parseValue(val, this.options.parseTagValue, this.options.numberParseOptions); | |
} else { | |
return val; | |
} | |
} | |
} | |
} | |
} | |
function resolveNameSpace(tagname) { | |
if (this.options.removeNSPrefix) { | |
const tags = tagname.split(":"); | |
const prefix = tagname.charAt(0) === "/" ? "/" : ""; | |
if (tags[0] === "xmlns") { | |
return ""; | |
} | |
if (tags.length === 2) { | |
tagname = prefix + tags[1]; | |
} | |
} | |
return tagname; | |
} | |
var attrsRegx = new RegExp(`([^\\s=]+)\\s*(=\\s*(['"])([\\s\\S]*?)\\3)?`, "gm"); | |
function buildAttributesMap(attrStr, jPath) { | |
if (!this.options.ignoreAttributes && typeof attrStr === "string") { | |
const matches = util3.getAllMatches(attrStr, attrsRegx); | |
const len = matches.length; | |
const attrs = {}; | |
for (let i = 0; i < len; i++) { | |
const attrName = this.resolveNameSpace(matches[i][1]); | |
let oldVal = matches[i][4]; | |
const aName = this.options.attributeNamePrefix + attrName; | |
if (attrName.length) { | |
if (oldVal !== void 0) { | |
if (this.options.trimValues) { | |
oldVal = oldVal.trim(); | |
} | |
oldVal = this.replaceEntitiesValue(oldVal); | |
const newVal = this.options.attributeValueProcessor(attrName, oldVal, jPath); | |
if (newVal === null || newVal === void 0) { | |
attrs[aName] = oldVal; | |
} else if (typeof newVal !== typeof oldVal || newVal !== oldVal) { | |
attrs[aName] = newVal; | |
} else { | |
attrs[aName] = parseValue( | |
oldVal, | |
this.options.parseAttributeValue, | |
this.options.numberParseOptions | |
); | |
} | |
} else if (this.options.allowBooleanAttributes) { | |
attrs[aName] = true; | |
} | |
} | |
} | |
if (!Object.keys(attrs).length) { | |
return; | |
} | |
if (this.options.attributesGroupName) { | |
const attrCollection = {}; | |
attrCollection[this.options.attributesGroupName] = attrs; | |
return attrCollection; | |
} | |
return attrs; | |
} | |
} | |
var parseXml = function(xmlData) { | |
xmlData = xmlData.replace(/\r\n?/g, "\n"); | |
const xmlObj = new xmlNode("!xml"); | |
let currentNode = xmlObj; | |
let textData = ""; | |
let jPath = ""; | |
for (let i = 0; i < xmlData.length; i++) { | |
const ch = xmlData[i]; | |
if (ch === "<") { | |
if (xmlData[i + 1] === "/") { | |
const closeIndex = findClosingIndex(xmlData, ">", i, "Closing Tag is not closed."); | |
let tagName = xmlData.substring(i + 2, closeIndex).trim(); | |
if (this.options.removeNSPrefix) { | |
const colonIndex = tagName.indexOf(":"); | |
if (colonIndex !== -1) { | |
tagName = tagName.substr(colonIndex + 1); | |
} | |
} | |
if (this.options.transformTagName) { | |
tagName = this.options.transformTagName(tagName); | |
} | |
if (currentNode) { | |
textData = this.saveTextToParentTag(textData, currentNode, jPath); | |
} | |
jPath = jPath.substr(0, jPath.lastIndexOf(".")); | |
currentNode = this.tagsNodeStack.pop(); | |
textData = ""; | |
i = closeIndex; | |
} else if (xmlData[i + 1] === "?") { | |
let tagData = readTagExp(xmlData, i, false, "?>"); | |
if (!tagData) | |
throw new Error("Pi Tag is not closed."); | |
textData = this.saveTextToParentTag(textData, currentNode, jPath); | |
if (this.options.ignoreDeclaration && tagData.tagName === "?xml" || this.options.ignorePiTags) { | |
} else { | |
const childNode = new xmlNode(tagData.tagName); | |
childNode.add(this.options.textNodeName, ""); | |
if (tagData.tagName !== tagData.tagExp && tagData.attrExpPresent) { | |
childNode[":@"] = this.buildAttributesMap(tagData.tagExp, jPath); | |
} | |
currentNode.addChild(childNode); | |
} | |
i = tagData.closeIndex + 1; | |
} else if (xmlData.substr(i + 1, 3) === "!--") { | |
const endIndex = findClosingIndex(xmlData, "-->", i + 4, "Comment is not closed."); | |
if (this.options.commentPropName) { | |
const comment = xmlData.substring(i + 4, endIndex - 2); | |
textData = this.saveTextToParentTag(textData, currentNode, jPath); | |
currentNode.add(this.options.commentPropName, [{ [this.options.textNodeName]: comment }]); | |
} | |
i = endIndex; | |
} else if (xmlData.substr(i + 1, 2) === "!D") { | |
const result = readDocType(xmlData, i); | |
this.docTypeEntities = result.entities; | |
i = result.i; | |
} else if (xmlData.substr(i + 1, 2) === "![") { | |
const closeIndex = findClosingIndex(xmlData, "]]>", i, "CDATA is not closed.") - 2; | |
const tagExp = xmlData.substring(i + 9, closeIndex); | |
textData = this.saveTextToParentTag(textData, currentNode, jPath); | |
if (this.options.cdataPropName) { | |
currentNode.add(this.options.cdataPropName, [{ [this.options.textNodeName]: tagExp }]); | |
} else { | |
let val = this.parseTextData(tagExp, currentNode.tagname, jPath, true, false, true); | |
if (val == void 0) | |
val = ""; | |
currentNode.add(this.options.textNodeName, val); | |
} | |
i = closeIndex + 2; | |
} else { | |
let result = readTagExp(xmlData, i, this.options.removeNSPrefix); | |
let tagName = result.tagName; | |
let tagExp = result.tagExp; | |
let attrExpPresent = result.attrExpPresent; | |
let closeIndex = result.closeIndex; | |
if (this.options.transformTagName) { | |
tagName = this.options.transformTagName(tagName); | |
} | |
if (currentNode && textData) { | |
if (currentNode.tagname !== "!xml") { | |
textData = this.saveTextToParentTag(textData, currentNode, jPath, false); | |
} | |
} | |
if (tagName !== xmlObj.tagname) { | |
jPath += jPath ? "." + tagName : tagName; | |
} | |
const lastTag = currentNode; | |
if (lastTag && this.options.unpairedTags.indexOf(lastTag.tagname) !== -1) { | |
currentNode = this.tagsNodeStack.pop(); | |
} | |
if (this.isItStopNode(this.options.stopNodes, jPath, tagName)) { | |
let tagContent = ""; | |
if (tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1) { | |
i = result.closeIndex; | |
} else if (this.options.unpairedTags.indexOf(tagName) !== -1) { | |
i = result.closeIndex; | |
} else { | |
const result2 = this.readStopNodeData(xmlData, tagName, closeIndex + 1); | |
if (!result2) | |
throw new Error(`Unexpected end of ${tagName}`); | |
i = result2.i; | |
tagContent = result2.tagContent; | |
} | |
const childNode = new xmlNode(tagName); | |
if (tagName !== tagExp && attrExpPresent) { | |
childNode[":@"] = this.buildAttributesMap(tagExp, jPath); | |
} | |
if (tagContent) { | |
tagContent = this.parseTextData(tagContent, tagName, jPath, true, attrExpPresent, true, true); | |
} | |
jPath = jPath.substr(0, jPath.lastIndexOf(".")); | |
childNode.add(this.options.textNodeName, tagContent); | |
currentNode.addChild(childNode); | |
} else { | |
if (tagExp.length > 0 && tagExp.lastIndexOf("/") === tagExp.length - 1) { | |
if (tagName[tagName.length - 1] === "/") { | |
tagName = tagName.substr(0, tagName.length - 1); | |
tagExp = tagName; | |
} else { | |
tagExp = tagExp.substr(0, tagExp.length - 1); | |
} | |
if (this.options.transformTagName) { | |
tagName = this.options.transformTagName(tagName); | |
} | |
const childNode = new xmlNode(tagName); | |
if (tagName !== tagExp && attrExpPresent) { | |
childNode[":@"] = this.buildAttributesMap(tagExp, jPath); | |
} | |
jPath = jPath.substr(0, jPath.lastIndexOf(".")); | |
currentNode.addChild(childNode); | |
} else { | |
const childNode = new xmlNode(tagName); | |
this.tagsNodeStack.push(currentNode); | |
if (tagName !== tagExp && attrExpPresent) { | |
childNode[":@"] = this.buildAttributesMap(tagExp, jPath); | |
} | |
currentNode.addChild(childNode); | |
currentNode = childNode; | |
} | |
textData = ""; | |
i = closeIndex; | |
} | |
} | |
} else { | |
textData += xmlData[i]; | |
} | |
} | |
return xmlObj.child; | |
}; | |
var replaceEntitiesValue = function(val) { | |
if (this.options.processEntities) { | |
for (let entityName in this.docTypeEntities) { | |
const entity = this.docTypeEntities[entityName]; | |
val = val.replace(entity.regx, entity.val); | |
} | |
for (let entityName in this.lastEntities) { | |
const entity = this.lastEntities[entityName]; | |
val = val.replace(entity.regex, entity.val); | |
} | |
if (this.options.htmlEntities) { | |
for (let entityName in this.htmlEntities) { | |
const entity = this.htmlEntities[entityName]; | |
val = val.replace(entity.regex, entity.val); | |
} | |
} | |
val = val.replace(this.ampEntity.regex, this.ampEntity.val); | |
} | |
return val; | |
}; | |
function saveTextToParentTag(textData, currentNode, jPath, isLeafNode) { | |
if (textData) { | |
if (isLeafNode === void 0) | |
isLeafNode = Object.keys(currentNode.child).length === 0; | |
textData = this.parseTextData( | |
textData, | |
currentNode.tagname, | |
jPath, | |
false, | |
currentNode[":@"] ? Object.keys(currentNode[":@"]).length !== 0 : false, | |
isLeafNode | |
); | |
if (textData !== void 0 && textData !== "") | |
currentNode.add(this.options.textNodeName, textData); | |
textData = ""; | |
} | |
return textData; | |
} | |
function isItStopNode(stopNodes, jPath, currentTagName) { | |
const allNodesExp = "*." + currentTagName; | |
for (const stopNodePath in stopNodes) { | |
const stopNodeExp = stopNodes[stopNodePath]; | |
if (allNodesExp === stopNodeExp || jPath === stopNodeExp) | |
return true; | |
} | |
return false; | |
} | |
function tagExpWithClosingIndex(xmlData, i, closingChar = ">") { | |
let attrBoundary; | |
let tagExp = ""; | |
for (let index = i; index < xmlData.length; index++) { | |
let ch = xmlData[index]; | |
if (attrBoundary) { | |
if (ch === attrBoundary) | |
attrBoundary = ""; | |
} else if (ch === '"' || ch === "'") { | |
attrBoundary = ch; | |
} else if (ch === closingChar[0]) { | |
if (closingChar[1]) { | |
if (xmlData[index + 1] === closingChar[1]) { | |
return { | |
data: tagExp, | |
index | |
}; | |
} | |
} else { | |
return { | |
data: tagExp, | |
index | |
}; | |
} | |
} else if (ch === " ") { | |
ch = " "; | |
} | |
tagExp += ch; | |
} | |
} | |
function findClosingIndex(xmlData, str, i, errMsg) { | |
const closingIndex = xmlData.indexOf(str, i); | |
if (closingIndex === -1) { | |
throw new Error(errMsg); | |
} else { | |
return closingIndex + str.length - 1; | |
} | |
} | |
function readTagExp(xmlData, i, removeNSPrefix, closingChar = ">") { | |
const result = tagExpWithClosingIndex(xmlData, i + 1, closingChar); | |
if (!result) | |
return; | |
let tagExp = result.data; | |
const closeIndex = result.index; | |
const separatorIndex = tagExp.search(/\s/); | |
let tagName = tagExp; | |
let attrExpPresent = true; | |
if (separatorIndex !== -1) { | |
tagName = tagExp.substr(0, separatorIndex).replace(/\s\s*$/, ""); | |
tagExp = tagExp.substr(separatorIndex + 1); | |
} | |
if (removeNSPrefix) { | |
const colonIndex = tagName.indexOf(":"); | |
if (colonIndex !== -1) { | |
tagName = tagName.substr(colonIndex + 1); | |
attrExpPresent = tagName !== result.data.substr(colonIndex + 1); | |
} | |
} | |
return { | |
tagName, | |
tagExp, | |
closeIndex, | |
attrExpPresent | |
}; | |
} | |
function readStopNodeData(xmlData, tagName, i) { | |
const startIndex = i; | |
let openTagCount = 1; | |
for (; i < xmlData.length; i++) { | |
if (xmlData[i] === "<") { | |
if (xmlData[i + 1] === "/") { | |
const closeIndex = findClosingIndex(xmlData, ">", i, `${tagName} is not closed`); | |
let closeTagName = xmlData.substring(i + 2, closeIndex).trim(); | |
if (closeTagName === tagName) { | |
openTagCount--; | |
if (openTagCount === 0) { | |
return { | |
tagContent: xmlData.substring(startIndex, i), | |
i: closeIndex | |
}; | |
} | |
} | |
i = closeIndex; | |
} else if (xmlData[i + 1] === "?") { | |
const closeIndex = findClosingIndex(xmlData, "?>", i + 1, "StopNode is not closed."); | |
i = closeIndex; | |
} else if (xmlData.substr(i + 1, 3) === "!--") { | |
const closeIndex = findClosingIndex(xmlData, "-->", i + 3, "StopNode is not closed."); | |
i = closeIndex; | |
} else if (xmlData.substr(i + 1, 2) === "![") { | |
const closeIndex = findClosingIndex(xmlData, "]]>", i, "StopNode is not closed.") - 2; | |
i = closeIndex; | |
} else { | |
const tagData = readTagExp(xmlData, i, ">"); | |
if (tagData) { | |
const openTagName = tagData && tagData.tagName; | |
if (openTagName === tagName && tagData.tagExp[tagData.tagExp.length - 1] !== "/") { | |
openTagCount++; | |
} | |
i = tagData.closeIndex; | |
} | |
} | |
} | |
} | |
} | |
function parseValue(val, shouldParse, options) { | |
if (shouldParse && typeof val === "string") { | |
const newval = val.trim(); | |
if (newval === "true") | |
return true; | |
else if (newval === "false") | |
return false; | |
else | |
return toNumber(val, options); | |
} else { | |
if (util3.isExist(val)) { | |
return val; | |
} else { | |
return ""; | |
} | |
} | |
} | |
module2.exports = OrderedObjParser; | |
} | |
}); | |
// ../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlparser/node2json.js | |
var require_node2json = __commonJS({ | |
"../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlparser/node2json.js"(exports) { | |
"use strict"; | |
function prettify(node, options) { | |
return compress(node, options); | |
} | |
function compress(arr, options, jPath) { | |
let text; | |
const compressedObj = {}; | |
for (let i = 0; i < arr.length; i++) { | |
const tagObj = arr[i]; | |
const property = propName(tagObj); | |
let newJpath = ""; | |
if (jPath === void 0) | |
newJpath = property; | |
else | |
newJpath = jPath + "." + property; | |
if (property === options.textNodeName) { | |
if (text === void 0) | |
text = tagObj[property]; | |
else | |
text += "" + tagObj[property]; | |
} else if (property === void 0) { | |
continue; | |
} else if (tagObj[property]) { | |
let val = compress(tagObj[property], options, newJpath); | |
const isLeaf = isLeafTag(val, options); | |
if (tagObj[":@"]) { | |
assignAttributes(val, tagObj[":@"], newJpath, options); | |
} else if (Object.keys(val).length === 1 && val[options.textNodeName] !== void 0 && !options.alwaysCreateTextNode) { | |
val = val[options.textNodeName]; | |
} else if (Object.keys(val).length === 0) { | |
if (options.alwaysCreateTextNode) | |
val[options.textNodeName] = ""; | |
else | |
val = ""; | |
} | |
if (compressedObj[property] !== void 0 && compressedObj.hasOwnProperty(property)) { | |
if (!Array.isArray(compressedObj[property])) { | |
compressedObj[property] = [compressedObj[property]]; | |
} | |
compressedObj[property].push(val); | |
} else { | |
if (options.isArray(property, newJpath, isLeaf)) { | |
compressedObj[property] = [val]; | |
} else { | |
compressedObj[property] = val; | |
} | |
} | |
} | |
} | |
if (typeof text === "string") { | |
if (text.length > 0) | |
compressedObj[options.textNodeName] = text; | |
} else if (text !== void 0) | |
compressedObj[options.textNodeName] = text; | |
return compressedObj; | |
} | |
function propName(obj) { | |
const keys = Object.keys(obj); | |
for (let i = 0; i < keys.length; i++) { | |
const key = keys[i]; | |
if (key !== ":@") | |
return key; | |
} | |
} | |
function assignAttributes(obj, attrMap, jpath, options) { | |
if (attrMap) { | |
const keys = Object.keys(attrMap); | |
const len = keys.length; | |
for (let i = 0; i < len; i++) { | |
const atrrName = keys[i]; | |
if (options.isArray(atrrName, jpath + "." + atrrName, true, true)) { | |
obj[atrrName] = [attrMap[atrrName]]; | |
} else { | |
obj[atrrName] = attrMap[atrrName]; | |
} | |
} | |
} | |
} | |
function isLeafTag(obj, options) { | |
const propCount = Object.keys(obj).length; | |
if (propCount === 0 || propCount === 1 && obj[options.textNodeName]) | |
return true; | |
return false; | |
} | |
exports.prettify = prettify; | |
} | |
}); | |
// ../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlparser/XMLParser.js | |
var require_XMLParser = __commonJS({ | |
"../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlparser/XMLParser.js"(exports, module2) { | |
var { buildOptions } = require_OptionsBuilder(); | |
var OrderedObjParser = require_OrderedObjParser(); | |
var { prettify } = require_node2json(); | |
var validator = require_validator(); | |
var XMLParser = class { | |
constructor(options) { | |
this.externalEntities = {}; | |
this.options = buildOptions(options); | |
} | |
/** | |
* Parse XML dats to JS object | |
* @param {string|Buffer} xmlData | |
* @param {boolean|Object} validationOption | |
*/ | |
parse(xmlData, validationOption) { | |
if (typeof xmlData === "string") { | |
} else if (xmlData.toString) { | |
xmlData = xmlData.toString(); | |
} else { | |
throw new Error("XML data is accepted in String or Bytes[] form."); | |
} | |
if (validationOption) { | |
if (validationOption === true) | |
validationOption = {}; | |
const result = validator.validate(xmlData, validationOption); | |
if (result !== true) { | |
throw Error(`${result.err.msg}:${result.err.line}:${result.err.col}`); | |
} | |
} | |
const orderedObjParser = new OrderedObjParser(this.options); | |
orderedObjParser.addExternalEntities(this.externalEntities); | |
const orderedResult = orderedObjParser.parseXml(xmlData); | |
if (this.options.preserveOrder || orderedResult === void 0) | |
return orderedResult; | |
else | |
return prettify(orderedResult, this.options); | |
} | |
/** | |
* Add Entity which is not by default supported by this library | |
* @param {string} key | |
* @param {string} value | |
*/ | |
addEntity(key, value) { | |
if (value.indexOf("&") !== -1) { | |
throw new Error("Entity value can't have '&'"); | |
} else if (key.indexOf("&") !== -1 || key.indexOf(";") !== -1) { | |
throw new Error("An entity must be set without '&' and ';'. Eg. use '#xD' for '
'"); | |
} else if (value === "&") { | |
throw new Error("An entity with value '&' is not permitted"); | |
} else { | |
this.externalEntities[key] = value; | |
} | |
} | |
}; | |
module2.exports = XMLParser; | |
} | |
}); | |
// ../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlbuilder/orderedJs2Xml.js | |
var require_orderedJs2Xml = __commonJS({ | |
"../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlbuilder/orderedJs2Xml.js"(exports, module2) { | |
var EOL = "\n"; | |
function toXml(jArray, options) { | |
return arrToStr(jArray, options, "", 0); | |
} | |
function arrToStr(arr, options, jPath, level) { | |
let xmlStr = ""; | |
let indentation = ""; | |
if (options.format && options.indentBy.length > 0) { | |
indentation = EOL + "" + options.indentBy.repeat(level); | |
} | |
for (let i = 0; i < arr.length; i++) { | |
const tagObj = arr[i]; | |
const tagName = propName(tagObj); | |
let newJPath = ""; | |
if (jPath.length === 0) | |
newJPath = tagName; | |
else | |
newJPath = `${jPath}.${tagName}`; | |
if (tagName === options.textNodeName) { | |
let tagText = tagObj[tagName]; | |
if (!isStopNode(newJPath, options)) { | |
tagText = options.tagValueProcessor(tagName, tagText); | |
tagText = replaceEntitiesValue(tagText, options); | |
} | |
xmlStr += indentation + tagText; | |
continue; | |
} else if (tagName === options.cdataPropName) { | |
xmlStr += indentation + `<![CDATA[${tagObj[tagName][0][options.textNodeName]}]]>`; | |
continue; | |
} else if (tagName === options.commentPropName) { | |
xmlStr += indentation + `<!--${tagObj[tagName][0][options.textNodeName]}-->`; | |
continue; | |
} else if (tagName[0] === "?") { | |
const attStr2 = attr_to_str(tagObj[":@"], options); | |
const tempInd = tagName === "?xml" ? "" : indentation; | |
let piTextNodeName = tagObj[tagName][0][options.textNodeName]; | |
piTextNodeName = piTextNodeName.length !== 0 ? " " + piTextNodeName : ""; | |
xmlStr += tempInd + `<${tagName}${piTextNodeName}${attStr2}?>`; | |
continue; | |
} | |
const attStr = attr_to_str(tagObj[":@"], options); | |
let tagStart = indentation + `<${tagName}${attStr}`; | |
let tagValue = arrToStr(tagObj[tagName], options, newJPath, level + 1); | |
if (options.unpairedTags.indexOf(tagName) !== -1) { | |
if (options.suppressUnpairedNode) | |
xmlStr += tagStart + ">"; | |
else | |
xmlStr += tagStart + "/>"; | |
} else if ((!tagValue || tagValue.length === 0) && options.suppressEmptyNode) { | |
xmlStr += tagStart + "/>"; | |
} else { | |
xmlStr += tagStart + `>${tagValue}${indentation}</${tagName}>`; | |
} | |
} | |
return xmlStr; | |
} | |
function propName(obj) { | |
const keys = Object.keys(obj); | |
for (let i = 0; i < keys.length; i++) { | |
const key = keys[i]; | |
if (key !== ":@") | |
return key; | |
} | |
} | |
function attr_to_str(attrMap, options) { | |
let attrStr = ""; | |
if (attrMap && !options.ignoreAttributes) { | |
for (let attr in attrMap) { | |
let attrVal = options.attributeValueProcessor(attr, attrMap[attr]); | |
attrVal = replaceEntitiesValue(attrVal, options); | |
if (attrVal === true && options.suppressBooleanAttributes) { | |
attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}`; | |
} else { | |
attrStr += ` ${attr.substr(options.attributeNamePrefix.length)}="${attrVal}"`; | |
} | |
} | |
} | |
return attrStr; | |
} | |
function isStopNode(jPath, options) { | |
jPath = jPath.substr(0, jPath.length - options.textNodeName.length - 1); | |
let tagName = jPath.substr(jPath.lastIndexOf(".") + 1); | |
for (let index in options.stopNodes) { | |
if (options.stopNodes[index] === jPath || options.stopNodes[index] === "*." + tagName) | |
return true; | |
} | |
return false; | |
} | |
function replaceEntitiesValue(textValue, options) { | |
if (textValue && textValue.length > 0 && options.processEntities) { | |
for (let i = 0; i < options.entities.length; i++) { | |
const entity = options.entities[i]; | |
textValue = textValue.replace(entity.regex, entity.val); | |
} | |
} | |
return textValue; | |
} | |
module2.exports = toXml; | |
} | |
}); | |
// ../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlbuilder/json2xml.js | |
var require_json2xml = __commonJS({ | |
"../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/xmlbuilder/json2xml.js"(exports, module2) { | |
"use strict"; | |
var buildFromOrderedJs = require_orderedJs2Xml(); | |
var defaultOptions = { | |
attributeNamePrefix: "@_", | |
attributesGroupName: false, | |
textNodeName: "#text", | |
ignoreAttributes: true, | |
cdataPropName: false, | |
format: false, | |
indentBy: " ", | |
suppressEmptyNode: false, | |
suppressUnpairedNode: true, | |
suppressBooleanAttributes: true, | |
tagValueProcessor: function(key, a) { | |
return a; | |
}, | |
attributeValueProcessor: function(attrName, a) { | |
return a; | |
}, | |
preserveOrder: false, | |
commentPropName: false, | |
unpairedTags: [], | |
entities: [ | |
{ regex: new RegExp("&", "g"), val: "&" }, | |
//it must be on top | |
{ regex: new RegExp(">", "g"), val: ">" }, | |
{ regex: new RegExp("<", "g"), val: "<" }, | |
{ regex: new RegExp("'", "g"), val: "'" }, | |
{ regex: new RegExp('"', "g"), val: """ } | |
], | |
processEntities: true, | |
stopNodes: [], | |
transformTagName: false | |
}; | |
function Builder(options) { | |
this.options = Object.assign({}, defaultOptions, options); | |
if (this.options.ignoreAttributes || this.options.attributesGroupName) { | |
this.isAttribute = function() { | |
return false; | |
}; | |
} else { | |
this.attrPrefixLen = this.options.attributeNamePrefix.length; | |
this.isAttribute = isAttribute; | |
} | |
this.processTextOrObjNode = processTextOrObjNode; | |
if (this.options.format) { | |
this.indentate = indentate; | |
this.tagEndChar = ">\n"; | |
this.newLine = "\n"; | |
} else { | |
this.indentate = function() { | |
return ""; | |
}; | |
this.tagEndChar = ">"; | |
this.newLine = ""; | |
} | |
if (this.options.suppressEmptyNode) { | |
this.buildTextNode = buildEmptyTextNode; | |
this.buildObjNode = buildEmptyObjNode; | |
} else { | |
this.buildTextNode = buildTextValNode; | |
this.buildObjNode = buildObjectNode; | |
} | |
this.buildTextValNode = buildTextValNode; | |
this.buildObjectNode = buildObjectNode; | |
this.replaceEntitiesValue = replaceEntitiesValue; | |
this.buildAttrPairStr = buildAttrPairStr; | |
} | |
Builder.prototype.build = function(jObj) { | |
if (this.options.preserveOrder) { | |
return buildFromOrderedJs(jObj, this.options); | |
} else { | |
if (Array.isArray(jObj) && this.options.arrayNodeName && this.options.arrayNodeName.length > 1) { | |
jObj = { | |
[this.options.arrayNodeName]: jObj | |
}; | |
} | |
return this.j2x(jObj, 0).val; | |
} | |
}; | |
Builder.prototype.j2x = function(jObj, level) { | |
let attrStr = ""; | |
let val = ""; | |
for (let key in jObj) { | |
if (typeof jObj[key] === "undefined") { | |
} else if (jObj[key] === null) { | |
if (key[0] === "?") | |
val += this.indentate(level) + "<" + key + "?" + this.tagEndChar; | |
else | |
val += this.indentate(level) + "<" + key + "/" + this.tagEndChar; | |
} else if (jObj[key] instanceof Date) { | |
val += this.buildTextNode(jObj[key], key, "", level); | |
} else if (typeof jObj[key] !== "object") { | |
const attr = this.isAttribute(key); | |
if (attr) { | |
attrStr += this.buildAttrPairStr(attr, "" + jObj[key]); | |
} else { | |
if (key === this.options.textNodeName) { | |
let newval = this.options.tagValueProcessor(key, "" + jObj[key]); | |
val += this.replaceEntitiesValue(newval); | |
} else { | |
val += this.buildTextNode(jObj[key], key, "", level); | |
} | |
} | |
} else if (Array.isArray(jObj[key])) { | |
const arrLen = jObj[key].length; | |
for (let j = 0; j < arrLen; j++) { | |
const item = jObj[key][j]; | |
if (typeof item === "undefined") { | |
} else if (item === null) { | |
if (key[0] === "?") | |
val += this.indentate(level) + "<" + key + "?" + this.tagEndChar; | |
else | |
val += this.indentate(level) + "<" + key + "/" + this.tagEndChar; | |
} else if (typeof item === "object") { | |
val += this.processTextOrObjNode(item, key, level); | |
} else { | |
val += this.buildTextNode(item, key, "", level); | |
} | |
} | |
} else { | |
if (this.options.attributesGroupName && key === this.options.attributesGroupName) { | |
const Ks = Object.keys(jObj[key]); | |
const L = Ks.length; | |
for (let j = 0; j < L; j++) { | |
attrStr += this.buildAttrPairStr(Ks[j], "" + jObj[key][Ks[j]]); | |
} | |
} else { | |
val += this.processTextOrObjNode(jObj[key], key, level); | |
} | |
} | |
} | |
return { attrStr, val }; | |
}; | |
function buildAttrPairStr(attrName, val) { | |
val = this.options.attributeValueProcessor(attrName, "" + val); | |
val = this.replaceEntitiesValue(val); | |
if (this.options.suppressBooleanAttributes && val === "true") { | |
return " " + attrName; | |
} else | |
return " " + attrName + '="' + val + '"'; | |
} | |
function processTextOrObjNode(object, key, level) { | |
const result = this.j2x(object, level + 1); | |
if (object[this.options.textNodeName] !== void 0 && Object.keys(object).length === 1) { | |
return this.buildTextNode(object[this.options.textNodeName], key, result.attrStr, level); | |
} else { | |
return this.buildObjNode(result.val, key, result.attrStr, level); | |
} | |
} | |
function buildObjectNode(val, key, attrStr, level) { | |
let tagEndExp = "</" + key + this.tagEndChar; | |
let piClosingChar = ""; | |
if (key[0] === "?") { | |
piClosingChar = "?"; | |
tagEndExp = ""; | |
} | |
if (attrStr && val.indexOf("<") === -1) { | |
return this.indentate(level) + "<" + key + attrStr + piClosingChar + ">" + val + tagEndExp; | |
} else if (this.options.commentPropName !== false && key === this.options.commentPropName && piClosingChar.length === 0) { | |
return this.indentate(level) + `<!--${val}-->` + this.newLine; | |
} else { | |
return this.indentate(level) + "<" + key + attrStr + piClosingChar + this.tagEndChar + val + this.indentate(level) + tagEndExp; | |
} | |
} | |
function buildEmptyObjNode(val, key, attrStr, level) { | |
if (val !== "") { | |
return this.buildObjectNode(val, key, attrStr, level); | |
} else { | |
if (key[0] === "?") | |
return this.indentate(level) + "<" + key + attrStr + "?" + this.tagEndChar; | |
else | |
return this.indentate(level) + "<" + key + attrStr + "/" + this.tagEndChar; | |
} | |
} | |
function buildTextValNode(val, key, attrStr, level) { | |
if (this.options.cdataPropName !== false && key === this.options.cdataPropName) { | |
return this.indentate(level) + `<![CDATA[${val}]]>` + this.newLine; | |
} else if (this.options.commentPropName !== false && key === this.options.commentPropName) { | |
return this.indentate(level) + `<!--${val}-->` + this.newLine; | |
} else { | |
let textValue = this.options.tagValueProcessor(key, val); | |
textValue = this.replaceEntitiesValue(textValue); | |
if (textValue === "" && this.options.unpairedTags.indexOf(key) !== -1) { | |
if (this.options.suppressUnpairedNode) { | |
return this.indentate(level) + "<" + key + this.tagEndChar; | |
} else { | |
return this.indentate(level) + "<" + key + "/" + this.tagEndChar; | |
} | |
} else { | |
return this.indentate(level) + "<" + key + attrStr + ">" + textValue + "</" + key + this.tagEndChar; | |
} | |
} | |
} | |
function replaceEntitiesValue(textValue) { | |
if (textValue && textValue.length > 0 && this.options.processEntities) { | |
for (let i = 0; i < this.options.entities.length; i++) { | |
const entity = this.options.entities[i]; | |
textValue = textValue.replace(entity.regex, entity.val); | |
} | |
} | |
return textValue; | |
} | |
function buildEmptyTextNode(val, key, attrStr, level) { | |
if (val === "" && this.options.unpairedTags.indexOf(key) !== -1) { | |
if (this.options.suppressUnpairedNode) { | |
return this.indentate(level) + "<" + key + this.tagEndChar; | |
} else { | |
return this.indentate(level) + "<" + key + "/" + this.tagEndChar; | |
} | |
} else if (val !== "") { | |
return this.buildTextValNode(val, key, attrStr, level); | |
} else { | |
if (key[0] === "?") | |
return this.indentate(level) + "<" + key + attrStr + "?" + this.tagEndChar; | |
else | |
return this.indentate(level) + "<" + key + attrStr + "/" + this.tagEndChar; | |
} | |
} | |
function indentate(level) { | |
return this.options.indentBy.repeat(level); | |
} | |
function isAttribute(name) { | |
if (name.startsWith(this.options.attributeNamePrefix)) { | |
return name.substr(this.attrPrefixLen); | |
} else { | |
return false; | |
} | |
} | |
module2.exports = Builder; | |
} | |
}); | |
// ../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/fxp.js | |
var require_fxp = __commonJS({ | |
"../../node_modules/.pnpm/fast-xml-parser@4.0.11/node_modules/fast-xml-parser/src/fxp.js"(exports, module2) { | |
"use strict"; | |
var validator = require_validator(); | |
var XMLParser = require_XMLParser(); | |
var XMLBuilder = require_json2xml(); | |
module2.exports = { | |
XMLParser, | |
XMLValidator: validator, | |
XMLBuilder | |
}; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/models/models_1.js | |
var require_models_1 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/models/models_1.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.WriteGetObjectResponseRequestFilterSensitiveLog = exports.UploadPartCopyRequestFilterSensitiveLog = exports.UploadPartCopyOutputFilterSensitiveLog = exports.CopyPartResultFilterSensitiveLog = exports.UploadPartRequestFilterSensitiveLog = exports.UploadPartOutputFilterSensitiveLog = exports.SelectObjectContentRequestFilterSensitiveLog = exports.ScanRangeFilterSensitiveLog = exports.RequestProgressFilterSensitiveLog = exports.SelectObjectContentOutputFilterSensitiveLog = exports.SelectObjectContentEventStreamFilterSensitiveLog = exports.StatsEventFilterSensitiveLog = exports.StatsFilterSensitiveLog = exports.RecordsEventFilterSensitiveLog = exports.ProgressEventFilterSensitiveLog = exports.ProgressFilterSensitiveLog = exports.EndEventFilterSensitiveLog = exports.ContinuationEventFilterSensitiveLog = exports.RestoreObjectRequestFilterSensitiveLog = exports.RestoreRequestFilterSensitiveLog = exports.SelectParametersFilterSensitiveLog = exports.OutputSerializationFilterSensitiveLog = exports.JSONOutputFilterSensitiveLog = exports.CSVOutputFilterSensitiveLog = exports.InputSerializationFilterSensitiveLog = exports.ParquetInputFilterSensitiveLog = exports.JSONInputFilterSensitiveLog = exports.CSVInputFilterSensitiveLog = exports.OutputLocationFilterSensitiveLog = exports.S3LocationFilterSensitiveLog = exports.MetadataEntryFilterSensitiveLog = exports.EncryptionFilterSensitiveLog = exports.GlacierJobParametersFilterSensitiveLog = exports.RestoreObjectOutputFilterSensitiveLog = exports.PutPublicAccessBlockRequestFilterSensitiveLog = exports.PutObjectTaggingRequestFilterSensitiveLog = exports.PutObjectTaggingOutputFilterSensitiveLog = exports.PutObjectRetentionRequestFilterSensitiveLog = exports.PutObjectRetentionOutputFilterSensitiveLog = exports.SelectObjectContentEventStream = exports.RestoreRequestType = exports.QuoteFields = exports.JSONType = exports.FileHeaderInfo = exports.CompressionType = exports.ExpressionType = exports.Tier = exports.ObjectAlreadyInActiveTierError = void 0; | |
var smithy_client_1 = require_dist_cjs7(); | |
var S3ServiceException_1 = require_S3ServiceException(); | |
var ObjectAlreadyInActiveTierError = class extends S3ServiceException_1.S3ServiceException { | |
constructor(opts) { | |
super({ | |
name: "ObjectAlreadyInActiveTierError", | |
$fault: "client", | |
...opts | |
}); | |
this.name = "ObjectAlreadyInActiveTierError"; | |
this.$fault = "client"; | |
Object.setPrototypeOf(this, ObjectAlreadyInActiveTierError.prototype); | |
} | |
}; | |
exports.ObjectAlreadyInActiveTierError = ObjectAlreadyInActiveTierError; | |
var Tier; | |
(function(Tier2) { | |
Tier2["Bulk"] = "Bulk"; | |
Tier2["Expedited"] = "Expedited"; | |
Tier2["Standard"] = "Standard"; | |
})(Tier = exports.Tier || (exports.Tier = {})); | |
var ExpressionType; | |
(function(ExpressionType2) { | |
ExpressionType2["SQL"] = "SQL"; | |
})(ExpressionType = exports.ExpressionType || (exports.ExpressionType = {})); | |
var CompressionType; | |
(function(CompressionType2) { | |
CompressionType2["BZIP2"] = "BZIP2"; | |
CompressionType2["GZIP"] = "GZIP"; | |
CompressionType2["NONE"] = "NONE"; | |
})(CompressionType = exports.CompressionType || (exports.CompressionType = {})); | |
var FileHeaderInfo; | |
(function(FileHeaderInfo2) { | |
FileHeaderInfo2["IGNORE"] = "IGNORE"; | |
FileHeaderInfo2["NONE"] = "NONE"; | |
FileHeaderInfo2["USE"] = "USE"; | |
})(FileHeaderInfo = exports.FileHeaderInfo || (exports.FileHeaderInfo = {})); | |
var JSONType; | |
(function(JSONType2) { | |
JSONType2["DOCUMENT"] = "DOCUMENT"; | |
JSONType2["LINES"] = "LINES"; | |
})(JSONType = exports.JSONType || (exports.JSONType = {})); | |
var QuoteFields; | |
(function(QuoteFields2) { | |
QuoteFields2["ALWAYS"] = "ALWAYS"; | |
QuoteFields2["ASNEEDED"] = "ASNEEDED"; | |
})(QuoteFields = exports.QuoteFields || (exports.QuoteFields = {})); | |
var RestoreRequestType; | |
(function(RestoreRequestType2) { | |
RestoreRequestType2["SELECT"] = "SELECT"; | |
})(RestoreRequestType = exports.RestoreRequestType || (exports.RestoreRequestType = {})); | |
var SelectObjectContentEventStream; | |
(function(SelectObjectContentEventStream2) { | |
SelectObjectContentEventStream2.visit = (value, visitor) => { | |
if (value.Records !== void 0) | |
return visitor.Records(value.Records); | |
if (value.Stats !== void 0) | |
return visitor.Stats(value.Stats); | |
if (value.Progress !== void 0) | |
return visitor.Progress(value.Progress); | |
if (value.Cont !== void 0) | |
return visitor.Cont(value.Cont); | |
if (value.End !== void 0) | |
return visitor.End(value.End); | |
return visitor._(value.$unknown[0], value.$unknown[1]); | |
}; | |
})(SelectObjectContentEventStream = exports.SelectObjectContentEventStream || (exports.SelectObjectContentEventStream = {})); | |
var PutObjectRetentionOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.PutObjectRetentionOutputFilterSensitiveLog = PutObjectRetentionOutputFilterSensitiveLog; | |
var PutObjectRetentionRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.PutObjectRetentionRequestFilterSensitiveLog = PutObjectRetentionRequestFilterSensitiveLog; | |
var PutObjectTaggingOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.PutObjectTaggingOutputFilterSensitiveLog = PutObjectTaggingOutputFilterSensitiveLog; | |
var PutObjectTaggingRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.PutObjectTaggingRequestFilterSensitiveLog = PutObjectTaggingRequestFilterSensitiveLog; | |
var PutPublicAccessBlockRequestFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.PutPublicAccessBlockRequestFilterSensitiveLog = PutPublicAccessBlockRequestFilterSensitiveLog; | |
var RestoreObjectOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.RestoreObjectOutputFilterSensitiveLog = RestoreObjectOutputFilterSensitiveLog; | |
var GlacierJobParametersFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.GlacierJobParametersFilterSensitiveLog = GlacierJobParametersFilterSensitiveLog; | |
var EncryptionFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.KMSKeyId && { KMSKeyId: smithy_client_1.SENSITIVE_STRING } | |
}); | |
exports.EncryptionFilterSensitiveLog = EncryptionFilterSensitiveLog; | |
var MetadataEntryFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.MetadataEntryFilterSensitiveLog = MetadataEntryFilterSensitiveLog; | |
var S3LocationFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.Encryption && { Encryption: (0, exports.EncryptionFilterSensitiveLog)(obj.Encryption) } | |
}); | |
exports.S3LocationFilterSensitiveLog = S3LocationFilterSensitiveLog; | |
var OutputLocationFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.S3 && { S3: (0, exports.S3LocationFilterSensitiveLog)(obj.S3) } | |
}); | |
exports.OutputLocationFilterSensitiveLog = OutputLocationFilterSensitiveLog; | |
var CSVInputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.CSVInputFilterSensitiveLog = CSVInputFilterSensitiveLog; | |
var JSONInputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.JSONInputFilterSensitiveLog = JSONInputFilterSensitiveLog; | |
var ParquetInputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ParquetInputFilterSensitiveLog = ParquetInputFilterSensitiveLog; | |
var InputSerializationFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.InputSerializationFilterSensitiveLog = InputSerializationFilterSensitiveLog; | |
var CSVOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.CSVOutputFilterSensitiveLog = CSVOutputFilterSensitiveLog; | |
var JSONOutputFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.JSONOutputFilterSensitiveLog = JSONOutputFilterSensitiveLog; | |
var OutputSerializationFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.OutputSerializationFilterSensitiveLog = OutputSerializationFilterSensitiveLog; | |
var SelectParametersFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.SelectParametersFilterSensitiveLog = SelectParametersFilterSensitiveLog; | |
var RestoreRequestFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.OutputLocation && { OutputLocation: (0, exports.OutputLocationFilterSensitiveLog)(obj.OutputLocation) } | |
}); | |
exports.RestoreRequestFilterSensitiveLog = RestoreRequestFilterSensitiveLog; | |
var RestoreObjectRequestFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.RestoreRequest && { RestoreRequest: (0, exports.RestoreRequestFilterSensitiveLog)(obj.RestoreRequest) } | |
}); | |
exports.RestoreObjectRequestFilterSensitiveLog = RestoreObjectRequestFilterSensitiveLog; | |
var ContinuationEventFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ContinuationEventFilterSensitiveLog = ContinuationEventFilterSensitiveLog; | |
var EndEventFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.EndEventFilterSensitiveLog = EndEventFilterSensitiveLog; | |
var ProgressFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ProgressFilterSensitiveLog = ProgressFilterSensitiveLog; | |
var ProgressEventFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ProgressEventFilterSensitiveLog = ProgressEventFilterSensitiveLog; | |
var RecordsEventFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.RecordsEventFilterSensitiveLog = RecordsEventFilterSensitiveLog; | |
var StatsFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.StatsFilterSensitiveLog = StatsFilterSensitiveLog; | |
var StatsEventFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.StatsEventFilterSensitiveLog = StatsEventFilterSensitiveLog; | |
var SelectObjectContentEventStreamFilterSensitiveLog = (obj) => { | |
if (obj.Records !== void 0) | |
return { Records: (0, exports.RecordsEventFilterSensitiveLog)(obj.Records) }; | |
if (obj.Stats !== void 0) | |
return { Stats: (0, exports.StatsEventFilterSensitiveLog)(obj.Stats) }; | |
if (obj.Progress !== void 0) | |
return { Progress: (0, exports.ProgressEventFilterSensitiveLog)(obj.Progress) }; | |
if (obj.Cont !== void 0) | |
return { Cont: (0, exports.ContinuationEventFilterSensitiveLog)(obj.Cont) }; | |
if (obj.End !== void 0) | |
return { End: (0, exports.EndEventFilterSensitiveLog)(obj.End) }; | |
if (obj.$unknown !== void 0) | |
return { [obj.$unknown[0]]: "UNKNOWN" }; | |
}; | |
exports.SelectObjectContentEventStreamFilterSensitiveLog = SelectObjectContentEventStreamFilterSensitiveLog; | |
var SelectObjectContentOutputFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.Payload && { Payload: "STREAMING_CONTENT" } | |
}); | |
exports.SelectObjectContentOutputFilterSensitiveLog = SelectObjectContentOutputFilterSensitiveLog; | |
var RequestProgressFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.RequestProgressFilterSensitiveLog = RequestProgressFilterSensitiveLog; | |
var ScanRangeFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.ScanRangeFilterSensitiveLog = ScanRangeFilterSensitiveLog; | |
var SelectObjectContentRequestFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.SSECustomerKey && { SSECustomerKey: smithy_client_1.SENSITIVE_STRING } | |
}); | |
exports.SelectObjectContentRequestFilterSensitiveLog = SelectObjectContentRequestFilterSensitiveLog; | |
var UploadPartOutputFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.SSEKMSKeyId && { SSEKMSKeyId: smithy_client_1.SENSITIVE_STRING } | |
}); | |
exports.UploadPartOutputFilterSensitiveLog = UploadPartOutputFilterSensitiveLog; | |
var UploadPartRequestFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.SSECustomerKey && { SSECustomerKey: smithy_client_1.SENSITIVE_STRING } | |
}); | |
exports.UploadPartRequestFilterSensitiveLog = UploadPartRequestFilterSensitiveLog; | |
var CopyPartResultFilterSensitiveLog = (obj) => ({ | |
...obj | |
}); | |
exports.CopyPartResultFilterSensitiveLog = CopyPartResultFilterSensitiveLog; | |
var UploadPartCopyOutputFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.SSEKMSKeyId && { SSEKMSKeyId: smithy_client_1.SENSITIVE_STRING } | |
}); | |
exports.UploadPartCopyOutputFilterSensitiveLog = UploadPartCopyOutputFilterSensitiveLog; | |
var UploadPartCopyRequestFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.SSECustomerKey && { SSECustomerKey: smithy_client_1.SENSITIVE_STRING }, | |
...obj.CopySourceSSECustomerKey && { CopySourceSSECustomerKey: smithy_client_1.SENSITIVE_STRING } | |
}); | |
exports.UploadPartCopyRequestFilterSensitiveLog = UploadPartCopyRequestFilterSensitiveLog; | |
var WriteGetObjectResponseRequestFilterSensitiveLog = (obj) => ({ | |
...obj, | |
...obj.SSEKMSKeyId && { SSEKMSKeyId: smithy_client_1.SENSITIVE_STRING } | |
}); | |
exports.WriteGetObjectResponseRequestFilterSensitiveLog = WriteGetObjectResponseRequestFilterSensitiveLog; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/protocols/Aws_restXml.js | |
var require_Aws_restXml = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/protocols/Aws_restXml.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.serializeAws_restXmlGetObjectTorrentCommand = exports.serializeAws_restXmlGetObjectTaggingCommand = exports.serializeAws_restXmlGetObjectRetentionCommand = exports.serializeAws_restXmlGetObjectLockConfigurationCommand = exports.serializeAws_restXmlGetObjectLegalHoldCommand = exports.serializeAws_restXmlGetObjectAttributesCommand = exports.serializeAws_restXmlGetObjectAclCommand = exports.serializeAws_restXmlGetObjectCommand = exports.serializeAws_restXmlGetBucketWebsiteCommand = exports.serializeAws_restXmlGetBucketVersioningCommand = exports.serializeAws_restXmlGetBucketTaggingCommand = exports.serializeAws_restXmlGetBucketRequestPaymentCommand = exports.serializeAws_restXmlGetBucketReplicationCommand = exports.serializeAws_restXmlGetBucketPolicyStatusCommand = exports.serializeAws_restXmlGetBucketPolicyCommand = exports.serializeAws_restXmlGetBucketOwnershipControlsCommand = exports.serializeAws_restXmlGetBucketNotificationConfigurationCommand = exports.serializeAws_restXmlGetBucketMetricsConfigurationCommand = exports.serializeAws_restXmlGetBucketLoggingCommand = exports.serializeAws_restXmlGetBucketLocationCommand = exports.serializeAws_restXmlGetBucketLifecycleConfigurationCommand = exports.serializeAws_restXmlGetBucketInventoryConfigurationCommand = exports.serializeAws_restXmlGetBucketIntelligentTieringConfigurationCommand = exports.serializeAws_restXmlGetBucketEncryptionCommand = exports.serializeAws_restXmlGetBucketCorsCommand = exports.serializeAws_restXmlGetBucketAnalyticsConfigurationCommand = exports.serializeAws_restXmlGetBucketAclCommand = exports.serializeAws_restXmlGetBucketAccelerateConfigurationCommand = exports.serializeAws_restXmlDeletePublicAccessBlockCommand = exports.serializeAws_restXmlDeleteObjectTaggingCommand = exports.serializeAws_restXmlDeleteObjectsCommand = exports.serializeAws_restXmlDeleteObjectCommand = exports.serializeAws_restXmlDeleteBucketWebsiteCommand = exports.serializeAws_restXmlDeleteBucketTaggingCommand = exports.serializeAws_restXmlDeleteBucketReplicationCommand = exports.serializeAws_restXmlDeleteBucketPolicyCommand = exports.serializeAws_restXmlDeleteBucketOwnershipControlsCommand = exports.serializeAws_restXmlDeleteBucketMetricsConfigurationCommand = exports.serializeAws_restXmlDeleteBucketLifecycleCommand = exports.serializeAws_restXmlDeleteBucketInventoryConfigurationCommand = exports.serializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommand = exports.serializeAws_restXmlDeleteBucketEncryptionCommand = exports.serializeAws_restXmlDeleteBucketCorsCommand = exports.serializeAws_restXmlDeleteBucketAnalyticsConfigurationCommand = exports.serializeAws_restXmlDeleteBucketCommand = exports.serializeAws_restXmlCreateMultipartUploadCommand = exports.serializeAws_restXmlCreateBucketCommand = exports.serializeAws_restXmlCopyObjectCommand = exports.serializeAws_restXmlCompleteMultipartUploadCommand = exports.serializeAws_restXmlAbortMultipartUploadCommand = void 0; | |
exports.deserializeAws_restXmlDeleteBucketAnalyticsConfigurationCommand = exports.deserializeAws_restXmlDeleteBucketCommand = exports.deserializeAws_restXmlCreateMultipartUploadCommand = exports.deserializeAws_restXmlCreateBucketCommand = exports.deserializeAws_restXmlCopyObjectCommand = exports.deserializeAws_restXmlCompleteMultipartUploadCommand = exports.deserializeAws_restXmlAbortMultipartUploadCommand = exports.serializeAws_restXmlWriteGetObjectResponseCommand = exports.serializeAws_restXmlUploadPartCopyCommand = exports.serializeAws_restXmlUploadPartCommand = exports.serializeAws_restXmlSelectObjectContentCommand = exports.serializeAws_restXmlRestoreObjectCommand = exports.serializeAws_restXmlPutPublicAccessBlockCommand = exports.serializeAws_restXmlPutObjectTaggingCommand = exports.serializeAws_restXmlPutObjectRetentionCommand = exports.serializeAws_restXmlPutObjectLockConfigurationCommand = exports.serializeAws_restXmlPutObjectLegalHoldCommand = exports.serializeAws_restXmlPutObjectAclCommand = exports.serializeAws_restXmlPutObjectCommand = exports.serializeAws_restXmlPutBucketWebsiteCommand = exports.serializeAws_restXmlPutBucketVersioningCommand = exports.serializeAws_restXmlPutBucketTaggingCommand = exports.serializeAws_restXmlPutBucketRequestPaymentCommand = exports.serializeAws_restXmlPutBucketReplicationCommand = exports.serializeAws_restXmlPutBucketPolicyCommand = exports.serializeAws_restXmlPutBucketOwnershipControlsCommand = exports.serializeAws_restXmlPutBucketNotificationConfigurationCommand = exports.serializeAws_restXmlPutBucketMetricsConfigurationCommand = exports.serializeAws_restXmlPutBucketLoggingCommand = exports.serializeAws_restXmlPutBucketLifecycleConfigurationCommand = exports.serializeAws_restXmlPutBucketInventoryConfigurationCommand = exports.serializeAws_restXmlPutBucketIntelligentTieringConfigurationCommand = exports.serializeAws_restXmlPutBucketEncryptionCommand = exports.serializeAws_restXmlPutBucketCorsCommand = exports.serializeAws_restXmlPutBucketAnalyticsConfigurationCommand = exports.serializeAws_restXmlPutBucketAclCommand = exports.serializeAws_restXmlPutBucketAccelerateConfigurationCommand = exports.serializeAws_restXmlListPartsCommand = exports.serializeAws_restXmlListObjectVersionsCommand = exports.serializeAws_restXmlListObjectsV2Command = exports.serializeAws_restXmlListObjectsCommand = exports.serializeAws_restXmlListMultipartUploadsCommand = exports.serializeAws_restXmlListBucketsCommand = exports.serializeAws_restXmlListBucketMetricsConfigurationsCommand = exports.serializeAws_restXmlListBucketInventoryConfigurationsCommand = exports.serializeAws_restXmlListBucketIntelligentTieringConfigurationsCommand = exports.serializeAws_restXmlListBucketAnalyticsConfigurationsCommand = exports.serializeAws_restXmlHeadObjectCommand = exports.serializeAws_restXmlHeadBucketCommand = exports.serializeAws_restXmlGetPublicAccessBlockCommand = void 0; | |
exports.deserializeAws_restXmlListBucketMetricsConfigurationsCommand = exports.deserializeAws_restXmlListBucketInventoryConfigurationsCommand = exports.deserializeAws_restXmlListBucketIntelligentTieringConfigurationsCommand = exports.deserializeAws_restXmlListBucketAnalyticsConfigurationsCommand = exports.deserializeAws_restXmlHeadObjectCommand = exports.deserializeAws_restXmlHeadBucketCommand = exports.deserializeAws_restXmlGetPublicAccessBlockCommand = exports.deserializeAws_restXmlGetObjectTorrentCommand = exports.deserializeAws_restXmlGetObjectTaggingCommand = exports.deserializeAws_restXmlGetObjectRetentionCommand = exports.deserializeAws_restXmlGetObjectLockConfigurationCommand = exports.deserializeAws_restXmlGetObjectLegalHoldCommand = exports.deserializeAws_restXmlGetObjectAttributesCommand = exports.deserializeAws_restXmlGetObjectAclCommand = exports.deserializeAws_restXmlGetObjectCommand = exports.deserializeAws_restXmlGetBucketWebsiteCommand = exports.deserializeAws_restXmlGetBucketVersioningCommand = exports.deserializeAws_restXmlGetBucketTaggingCommand = exports.deserializeAws_restXmlGetBucketRequestPaymentCommand = exports.deserializeAws_restXmlGetBucketReplicationCommand = exports.deserializeAws_restXmlGetBucketPolicyStatusCommand = exports.deserializeAws_restXmlGetBucketPolicyCommand = exports.deserializeAws_restXmlGetBucketOwnershipControlsCommand = exports.deserializeAws_restXmlGetBucketNotificationConfigurationCommand = exports.deserializeAws_restXmlGetBucketMetricsConfigurationCommand = exports.deserializeAws_restXmlGetBucketLoggingCommand = exports.deserializeAws_restXmlGetBucketLocationCommand = exports.deserializeAws_restXmlGetBucketLifecycleConfigurationCommand = exports.deserializeAws_restXmlGetBucketInventoryConfigurationCommand = exports.deserializeAws_restXmlGetBucketIntelligentTieringConfigurationCommand = exports.deserializeAws_restXmlGetBucketEncryptionCommand = exports.deserializeAws_restXmlGetBucketCorsCommand = exports.deserializeAws_restXmlGetBucketAnalyticsConfigurationCommand = exports.deserializeAws_restXmlGetBucketAclCommand = exports.deserializeAws_restXmlGetBucketAccelerateConfigurationCommand = exports.deserializeAws_restXmlDeletePublicAccessBlockCommand = exports.deserializeAws_restXmlDeleteObjectTaggingCommand = exports.deserializeAws_restXmlDeleteObjectsCommand = exports.deserializeAws_restXmlDeleteObjectCommand = exports.deserializeAws_restXmlDeleteBucketWebsiteCommand = exports.deserializeAws_restXmlDeleteBucketTaggingCommand = exports.deserializeAws_restXmlDeleteBucketReplicationCommand = exports.deserializeAws_restXmlDeleteBucketPolicyCommand = exports.deserializeAws_restXmlDeleteBucketOwnershipControlsCommand = exports.deserializeAws_restXmlDeleteBucketMetricsConfigurationCommand = exports.deserializeAws_restXmlDeleteBucketLifecycleCommand = exports.deserializeAws_restXmlDeleteBucketInventoryConfigurationCommand = exports.deserializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommand = exports.deserializeAws_restXmlDeleteBucketEncryptionCommand = exports.deserializeAws_restXmlDeleteBucketCorsCommand = void 0; | |
exports.deserializeAws_restXmlWriteGetObjectResponseCommand = exports.deserializeAws_restXmlUploadPartCopyCommand = exports.deserializeAws_restXmlUploadPartCommand = exports.deserializeAws_restXmlSelectObjectContentCommand = exports.deserializeAws_restXmlRestoreObjectCommand = exports.deserializeAws_restXmlPutPublicAccessBlockCommand = exports.deserializeAws_restXmlPutObjectTaggingCommand = exports.deserializeAws_restXmlPutObjectRetentionCommand = exports.deserializeAws_restXmlPutObjectLockConfigurationCommand = exports.deserializeAws_restXmlPutObjectLegalHoldCommand = exports.deserializeAws_restXmlPutObjectAclCommand = exports.deserializeAws_restXmlPutObjectCommand = exports.deserializeAws_restXmlPutBucketWebsiteCommand = exports.deserializeAws_restXmlPutBucketVersioningCommand = exports.deserializeAws_restXmlPutBucketTaggingCommand = exports.deserializeAws_restXmlPutBucketRequestPaymentCommand = exports.deserializeAws_restXmlPutBucketReplicationCommand = exports.deserializeAws_restXmlPutBucketPolicyCommand = exports.deserializeAws_restXmlPutBucketOwnershipControlsCommand = exports.deserializeAws_restXmlPutBucketNotificationConfigurationCommand = exports.deserializeAws_restXmlPutBucketMetricsConfigurationCommand = exports.deserializeAws_restXmlPutBucketLoggingCommand = exports.deserializeAws_restXmlPutBucketLifecycleConfigurationCommand = exports.deserializeAws_restXmlPutBucketInventoryConfigurationCommand = exports.deserializeAws_restXmlPutBucketIntelligentTieringConfigurationCommand = exports.deserializeAws_restXmlPutBucketEncryptionCommand = exports.deserializeAws_restXmlPutBucketCorsCommand = exports.deserializeAws_restXmlPutBucketAnalyticsConfigurationCommand = exports.deserializeAws_restXmlPutBucketAclCommand = exports.deserializeAws_restXmlPutBucketAccelerateConfigurationCommand = exports.deserializeAws_restXmlListPartsCommand = exports.deserializeAws_restXmlListObjectVersionsCommand = exports.deserializeAws_restXmlListObjectsV2Command = exports.deserializeAws_restXmlListObjectsCommand = exports.deserializeAws_restXmlListMultipartUploadsCommand = exports.deserializeAws_restXmlListBucketsCommand = void 0; | |
var protocol_http_1 = require_dist_cjs8(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var xml_builder_1 = require_dist_cjs9(); | |
var fast_xml_parser_1 = require_fxp(); | |
var models_0_1 = require_models_0(); | |
var models_1_1 = require_models_1(); | |
var S3ServiceException_1 = require_S3ServiceException(); | |
var serializeAws_restXmlAbortMultipartUploadCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-request-payer": input.RequestPayer, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true); | |
const query = map({ | |
"x-id": [, "AbortMultipartUpload"], | |
uploadId: [, (0, smithy_client_1.expectNonNull)(input.UploadId, `UploadId`)] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "DELETE", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlAbortMultipartUploadCommand = serializeAws_restXmlAbortMultipartUploadCommand; | |
var serializeAws_restXmlCompleteMultipartUploadCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/xml", | |
"x-amz-checksum-crc32": input.ChecksumCRC32, | |
"x-amz-checksum-crc32c": input.ChecksumCRC32C, | |
"x-amz-checksum-sha1": input.ChecksumSHA1, | |
"x-amz-checksum-sha256": input.ChecksumSHA256, | |
"x-amz-request-payer": input.RequestPayer, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner, | |
"x-amz-server-side-encryption-customer-algorithm": input.SSECustomerAlgorithm, | |
"x-amz-server-side-encryption-customer-key": input.SSECustomerKey, | |
"x-amz-server-side-encryption-customer-key-md5": input.SSECustomerKeyMD5 | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true); | |
const query = map({ | |
"x-id": [, "CompleteMultipartUpload"], | |
uploadId: [, (0, smithy_client_1.expectNonNull)(input.UploadId, `UploadId`)] | |
}); | |
let body; | |
if (input.MultipartUpload !== void 0) { | |
body = serializeAws_restXmlCompletedMultipartUpload(input.MultipartUpload, context); | |
} | |
let contents; | |
if (input.MultipartUpload !== void 0) { | |
contents = serializeAws_restXmlCompletedMultipartUpload(input.MultipartUpload, context); | |
contents = contents.withName("CompleteMultipartUpload"); | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
body += contents.toString(); | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "POST", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlCompleteMultipartUploadCommand = serializeAws_restXmlCompleteMultipartUploadCommand; | |
var serializeAws_restXmlCopyObjectCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-acl": input.ACL, | |
"cache-control": input.CacheControl, | |
"x-amz-checksum-algorithm": input.ChecksumAlgorithm, | |
"content-disposition": input.ContentDisposition, | |
"content-encoding": input.ContentEncoding, | |
"content-language": input.ContentLanguage, | |
"content-type": input.ContentType, | |
"x-amz-copy-source": input.CopySource, | |
"x-amz-copy-source-if-match": input.CopySourceIfMatch, | |
"x-amz-copy-source-if-modified-since": [ | |
() => isSerializableHeaderValue(input.CopySourceIfModifiedSince), | |
() => (0, smithy_client_1.dateToUtcString)(input.CopySourceIfModifiedSince).toString() | |
], | |
"x-amz-copy-source-if-none-match": input.CopySourceIfNoneMatch, | |
"x-amz-copy-source-if-unmodified-since": [ | |
() => isSerializableHeaderValue(input.CopySourceIfUnmodifiedSince), | |
() => (0, smithy_client_1.dateToUtcString)(input.CopySourceIfUnmodifiedSince).toString() | |
], | |
expires: [() => isSerializableHeaderValue(input.Expires), () => (0, smithy_client_1.dateToUtcString)(input.Expires).toString()], | |
"x-amz-grant-full-control": input.GrantFullControl, | |
"x-amz-grant-read": input.GrantRead, | |
"x-amz-grant-read-acp": input.GrantReadACP, | |
"x-amz-grant-write-acp": input.GrantWriteACP, | |
"x-amz-metadata-directive": input.MetadataDirective, | |
"x-amz-tagging-directive": input.TaggingDirective, | |
"x-amz-server-side-encryption": input.ServerSideEncryption, | |
"x-amz-storage-class": input.StorageClass, | |
"x-amz-website-redirect-location": input.WebsiteRedirectLocation, | |
"x-amz-server-side-encryption-customer-algorithm": input.SSECustomerAlgorithm, | |
"x-amz-server-side-encryption-customer-key": input.SSECustomerKey, | |
"x-amz-server-side-encryption-customer-key-md5": input.SSECustomerKeyMD5, | |
"x-amz-server-side-encryption-aws-kms-key-id": input.SSEKMSKeyId, | |
"x-amz-server-side-encryption-context": input.SSEKMSEncryptionContext, | |
"x-amz-server-side-encryption-bucket-key-enabled": [ | |
() => isSerializableHeaderValue(input.BucketKeyEnabled), | |
() => input.BucketKeyEnabled.toString() | |
], | |
"x-amz-copy-source-server-side-encryption-customer-algorithm": input.CopySourceSSECustomerAlgorithm, | |
"x-amz-copy-source-server-side-encryption-customer-key": input.CopySourceSSECustomerKey, | |
"x-amz-copy-source-server-side-encryption-customer-key-md5": input.CopySourceSSECustomerKeyMD5, | |
"x-amz-request-payer": input.RequestPayer, | |
"x-amz-tagging": input.Tagging, | |
"x-amz-object-lock-mode": input.ObjectLockMode, | |
"x-amz-object-lock-retain-until-date": [ | |
() => isSerializableHeaderValue(input.ObjectLockRetainUntilDate), | |
() => (input.ObjectLockRetainUntilDate.toISOString().split(".")[0] + "Z").toString() | |
], | |
"x-amz-object-lock-legal-hold": input.ObjectLockLegalHoldStatus, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner, | |
"x-amz-source-expected-bucket-owner": input.ExpectedSourceBucketOwner, | |
...input.Metadata !== void 0 && Object.keys(input.Metadata).reduce((acc, suffix) => { | |
acc[`x-amz-meta-${suffix.toLowerCase()}`] = input.Metadata[suffix]; | |
return acc; | |
}, {}) | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true); | |
const query = map({ | |
"x-id": [, "CopyObject"] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlCopyObjectCommand = serializeAws_restXmlCopyObjectCommand; | |
var serializeAws_restXmlCreateBucketCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/xml", | |
"x-amz-acl": input.ACL, | |
"x-amz-grant-full-control": input.GrantFullControl, | |
"x-amz-grant-read": input.GrantRead, | |
"x-amz-grant-read-acp": input.GrantReadACP, | |
"x-amz-grant-write": input.GrantWrite, | |
"x-amz-grant-write-acp": input.GrantWriteACP, | |
"x-amz-bucket-object-lock-enabled": [ | |
() => isSerializableHeaderValue(input.ObjectLockEnabledForBucket), | |
() => input.ObjectLockEnabledForBucket.toString() | |
], | |
"x-amz-object-ownership": input.ObjectOwnership | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
let body; | |
if (input.CreateBucketConfiguration !== void 0) { | |
body = serializeAws_restXmlCreateBucketConfiguration(input.CreateBucketConfiguration, context); | |
} | |
let contents; | |
if (input.CreateBucketConfiguration !== void 0) { | |
contents = serializeAws_restXmlCreateBucketConfiguration(input.CreateBucketConfiguration, context); | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
body += contents.toString(); | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlCreateBucketCommand = serializeAws_restXmlCreateBucketCommand; | |
var serializeAws_restXmlCreateMultipartUploadCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-acl": input.ACL, | |
"cache-control": input.CacheControl, | |
"content-disposition": input.ContentDisposition, | |
"content-encoding": input.ContentEncoding, | |
"content-language": input.ContentLanguage, | |
"content-type": input.ContentType, | |
expires: [() => isSerializableHeaderValue(input.Expires), () => (0, smithy_client_1.dateToUtcString)(input.Expires).toString()], | |
"x-amz-grant-full-control": input.GrantFullControl, | |
"x-amz-grant-read": input.GrantRead, | |
"x-amz-grant-read-acp": input.GrantReadACP, | |
"x-amz-grant-write-acp": input.GrantWriteACP, | |
"x-amz-server-side-encryption": input.ServerSideEncryption, | |
"x-amz-storage-class": input.StorageClass, | |
"x-amz-website-redirect-location": input.WebsiteRedirectLocation, | |
"x-amz-server-side-encryption-customer-algorithm": input.SSECustomerAlgorithm, | |
"x-amz-server-side-encryption-customer-key": input.SSECustomerKey, | |
"x-amz-server-side-encryption-customer-key-md5": input.SSECustomerKeyMD5, | |
"x-amz-server-side-encryption-aws-kms-key-id": input.SSEKMSKeyId, | |
"x-amz-server-side-encryption-context": input.SSEKMSEncryptionContext, | |
"x-amz-server-side-encryption-bucket-key-enabled": [ | |
() => isSerializableHeaderValue(input.BucketKeyEnabled), | |
() => input.BucketKeyEnabled.toString() | |
], | |
"x-amz-request-payer": input.RequestPayer, | |
"x-amz-tagging": input.Tagging, | |
"x-amz-object-lock-mode": input.ObjectLockMode, | |
"x-amz-object-lock-retain-until-date": [ | |
() => isSerializableHeaderValue(input.ObjectLockRetainUntilDate), | |
() => (input.ObjectLockRetainUntilDate.toISOString().split(".")[0] + "Z").toString() | |
], | |
"x-amz-object-lock-legal-hold": input.ObjectLockLegalHoldStatus, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner, | |
"x-amz-checksum-algorithm": input.ChecksumAlgorithm, | |
...input.Metadata !== void 0 && Object.keys(input.Metadata).reduce((acc, suffix) => { | |
acc[`x-amz-meta-${suffix.toLowerCase()}`] = input.Metadata[suffix]; | |
return acc; | |
}, {}) | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true); | |
const query = map({ | |
uploads: [, ""], | |
"x-id": [, "CreateMultipartUpload"] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "POST", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlCreateMultipartUploadCommand = serializeAws_restXmlCreateMultipartUploadCommand; | |
var serializeAws_restXmlDeleteBucketCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "DELETE", | |
headers, | |
path: resolvedPath, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlDeleteBucketCommand = serializeAws_restXmlDeleteBucketCommand; | |
var serializeAws_restXmlDeleteBucketAnalyticsConfigurationCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
analytics: [, ""], | |
id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "DELETE", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlDeleteBucketAnalyticsConfigurationCommand = serializeAws_restXmlDeleteBucketAnalyticsConfigurationCommand; | |
var serializeAws_restXmlDeleteBucketCorsCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
cors: [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "DELETE", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlDeleteBucketCorsCommand = serializeAws_restXmlDeleteBucketCorsCommand; | |
var serializeAws_restXmlDeleteBucketEncryptionCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
encryption: [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "DELETE", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlDeleteBucketEncryptionCommand = serializeAws_restXmlDeleteBucketEncryptionCommand; | |
var serializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = {}; | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
"intelligent-tiering": [, ""], | |
id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "DELETE", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommand = serializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommand; | |
var serializeAws_restXmlDeleteBucketInventoryConfigurationCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
inventory: [, ""], | |
id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "DELETE", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlDeleteBucketInventoryConfigurationCommand = serializeAws_restXmlDeleteBucketInventoryConfigurationCommand; | |
var serializeAws_restXmlDeleteBucketLifecycleCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
lifecycle: [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "DELETE", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlDeleteBucketLifecycleCommand = serializeAws_restXmlDeleteBucketLifecycleCommand; | |
var serializeAws_restXmlDeleteBucketMetricsConfigurationCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
metrics: [, ""], | |
id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "DELETE", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlDeleteBucketMetricsConfigurationCommand = serializeAws_restXmlDeleteBucketMetricsConfigurationCommand; | |
var serializeAws_restXmlDeleteBucketOwnershipControlsCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
ownershipControls: [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "DELETE", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlDeleteBucketOwnershipControlsCommand = serializeAws_restXmlDeleteBucketOwnershipControlsCommand; | |
var serializeAws_restXmlDeleteBucketPolicyCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
policy: [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "DELETE", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlDeleteBucketPolicyCommand = serializeAws_restXmlDeleteBucketPolicyCommand; | |
var serializeAws_restXmlDeleteBucketReplicationCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
replication: [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "DELETE", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlDeleteBucketReplicationCommand = serializeAws_restXmlDeleteBucketReplicationCommand; | |
var serializeAws_restXmlDeleteBucketTaggingCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
tagging: [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "DELETE", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlDeleteBucketTaggingCommand = serializeAws_restXmlDeleteBucketTaggingCommand; | |
var serializeAws_restXmlDeleteBucketWebsiteCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
website: [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "DELETE", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlDeleteBucketWebsiteCommand = serializeAws_restXmlDeleteBucketWebsiteCommand; | |
var serializeAws_restXmlDeleteObjectCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-mfa": input.MFA, | |
"x-amz-request-payer": input.RequestPayer, | |
"x-amz-bypass-governance-retention": [ | |
() => isSerializableHeaderValue(input.BypassGovernanceRetention), | |
() => input.BypassGovernanceRetention.toString() | |
], | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true); | |
const query = map({ | |
"x-id": [, "DeleteObject"], | |
versionId: [, input.VersionId] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "DELETE", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlDeleteObjectCommand = serializeAws_restXmlDeleteObjectCommand; | |
var serializeAws_restXmlDeleteObjectsCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/xml", | |
"x-amz-mfa": input.MFA, | |
"x-amz-request-payer": input.RequestPayer, | |
"x-amz-bypass-governance-retention": [ | |
() => isSerializableHeaderValue(input.BypassGovernanceRetention), | |
() => input.BypassGovernanceRetention.toString() | |
], | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner, | |
"x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
delete: [, ""], | |
"x-id": [, "DeleteObjects"] | |
}); | |
let body; | |
if (input.Delete !== void 0) { | |
body = serializeAws_restXmlDelete(input.Delete, context); | |
} | |
let contents; | |
if (input.Delete !== void 0) { | |
contents = serializeAws_restXmlDelete(input.Delete, context); | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
body += contents.toString(); | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "POST", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlDeleteObjectsCommand = serializeAws_restXmlDeleteObjectsCommand; | |
var serializeAws_restXmlDeleteObjectTaggingCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true); | |
const query = map({ | |
tagging: [, ""], | |
versionId: [, input.VersionId] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "DELETE", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlDeleteObjectTaggingCommand = serializeAws_restXmlDeleteObjectTaggingCommand; | |
var serializeAws_restXmlDeletePublicAccessBlockCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
publicAccessBlock: [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "DELETE", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlDeletePublicAccessBlockCommand = serializeAws_restXmlDeletePublicAccessBlockCommand; | |
var serializeAws_restXmlGetBucketAccelerateConfigurationCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
accelerate: [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetBucketAccelerateConfigurationCommand = serializeAws_restXmlGetBucketAccelerateConfigurationCommand; | |
var serializeAws_restXmlGetBucketAclCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
acl: [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetBucketAclCommand = serializeAws_restXmlGetBucketAclCommand; | |
var serializeAws_restXmlGetBucketAnalyticsConfigurationCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
analytics: [, ""], | |
"x-id": [, "GetBucketAnalyticsConfiguration"], | |
id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetBucketAnalyticsConfigurationCommand = serializeAws_restXmlGetBucketAnalyticsConfigurationCommand; | |
var serializeAws_restXmlGetBucketCorsCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
cors: [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetBucketCorsCommand = serializeAws_restXmlGetBucketCorsCommand; | |
var serializeAws_restXmlGetBucketEncryptionCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
encryption: [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetBucketEncryptionCommand = serializeAws_restXmlGetBucketEncryptionCommand; | |
var serializeAws_restXmlGetBucketIntelligentTieringConfigurationCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = {}; | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
"intelligent-tiering": [, ""], | |
"x-id": [, "GetBucketIntelligentTieringConfiguration"], | |
id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetBucketIntelligentTieringConfigurationCommand = serializeAws_restXmlGetBucketIntelligentTieringConfigurationCommand; | |
var serializeAws_restXmlGetBucketInventoryConfigurationCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
inventory: [, ""], | |
"x-id": [, "GetBucketInventoryConfiguration"], | |
id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetBucketInventoryConfigurationCommand = serializeAws_restXmlGetBucketInventoryConfigurationCommand; | |
var serializeAws_restXmlGetBucketLifecycleConfigurationCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
lifecycle: [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetBucketLifecycleConfigurationCommand = serializeAws_restXmlGetBucketLifecycleConfigurationCommand; | |
var serializeAws_restXmlGetBucketLocationCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
location: [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetBucketLocationCommand = serializeAws_restXmlGetBucketLocationCommand; | |
var serializeAws_restXmlGetBucketLoggingCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
logging: [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetBucketLoggingCommand = serializeAws_restXmlGetBucketLoggingCommand; | |
var serializeAws_restXmlGetBucketMetricsConfigurationCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
metrics: [, ""], | |
"x-id": [, "GetBucketMetricsConfiguration"], | |
id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetBucketMetricsConfigurationCommand = serializeAws_restXmlGetBucketMetricsConfigurationCommand; | |
var serializeAws_restXmlGetBucketNotificationConfigurationCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
notification: [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetBucketNotificationConfigurationCommand = serializeAws_restXmlGetBucketNotificationConfigurationCommand; | |
var serializeAws_restXmlGetBucketOwnershipControlsCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
ownershipControls: [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetBucketOwnershipControlsCommand = serializeAws_restXmlGetBucketOwnershipControlsCommand; | |
var serializeAws_restXmlGetBucketPolicyCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
policy: [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetBucketPolicyCommand = serializeAws_restXmlGetBucketPolicyCommand; | |
var serializeAws_restXmlGetBucketPolicyStatusCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
policyStatus: [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetBucketPolicyStatusCommand = serializeAws_restXmlGetBucketPolicyStatusCommand; | |
var serializeAws_restXmlGetBucketReplicationCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
replication: [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetBucketReplicationCommand = serializeAws_restXmlGetBucketReplicationCommand; | |
var serializeAws_restXmlGetBucketRequestPaymentCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
requestPayment: [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetBucketRequestPaymentCommand = serializeAws_restXmlGetBucketRequestPaymentCommand; | |
var serializeAws_restXmlGetBucketTaggingCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
tagging: [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetBucketTaggingCommand = serializeAws_restXmlGetBucketTaggingCommand; | |
var serializeAws_restXmlGetBucketVersioningCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
versioning: [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetBucketVersioningCommand = serializeAws_restXmlGetBucketVersioningCommand; | |
var serializeAws_restXmlGetBucketWebsiteCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
website: [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetBucketWebsiteCommand = serializeAws_restXmlGetBucketWebsiteCommand; | |
var serializeAws_restXmlGetObjectCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"if-match": input.IfMatch, | |
"if-modified-since": [ | |
() => isSerializableHeaderValue(input.IfModifiedSince), | |
() => (0, smithy_client_1.dateToUtcString)(input.IfModifiedSince).toString() | |
], | |
"if-none-match": input.IfNoneMatch, | |
"if-unmodified-since": [ | |
() => isSerializableHeaderValue(input.IfUnmodifiedSince), | |
() => (0, smithy_client_1.dateToUtcString)(input.IfUnmodifiedSince).toString() | |
], | |
range: input.Range, | |
"x-amz-server-side-encryption-customer-algorithm": input.SSECustomerAlgorithm, | |
"x-amz-server-side-encryption-customer-key": input.SSECustomerKey, | |
"x-amz-server-side-encryption-customer-key-md5": input.SSECustomerKeyMD5, | |
"x-amz-request-payer": input.RequestPayer, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner, | |
"x-amz-checksum-mode": input.ChecksumMode | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true); | |
const query = map({ | |
"x-id": [, "GetObject"], | |
"response-cache-control": [, input.ResponseCacheControl], | |
"response-content-disposition": [, input.ResponseContentDisposition], | |
"response-content-encoding": [, input.ResponseContentEncoding], | |
"response-content-language": [, input.ResponseContentLanguage], | |
"response-content-type": [, input.ResponseContentType], | |
"response-expires": [ | |
() => input.ResponseExpires !== void 0, | |
() => (0, smithy_client_1.dateToUtcString)(input.ResponseExpires).toString() | |
], | |
versionId: [, input.VersionId], | |
partNumber: [() => input.PartNumber !== void 0, () => input.PartNumber.toString()] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetObjectCommand = serializeAws_restXmlGetObjectCommand; | |
var serializeAws_restXmlGetObjectAclCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-request-payer": input.RequestPayer, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true); | |
const query = map({ | |
acl: [, ""], | |
versionId: [, input.VersionId] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetObjectAclCommand = serializeAws_restXmlGetObjectAclCommand; | |
var serializeAws_restXmlGetObjectAttributesCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-max-parts": [() => isSerializableHeaderValue(input.MaxParts), () => input.MaxParts.toString()], | |
"x-amz-part-number-marker": input.PartNumberMarker, | |
"x-amz-server-side-encryption-customer-algorithm": input.SSECustomerAlgorithm, | |
"x-amz-server-side-encryption-customer-key": input.SSECustomerKey, | |
"x-amz-server-side-encryption-customer-key-md5": input.SSECustomerKeyMD5, | |
"x-amz-request-payer": input.RequestPayer, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner, | |
"x-amz-object-attributes": [ | |
() => isSerializableHeaderValue(input.ObjectAttributes), | |
() => (input.ObjectAttributes || []).map((_entry) => _entry).join(", ") | |
] | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true); | |
const query = map({ | |
attributes: [, ""], | |
versionId: [, input.VersionId] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetObjectAttributesCommand = serializeAws_restXmlGetObjectAttributesCommand; | |
var serializeAws_restXmlGetObjectLegalHoldCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-request-payer": input.RequestPayer, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true); | |
const query = map({ | |
"legal-hold": [, ""], | |
versionId: [, input.VersionId] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetObjectLegalHoldCommand = serializeAws_restXmlGetObjectLegalHoldCommand; | |
var serializeAws_restXmlGetObjectLockConfigurationCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
"object-lock": [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetObjectLockConfigurationCommand = serializeAws_restXmlGetObjectLockConfigurationCommand; | |
var serializeAws_restXmlGetObjectRetentionCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-request-payer": input.RequestPayer, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true); | |
const query = map({ | |
retention: [, ""], | |
versionId: [, input.VersionId] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetObjectRetentionCommand = serializeAws_restXmlGetObjectRetentionCommand; | |
var serializeAws_restXmlGetObjectTaggingCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner, | |
"x-amz-request-payer": input.RequestPayer | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true); | |
const query = map({ | |
tagging: [, ""], | |
versionId: [, input.VersionId] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetObjectTaggingCommand = serializeAws_restXmlGetObjectTaggingCommand; | |
var serializeAws_restXmlGetObjectTorrentCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-request-payer": input.RequestPayer, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true); | |
const query = map({ | |
torrent: [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetObjectTorrentCommand = serializeAws_restXmlGetObjectTorrentCommand; | |
var serializeAws_restXmlGetPublicAccessBlockCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
publicAccessBlock: [, ""] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlGetPublicAccessBlockCommand = serializeAws_restXmlGetPublicAccessBlockCommand; | |
var serializeAws_restXmlHeadBucketCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "HEAD", | |
headers, | |
path: resolvedPath, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlHeadBucketCommand = serializeAws_restXmlHeadBucketCommand; | |
var serializeAws_restXmlHeadObjectCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"if-match": input.IfMatch, | |
"if-modified-since": [ | |
() => isSerializableHeaderValue(input.IfModifiedSince), | |
() => (0, smithy_client_1.dateToUtcString)(input.IfModifiedSince).toString() | |
], | |
"if-none-match": input.IfNoneMatch, | |
"if-unmodified-since": [ | |
() => isSerializableHeaderValue(input.IfUnmodifiedSince), | |
() => (0, smithy_client_1.dateToUtcString)(input.IfUnmodifiedSince).toString() | |
], | |
range: input.Range, | |
"x-amz-server-side-encryption-customer-algorithm": input.SSECustomerAlgorithm, | |
"x-amz-server-side-encryption-customer-key": input.SSECustomerKey, | |
"x-amz-server-side-encryption-customer-key-md5": input.SSECustomerKeyMD5, | |
"x-amz-request-payer": input.RequestPayer, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner, | |
"x-amz-checksum-mode": input.ChecksumMode | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true); | |
const query = map({ | |
versionId: [, input.VersionId], | |
partNumber: [() => input.PartNumber !== void 0, () => input.PartNumber.toString()] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "HEAD", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlHeadObjectCommand = serializeAws_restXmlHeadObjectCommand; | |
var serializeAws_restXmlListBucketAnalyticsConfigurationsCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
analytics: [, ""], | |
"x-id": [, "ListBucketAnalyticsConfigurations"], | |
"continuation-token": [, input.ContinuationToken] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlListBucketAnalyticsConfigurationsCommand = serializeAws_restXmlListBucketAnalyticsConfigurationsCommand; | |
var serializeAws_restXmlListBucketIntelligentTieringConfigurationsCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = {}; | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
"intelligent-tiering": [, ""], | |
"x-id": [, "ListBucketIntelligentTieringConfigurations"], | |
"continuation-token": [, input.ContinuationToken] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlListBucketIntelligentTieringConfigurationsCommand = serializeAws_restXmlListBucketIntelligentTieringConfigurationsCommand; | |
var serializeAws_restXmlListBucketInventoryConfigurationsCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
inventory: [, ""], | |
"x-id": [, "ListBucketInventoryConfigurations"], | |
"continuation-token": [, input.ContinuationToken] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlListBucketInventoryConfigurationsCommand = serializeAws_restXmlListBucketInventoryConfigurationsCommand; | |
var serializeAws_restXmlListBucketMetricsConfigurationsCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
metrics: [, ""], | |
"x-id": [, "ListBucketMetricsConfigurations"], | |
"continuation-token": [, input.ContinuationToken] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlListBucketMetricsConfigurationsCommand = serializeAws_restXmlListBucketMetricsConfigurationsCommand; | |
var serializeAws_restXmlListBucketsCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = { | |
"content-type": "application/xml" | |
}; | |
const resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
let body; | |
body = ""; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlListBucketsCommand = serializeAws_restXmlListBucketsCommand; | |
var serializeAws_restXmlListMultipartUploadsCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
uploads: [, ""], | |
delimiter: [, input.Delimiter], | |
"encoding-type": [, input.EncodingType], | |
"key-marker": [, input.KeyMarker], | |
"max-uploads": [() => input.MaxUploads !== void 0, () => input.MaxUploads.toString()], | |
prefix: [, input.Prefix], | |
"upload-id-marker": [, input.UploadIdMarker] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlListMultipartUploadsCommand = serializeAws_restXmlListMultipartUploadsCommand; | |
var serializeAws_restXmlListObjectsCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-request-payer": input.RequestPayer, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
delimiter: [, input.Delimiter], | |
"encoding-type": [, input.EncodingType], | |
marker: [, input.Marker], | |
"max-keys": [() => input.MaxKeys !== void 0, () => input.MaxKeys.toString()], | |
prefix: [, input.Prefix] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlListObjectsCommand = serializeAws_restXmlListObjectsCommand; | |
var serializeAws_restXmlListObjectsV2Command = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-request-payer": input.RequestPayer, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
"list-type": [, "2"], | |
delimiter: [, input.Delimiter], | |
"encoding-type": [, input.EncodingType], | |
"max-keys": [() => input.MaxKeys !== void 0, () => input.MaxKeys.toString()], | |
prefix: [, input.Prefix], | |
"continuation-token": [, input.ContinuationToken], | |
"fetch-owner": [() => input.FetchOwner !== void 0, () => input.FetchOwner.toString()], | |
"start-after": [, input.StartAfter] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlListObjectsV2Command = serializeAws_restXmlListObjectsV2Command; | |
var serializeAws_restXmlListObjectVersionsCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
versions: [, ""], | |
delimiter: [, input.Delimiter], | |
"encoding-type": [, input.EncodingType], | |
"key-marker": [, input.KeyMarker], | |
"max-keys": [() => input.MaxKeys !== void 0, () => input.MaxKeys.toString()], | |
prefix: [, input.Prefix], | |
"version-id-marker": [, input.VersionIdMarker] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlListObjectVersionsCommand = serializeAws_restXmlListObjectVersionsCommand; | |
var serializeAws_restXmlListPartsCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-request-payer": input.RequestPayer, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner, | |
"x-amz-server-side-encryption-customer-algorithm": input.SSECustomerAlgorithm, | |
"x-amz-server-side-encryption-customer-key": input.SSECustomerKey, | |
"x-amz-server-side-encryption-customer-key-md5": input.SSECustomerKeyMD5 | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true); | |
const query = map({ | |
"x-id": [, "ListParts"], | |
"max-parts": [() => input.MaxParts !== void 0, () => input.MaxParts.toString()], | |
"part-number-marker": [, input.PartNumberMarker], | |
uploadId: [, (0, smithy_client_1.expectNonNull)(input.UploadId, `UploadId`)] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "GET", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlListPartsCommand = serializeAws_restXmlListPartsCommand; | |
var serializeAws_restXmlPutBucketAccelerateConfigurationCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/xml", | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner, | |
"x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
accelerate: [, ""] | |
}); | |
let body; | |
if (input.AccelerateConfiguration !== void 0) { | |
body = serializeAws_restXmlAccelerateConfiguration(input.AccelerateConfiguration, context); | |
} | |
let contents; | |
if (input.AccelerateConfiguration !== void 0) { | |
contents = serializeAws_restXmlAccelerateConfiguration(input.AccelerateConfiguration, context); | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
body += contents.toString(); | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlPutBucketAccelerateConfigurationCommand = serializeAws_restXmlPutBucketAccelerateConfigurationCommand; | |
var serializeAws_restXmlPutBucketAclCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/xml", | |
"x-amz-acl": input.ACL, | |
"content-md5": input.ContentMD5, | |
"x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm, | |
"x-amz-grant-full-control": input.GrantFullControl, | |
"x-amz-grant-read": input.GrantRead, | |
"x-amz-grant-read-acp": input.GrantReadACP, | |
"x-amz-grant-write": input.GrantWrite, | |
"x-amz-grant-write-acp": input.GrantWriteACP, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
acl: [, ""] | |
}); | |
let body; | |
if (input.AccessControlPolicy !== void 0) { | |
body = serializeAws_restXmlAccessControlPolicy(input.AccessControlPolicy, context); | |
} | |
let contents; | |
if (input.AccessControlPolicy !== void 0) { | |
contents = serializeAws_restXmlAccessControlPolicy(input.AccessControlPolicy, context); | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
body += contents.toString(); | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlPutBucketAclCommand = serializeAws_restXmlPutBucketAclCommand; | |
var serializeAws_restXmlPutBucketAnalyticsConfigurationCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/xml", | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
analytics: [, ""], | |
id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)] | |
}); | |
let body; | |
if (input.AnalyticsConfiguration !== void 0) { | |
body = serializeAws_restXmlAnalyticsConfiguration(input.AnalyticsConfiguration, context); | |
} | |
let contents; | |
if (input.AnalyticsConfiguration !== void 0) { | |
contents = serializeAws_restXmlAnalyticsConfiguration(input.AnalyticsConfiguration, context); | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
body += contents.toString(); | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlPutBucketAnalyticsConfigurationCommand = serializeAws_restXmlPutBucketAnalyticsConfigurationCommand; | |
var serializeAws_restXmlPutBucketCorsCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/xml", | |
"content-md5": input.ContentMD5, | |
"x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
cors: [, ""] | |
}); | |
let body; | |
if (input.CORSConfiguration !== void 0) { | |
body = serializeAws_restXmlCORSConfiguration(input.CORSConfiguration, context); | |
} | |
let contents; | |
if (input.CORSConfiguration !== void 0) { | |
contents = serializeAws_restXmlCORSConfiguration(input.CORSConfiguration, context); | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
body += contents.toString(); | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlPutBucketCorsCommand = serializeAws_restXmlPutBucketCorsCommand; | |
var serializeAws_restXmlPutBucketEncryptionCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/xml", | |
"content-md5": input.ContentMD5, | |
"x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
encryption: [, ""] | |
}); | |
let body; | |
if (input.ServerSideEncryptionConfiguration !== void 0) { | |
body = serializeAws_restXmlServerSideEncryptionConfiguration(input.ServerSideEncryptionConfiguration, context); | |
} | |
let contents; | |
if (input.ServerSideEncryptionConfiguration !== void 0) { | |
contents = serializeAws_restXmlServerSideEncryptionConfiguration(input.ServerSideEncryptionConfiguration, context); | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
body += contents.toString(); | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlPutBucketEncryptionCommand = serializeAws_restXmlPutBucketEncryptionCommand; | |
var serializeAws_restXmlPutBucketIntelligentTieringConfigurationCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = { | |
"content-type": "application/xml" | |
}; | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
"intelligent-tiering": [, ""], | |
id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)] | |
}); | |
let body; | |
if (input.IntelligentTieringConfiguration !== void 0) { | |
body = serializeAws_restXmlIntelligentTieringConfiguration(input.IntelligentTieringConfiguration, context); | |
} | |
let contents; | |
if (input.IntelligentTieringConfiguration !== void 0) { | |
contents = serializeAws_restXmlIntelligentTieringConfiguration(input.IntelligentTieringConfiguration, context); | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
body += contents.toString(); | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlPutBucketIntelligentTieringConfigurationCommand = serializeAws_restXmlPutBucketIntelligentTieringConfigurationCommand; | |
var serializeAws_restXmlPutBucketInventoryConfigurationCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/xml", | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
inventory: [, ""], | |
id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)] | |
}); | |
let body; | |
if (input.InventoryConfiguration !== void 0) { | |
body = serializeAws_restXmlInventoryConfiguration(input.InventoryConfiguration, context); | |
} | |
let contents; | |
if (input.InventoryConfiguration !== void 0) { | |
contents = serializeAws_restXmlInventoryConfiguration(input.InventoryConfiguration, context); | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
body += contents.toString(); | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlPutBucketInventoryConfigurationCommand = serializeAws_restXmlPutBucketInventoryConfigurationCommand; | |
var serializeAws_restXmlPutBucketLifecycleConfigurationCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/xml", | |
"x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
lifecycle: [, ""] | |
}); | |
let body; | |
if (input.LifecycleConfiguration !== void 0) { | |
body = serializeAws_restXmlBucketLifecycleConfiguration(input.LifecycleConfiguration, context); | |
} | |
let contents; | |
if (input.LifecycleConfiguration !== void 0) { | |
contents = serializeAws_restXmlBucketLifecycleConfiguration(input.LifecycleConfiguration, context); | |
contents = contents.withName("LifecycleConfiguration"); | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
body += contents.toString(); | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlPutBucketLifecycleConfigurationCommand = serializeAws_restXmlPutBucketLifecycleConfigurationCommand; | |
var serializeAws_restXmlPutBucketLoggingCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/xml", | |
"content-md5": input.ContentMD5, | |
"x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
logging: [, ""] | |
}); | |
let body; | |
if (input.BucketLoggingStatus !== void 0) { | |
body = serializeAws_restXmlBucketLoggingStatus(input.BucketLoggingStatus, context); | |
} | |
let contents; | |
if (input.BucketLoggingStatus !== void 0) { | |
contents = serializeAws_restXmlBucketLoggingStatus(input.BucketLoggingStatus, context); | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
body += contents.toString(); | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlPutBucketLoggingCommand = serializeAws_restXmlPutBucketLoggingCommand; | |
var serializeAws_restXmlPutBucketMetricsConfigurationCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/xml", | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
metrics: [, ""], | |
id: [, (0, smithy_client_1.expectNonNull)(input.Id, `Id`)] | |
}); | |
let body; | |
if (input.MetricsConfiguration !== void 0) { | |
body = serializeAws_restXmlMetricsConfiguration(input.MetricsConfiguration, context); | |
} | |
let contents; | |
if (input.MetricsConfiguration !== void 0) { | |
contents = serializeAws_restXmlMetricsConfiguration(input.MetricsConfiguration, context); | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
body += contents.toString(); | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlPutBucketMetricsConfigurationCommand = serializeAws_restXmlPutBucketMetricsConfigurationCommand; | |
var serializeAws_restXmlPutBucketNotificationConfigurationCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/xml", | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner, | |
"x-amz-skip-destination-validation": [ | |
() => isSerializableHeaderValue(input.SkipDestinationValidation), | |
() => input.SkipDestinationValidation.toString() | |
] | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
notification: [, ""] | |
}); | |
let body; | |
if (input.NotificationConfiguration !== void 0) { | |
body = serializeAws_restXmlNotificationConfiguration(input.NotificationConfiguration, context); | |
} | |
let contents; | |
if (input.NotificationConfiguration !== void 0) { | |
contents = serializeAws_restXmlNotificationConfiguration(input.NotificationConfiguration, context); | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
body += contents.toString(); | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlPutBucketNotificationConfigurationCommand = serializeAws_restXmlPutBucketNotificationConfigurationCommand; | |
var serializeAws_restXmlPutBucketOwnershipControlsCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/xml", | |
"content-md5": input.ContentMD5, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
ownershipControls: [, ""] | |
}); | |
let body; | |
if (input.OwnershipControls !== void 0) { | |
body = serializeAws_restXmlOwnershipControls(input.OwnershipControls, context); | |
} | |
let contents; | |
if (input.OwnershipControls !== void 0) { | |
contents = serializeAws_restXmlOwnershipControls(input.OwnershipControls, context); | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
body += contents.toString(); | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlPutBucketOwnershipControlsCommand = serializeAws_restXmlPutBucketOwnershipControlsCommand; | |
var serializeAws_restXmlPutBucketPolicyCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "text/plain", | |
"content-md5": input.ContentMD5, | |
"x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm, | |
"x-amz-confirm-remove-self-bucket-access": [ | |
() => isSerializableHeaderValue(input.ConfirmRemoveSelfBucketAccess), | |
() => input.ConfirmRemoveSelfBucketAccess.toString() | |
], | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
policy: [, ""] | |
}); | |
let body; | |
if (input.Policy !== void 0) { | |
body = input.Policy; | |
} | |
let contents; | |
if (input.Policy !== void 0) { | |
contents = input.Policy; | |
body = contents; | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlPutBucketPolicyCommand = serializeAws_restXmlPutBucketPolicyCommand; | |
var serializeAws_restXmlPutBucketReplicationCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/xml", | |
"content-md5": input.ContentMD5, | |
"x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm, | |
"x-amz-bucket-object-lock-token": input.Token, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
replication: [, ""] | |
}); | |
let body; | |
if (input.ReplicationConfiguration !== void 0) { | |
body = serializeAws_restXmlReplicationConfiguration(input.ReplicationConfiguration, context); | |
} | |
let contents; | |
if (input.ReplicationConfiguration !== void 0) { | |
contents = serializeAws_restXmlReplicationConfiguration(input.ReplicationConfiguration, context); | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
body += contents.toString(); | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlPutBucketReplicationCommand = serializeAws_restXmlPutBucketReplicationCommand; | |
var serializeAws_restXmlPutBucketRequestPaymentCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/xml", | |
"content-md5": input.ContentMD5, | |
"x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
requestPayment: [, ""] | |
}); | |
let body; | |
if (input.RequestPaymentConfiguration !== void 0) { | |
body = serializeAws_restXmlRequestPaymentConfiguration(input.RequestPaymentConfiguration, context); | |
} | |
let contents; | |
if (input.RequestPaymentConfiguration !== void 0) { | |
contents = serializeAws_restXmlRequestPaymentConfiguration(input.RequestPaymentConfiguration, context); | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
body += contents.toString(); | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlPutBucketRequestPaymentCommand = serializeAws_restXmlPutBucketRequestPaymentCommand; | |
var serializeAws_restXmlPutBucketTaggingCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/xml", | |
"content-md5": input.ContentMD5, | |
"x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
tagging: [, ""] | |
}); | |
let body; | |
if (input.Tagging !== void 0) { | |
body = serializeAws_restXmlTagging(input.Tagging, context); | |
} | |
let contents; | |
if (input.Tagging !== void 0) { | |
contents = serializeAws_restXmlTagging(input.Tagging, context); | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
body += contents.toString(); | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlPutBucketTaggingCommand = serializeAws_restXmlPutBucketTaggingCommand; | |
var serializeAws_restXmlPutBucketVersioningCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/xml", | |
"content-md5": input.ContentMD5, | |
"x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm, | |
"x-amz-mfa": input.MFA, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
versioning: [, ""] | |
}); | |
let body; | |
if (input.VersioningConfiguration !== void 0) { | |
body = serializeAws_restXmlVersioningConfiguration(input.VersioningConfiguration, context); | |
} | |
let contents; | |
if (input.VersioningConfiguration !== void 0) { | |
contents = serializeAws_restXmlVersioningConfiguration(input.VersioningConfiguration, context); | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
body += contents.toString(); | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlPutBucketVersioningCommand = serializeAws_restXmlPutBucketVersioningCommand; | |
var serializeAws_restXmlPutBucketWebsiteCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/xml", | |
"content-md5": input.ContentMD5, | |
"x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
website: [, ""] | |
}); | |
let body; | |
if (input.WebsiteConfiguration !== void 0) { | |
body = serializeAws_restXmlWebsiteConfiguration(input.WebsiteConfiguration, context); | |
} | |
let contents; | |
if (input.WebsiteConfiguration !== void 0) { | |
contents = serializeAws_restXmlWebsiteConfiguration(input.WebsiteConfiguration, context); | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
body += contents.toString(); | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlPutBucketWebsiteCommand = serializeAws_restXmlPutBucketWebsiteCommand; | |
var serializeAws_restXmlPutObjectCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": input.ContentType || "application/octet-stream", | |
"x-amz-acl": input.ACL, | |
"cache-control": input.CacheControl, | |
"content-disposition": input.ContentDisposition, | |
"content-encoding": input.ContentEncoding, | |
"content-language": input.ContentLanguage, | |
"content-length": [() => isSerializableHeaderValue(input.ContentLength), () => input.ContentLength.toString()], | |
"content-md5": input.ContentMD5, | |
"x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm, | |
"x-amz-checksum-crc32": input.ChecksumCRC32, | |
"x-amz-checksum-crc32c": input.ChecksumCRC32C, | |
"x-amz-checksum-sha1": input.ChecksumSHA1, | |
"x-amz-checksum-sha256": input.ChecksumSHA256, | |
expires: [() => isSerializableHeaderValue(input.Expires), () => (0, smithy_client_1.dateToUtcString)(input.Expires).toString()], | |
"x-amz-grant-full-control": input.GrantFullControl, | |
"x-amz-grant-read": input.GrantRead, | |
"x-amz-grant-read-acp": input.GrantReadACP, | |
"x-amz-grant-write-acp": input.GrantWriteACP, | |
"x-amz-server-side-encryption": input.ServerSideEncryption, | |
"x-amz-storage-class": input.StorageClass, | |
"x-amz-website-redirect-location": input.WebsiteRedirectLocation, | |
"x-amz-server-side-encryption-customer-algorithm": input.SSECustomerAlgorithm, | |
"x-amz-server-side-encryption-customer-key": input.SSECustomerKey, | |
"x-amz-server-side-encryption-customer-key-md5": input.SSECustomerKeyMD5, | |
"x-amz-server-side-encryption-aws-kms-key-id": input.SSEKMSKeyId, | |
"x-amz-server-side-encryption-context": input.SSEKMSEncryptionContext, | |
"x-amz-server-side-encryption-bucket-key-enabled": [ | |
() => isSerializableHeaderValue(input.BucketKeyEnabled), | |
() => input.BucketKeyEnabled.toString() | |
], | |
"x-amz-request-payer": input.RequestPayer, | |
"x-amz-tagging": input.Tagging, | |
"x-amz-object-lock-mode": input.ObjectLockMode, | |
"x-amz-object-lock-retain-until-date": [ | |
() => isSerializableHeaderValue(input.ObjectLockRetainUntilDate), | |
() => (input.ObjectLockRetainUntilDate.toISOString().split(".")[0] + "Z").toString() | |
], | |
"x-amz-object-lock-legal-hold": input.ObjectLockLegalHoldStatus, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner, | |
...input.Metadata !== void 0 && Object.keys(input.Metadata).reduce((acc, suffix) => { | |
acc[`x-amz-meta-${suffix.toLowerCase()}`] = input.Metadata[suffix]; | |
return acc; | |
}, {}) | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true); | |
const query = map({ | |
"x-id": [, "PutObject"] | |
}); | |
let body; | |
if (input.Body !== void 0) { | |
body = input.Body; | |
} | |
let contents; | |
if (input.Body !== void 0) { | |
contents = input.Body; | |
body = contents; | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlPutObjectCommand = serializeAws_restXmlPutObjectCommand; | |
var serializeAws_restXmlPutObjectAclCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/xml", | |
"x-amz-acl": input.ACL, | |
"content-md5": input.ContentMD5, | |
"x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm, | |
"x-amz-grant-full-control": input.GrantFullControl, | |
"x-amz-grant-read": input.GrantRead, | |
"x-amz-grant-read-acp": input.GrantReadACP, | |
"x-amz-grant-write": input.GrantWrite, | |
"x-amz-grant-write-acp": input.GrantWriteACP, | |
"x-amz-request-payer": input.RequestPayer, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true); | |
const query = map({ | |
acl: [, ""], | |
versionId: [, input.VersionId] | |
}); | |
let body; | |
if (input.AccessControlPolicy !== void 0) { | |
body = serializeAws_restXmlAccessControlPolicy(input.AccessControlPolicy, context); | |
} | |
let contents; | |
if (input.AccessControlPolicy !== void 0) { | |
contents = serializeAws_restXmlAccessControlPolicy(input.AccessControlPolicy, context); | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
body += contents.toString(); | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlPutObjectAclCommand = serializeAws_restXmlPutObjectAclCommand; | |
var serializeAws_restXmlPutObjectLegalHoldCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/xml", | |
"x-amz-request-payer": input.RequestPayer, | |
"content-md5": input.ContentMD5, | |
"x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true); | |
const query = map({ | |
"legal-hold": [, ""], | |
versionId: [, input.VersionId] | |
}); | |
let body; | |
if (input.LegalHold !== void 0) { | |
body = serializeAws_restXmlObjectLockLegalHold(input.LegalHold, context); | |
} | |
let contents; | |
if (input.LegalHold !== void 0) { | |
contents = serializeAws_restXmlObjectLockLegalHold(input.LegalHold, context); | |
contents = contents.withName("LegalHold"); | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
body += contents.toString(); | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlPutObjectLegalHoldCommand = serializeAws_restXmlPutObjectLegalHoldCommand; | |
var serializeAws_restXmlPutObjectLockConfigurationCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/xml", | |
"x-amz-request-payer": input.RequestPayer, | |
"x-amz-bucket-object-lock-token": input.Token, | |
"content-md5": input.ContentMD5, | |
"x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
"object-lock": [, ""] | |
}); | |
let body; | |
if (input.ObjectLockConfiguration !== void 0) { | |
body = serializeAws_restXmlObjectLockConfiguration(input.ObjectLockConfiguration, context); | |
} | |
let contents; | |
if (input.ObjectLockConfiguration !== void 0) { | |
contents = serializeAws_restXmlObjectLockConfiguration(input.ObjectLockConfiguration, context); | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
body += contents.toString(); | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlPutObjectLockConfigurationCommand = serializeAws_restXmlPutObjectLockConfigurationCommand; | |
var serializeAws_restXmlPutObjectRetentionCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/xml", | |
"x-amz-request-payer": input.RequestPayer, | |
"x-amz-bypass-governance-retention": [ | |
() => isSerializableHeaderValue(input.BypassGovernanceRetention), | |
() => input.BypassGovernanceRetention.toString() | |
], | |
"content-md5": input.ContentMD5, | |
"x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true); | |
const query = map({ | |
retention: [, ""], | |
versionId: [, input.VersionId] | |
}); | |
let body; | |
if (input.Retention !== void 0) { | |
body = serializeAws_restXmlObjectLockRetention(input.Retention, context); | |
} | |
let contents; | |
if (input.Retention !== void 0) { | |
contents = serializeAws_restXmlObjectLockRetention(input.Retention, context); | |
contents = contents.withName("Retention"); | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
body += contents.toString(); | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlPutObjectRetentionCommand = serializeAws_restXmlPutObjectRetentionCommand; | |
var serializeAws_restXmlPutObjectTaggingCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/xml", | |
"content-md5": input.ContentMD5, | |
"x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner, | |
"x-amz-request-payer": input.RequestPayer | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true); | |
const query = map({ | |
tagging: [, ""], | |
versionId: [, input.VersionId] | |
}); | |
let body; | |
if (input.Tagging !== void 0) { | |
body = serializeAws_restXmlTagging(input.Tagging, context); | |
} | |
let contents; | |
if (input.Tagging !== void 0) { | |
contents = serializeAws_restXmlTagging(input.Tagging, context); | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
body += contents.toString(); | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlPutObjectTaggingCommand = serializeAws_restXmlPutObjectTaggingCommand; | |
var serializeAws_restXmlPutPublicAccessBlockCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/xml", | |
"content-md5": input.ContentMD5, | |
"x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
const query = map({ | |
publicAccessBlock: [, ""] | |
}); | |
let body; | |
if (input.PublicAccessBlockConfiguration !== void 0) { | |
body = serializeAws_restXmlPublicAccessBlockConfiguration(input.PublicAccessBlockConfiguration, context); | |
} | |
let contents; | |
if (input.PublicAccessBlockConfiguration !== void 0) { | |
contents = serializeAws_restXmlPublicAccessBlockConfiguration(input.PublicAccessBlockConfiguration, context); | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
body += contents.toString(); | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlPutPublicAccessBlockCommand = serializeAws_restXmlPutPublicAccessBlockCommand; | |
var serializeAws_restXmlRestoreObjectCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/xml", | |
"x-amz-request-payer": input.RequestPayer, | |
"x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true); | |
const query = map({ | |
restore: [, ""], | |
"x-id": [, "RestoreObject"], | |
versionId: [, input.VersionId] | |
}); | |
let body; | |
if (input.RestoreRequest !== void 0) { | |
body = serializeAws_restXmlRestoreRequest(input.RestoreRequest, context); | |
} | |
let contents; | |
if (input.RestoreRequest !== void 0) { | |
contents = serializeAws_restXmlRestoreRequest(input.RestoreRequest, context); | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
contents.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
body += contents.toString(); | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "POST", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlRestoreObjectCommand = serializeAws_restXmlRestoreObjectCommand; | |
var serializeAws_restXmlSelectObjectContentCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/xml", | |
"x-amz-server-side-encryption-customer-algorithm": input.SSECustomerAlgorithm, | |
"x-amz-server-side-encryption-customer-key": input.SSECustomerKey, | |
"x-amz-server-side-encryption-customer-key-md5": input.SSECustomerKeyMD5, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true); | |
const query = map({ | |
select: [, ""], | |
"select-type": [, "2"], | |
"x-id": [, "SelectObjectContent"] | |
}); | |
let body; | |
body = '<?xml version="1.0" encoding="UTF-8"?>'; | |
const bodyNode = new xml_builder_1.XmlNode("SelectObjectContentRequest"); | |
bodyNode.addAttribute("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/"); | |
if (input.Expression !== void 0) { | |
const node = xml_builder_1.XmlNode.of("Expression", input.Expression).withName("Expression"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.ExpressionType !== void 0) { | |
const node = xml_builder_1.XmlNode.of("ExpressionType", input.ExpressionType).withName("ExpressionType"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.InputSerialization !== void 0) { | |
const node = serializeAws_restXmlInputSerialization(input.InputSerialization, context).withName("InputSerialization"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.OutputSerialization !== void 0) { | |
const node = serializeAws_restXmlOutputSerialization(input.OutputSerialization, context).withName("OutputSerialization"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.RequestProgress !== void 0) { | |
const node = serializeAws_restXmlRequestProgress(input.RequestProgress, context).withName("RequestProgress"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.ScanRange !== void 0) { | |
const node = serializeAws_restXmlScanRange(input.ScanRange, context).withName("ScanRange"); | |
bodyNode.addChildNode(node); | |
} | |
body += bodyNode.toString(); | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "POST", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlSelectObjectContentCommand = serializeAws_restXmlSelectObjectContentCommand; | |
var serializeAws_restXmlUploadPartCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"content-type": "application/octet-stream", | |
"content-length": [() => isSerializableHeaderValue(input.ContentLength), () => input.ContentLength.toString()], | |
"content-md5": input.ContentMD5, | |
"x-amz-sdk-checksum-algorithm": input.ChecksumAlgorithm, | |
"x-amz-checksum-crc32": input.ChecksumCRC32, | |
"x-amz-checksum-crc32c": input.ChecksumCRC32C, | |
"x-amz-checksum-sha1": input.ChecksumSHA1, | |
"x-amz-checksum-sha256": input.ChecksumSHA256, | |
"x-amz-server-side-encryption-customer-algorithm": input.SSECustomerAlgorithm, | |
"x-amz-server-side-encryption-customer-key": input.SSECustomerKey, | |
"x-amz-server-side-encryption-customer-key-md5": input.SSECustomerKeyMD5, | |
"x-amz-request-payer": input.RequestPayer, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true); | |
const query = map({ | |
"x-id": [, "UploadPart"], | |
partNumber: [(0, smithy_client_1.expectNonNull)(input.PartNumber, `PartNumber`) != null, () => input.PartNumber.toString()], | |
uploadId: [, (0, smithy_client_1.expectNonNull)(input.UploadId, `UploadId`)] | |
}); | |
let body; | |
if (input.Body !== void 0) { | |
body = input.Body; | |
} | |
let contents; | |
if (input.Body !== void 0) { | |
contents = input.Body; | |
body = contents; | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlUploadPartCommand = serializeAws_restXmlUploadPartCommand; | |
var serializeAws_restXmlUploadPartCopyCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-copy-source": input.CopySource, | |
"x-amz-copy-source-if-match": input.CopySourceIfMatch, | |
"x-amz-copy-source-if-modified-since": [ | |
() => isSerializableHeaderValue(input.CopySourceIfModifiedSince), | |
() => (0, smithy_client_1.dateToUtcString)(input.CopySourceIfModifiedSince).toString() | |
], | |
"x-amz-copy-source-if-none-match": input.CopySourceIfNoneMatch, | |
"x-amz-copy-source-if-unmodified-since": [ | |
() => isSerializableHeaderValue(input.CopySourceIfUnmodifiedSince), | |
() => (0, smithy_client_1.dateToUtcString)(input.CopySourceIfUnmodifiedSince).toString() | |
], | |
"x-amz-copy-source-range": input.CopySourceRange, | |
"x-amz-server-side-encryption-customer-algorithm": input.SSECustomerAlgorithm, | |
"x-amz-server-side-encryption-customer-key": input.SSECustomerKey, | |
"x-amz-server-side-encryption-customer-key-md5": input.SSECustomerKeyMD5, | |
"x-amz-copy-source-server-side-encryption-customer-algorithm": input.CopySourceSSECustomerAlgorithm, | |
"x-amz-copy-source-server-side-encryption-customer-key": input.CopySourceSSECustomerKey, | |
"x-amz-copy-source-server-side-encryption-customer-key-md5": input.CopySourceSSECustomerKeyMD5, | |
"x-amz-request-payer": input.RequestPayer, | |
"x-amz-expected-bucket-owner": input.ExpectedBucketOwner, | |
"x-amz-source-expected-bucket-owner": input.ExpectedSourceBucketOwner | |
}); | |
let resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/{Key+}`; | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Bucket", () => input.Bucket, "{Bucket}", false); | |
resolvedPath = (0, smithy_client_1.resolvedPath)(resolvedPath, input, "Key", () => input.Key, "{Key+}", true); | |
const query = map({ | |
"x-id": [, "UploadPartCopy"], | |
partNumber: [(0, smithy_client_1.expectNonNull)(input.PartNumber, `PartNumber`) != null, () => input.PartNumber.toString()], | |
uploadId: [, (0, smithy_client_1.expectNonNull)(input.UploadId, `UploadId`)] | |
}); | |
let body; | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname, | |
port, | |
method: "PUT", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlUploadPartCopyCommand = serializeAws_restXmlUploadPartCopyCommand; | |
var serializeAws_restXmlWriteGetObjectResponseCommand = async (input, context) => { | |
const { hostname, protocol = "https", port, path: basePath } = await context.endpoint(); | |
const headers = map({}, isSerializableHeaderValue, { | |
"x-amz-content-sha256": "UNSIGNED-PAYLOAD", | |
"content-type": "application/octet-stream", | |
"x-amz-request-route": input.RequestRoute, | |
"x-amz-request-token": input.RequestToken, | |
"x-amz-fwd-status": [() => isSerializableHeaderValue(input.StatusCode), () => input.StatusCode.toString()], | |
"x-amz-fwd-error-code": input.ErrorCode, | |
"x-amz-fwd-error-message": input.ErrorMessage, | |
"x-amz-fwd-header-accept-ranges": input.AcceptRanges, | |
"x-amz-fwd-header-cache-control": input.CacheControl, | |
"x-amz-fwd-header-content-disposition": input.ContentDisposition, | |
"x-amz-fwd-header-content-encoding": input.ContentEncoding, | |
"x-amz-fwd-header-content-language": input.ContentLanguage, | |
"content-length": [() => isSerializableHeaderValue(input.ContentLength), () => input.ContentLength.toString()], | |
"x-amz-fwd-header-content-range": input.ContentRange, | |
"x-amz-fwd-header-content-type": input.ContentType, | |
"x-amz-fwd-header-x-amz-checksum-crc32": input.ChecksumCRC32, | |
"x-amz-fwd-header-x-amz-checksum-crc32c": input.ChecksumCRC32C, | |
"x-amz-fwd-header-x-amz-checksum-sha1": input.ChecksumSHA1, | |
"x-amz-fwd-header-x-amz-checksum-sha256": input.ChecksumSHA256, | |
"x-amz-fwd-header-x-amz-delete-marker": [ | |
() => isSerializableHeaderValue(input.DeleteMarker), | |
() => input.DeleteMarker.toString() | |
], | |
"x-amz-fwd-header-etag": input.ETag, | |
"x-amz-fwd-header-expires": [ | |
() => isSerializableHeaderValue(input.Expires), | |
() => (0, smithy_client_1.dateToUtcString)(input.Expires).toString() | |
], | |
"x-amz-fwd-header-x-amz-expiration": input.Expiration, | |
"x-amz-fwd-header-last-modified": [ | |
() => isSerializableHeaderValue(input.LastModified), | |
() => (0, smithy_client_1.dateToUtcString)(input.LastModified).toString() | |
], | |
"x-amz-fwd-header-x-amz-missing-meta": [ | |
() => isSerializableHeaderValue(input.MissingMeta), | |
() => input.MissingMeta.toString() | |
], | |
"x-amz-fwd-header-x-amz-object-lock-mode": input.ObjectLockMode, | |
"x-amz-fwd-header-x-amz-object-lock-legal-hold": input.ObjectLockLegalHoldStatus, | |
"x-amz-fwd-header-x-amz-object-lock-retain-until-date": [ | |
() => isSerializableHeaderValue(input.ObjectLockRetainUntilDate), | |
() => (input.ObjectLockRetainUntilDate.toISOString().split(".")[0] + "Z").toString() | |
], | |
"x-amz-fwd-header-x-amz-mp-parts-count": [ | |
() => isSerializableHeaderValue(input.PartsCount), | |
() => input.PartsCount.toString() | |
], | |
"x-amz-fwd-header-x-amz-replication-status": input.ReplicationStatus, | |
"x-amz-fwd-header-x-amz-request-charged": input.RequestCharged, | |
"x-amz-fwd-header-x-amz-restore": input.Restore, | |
"x-amz-fwd-header-x-amz-server-side-encryption": input.ServerSideEncryption, | |
"x-amz-fwd-header-x-amz-server-side-encryption-customer-algorithm": input.SSECustomerAlgorithm, | |
"x-amz-fwd-header-x-amz-server-side-encryption-aws-kms-key-id": input.SSEKMSKeyId, | |
"x-amz-fwd-header-x-amz-server-side-encryption-customer-key-md5": input.SSECustomerKeyMD5, | |
"x-amz-fwd-header-x-amz-storage-class": input.StorageClass, | |
"x-amz-fwd-header-x-amz-tagging-count": [ | |
() => isSerializableHeaderValue(input.TagCount), | |
() => input.TagCount.toString() | |
], | |
"x-amz-fwd-header-x-amz-version-id": input.VersionId, | |
"x-amz-fwd-header-x-amz-server-side-encryption-bucket-key-enabled": [ | |
() => isSerializableHeaderValue(input.BucketKeyEnabled), | |
() => input.BucketKeyEnabled.toString() | |
], | |
...input.Metadata !== void 0 && Object.keys(input.Metadata).reduce((acc, suffix) => { | |
acc[`x-amz-meta-${suffix.toLowerCase()}`] = input.Metadata[suffix]; | |
return acc; | |
}, {}) | |
}); | |
const resolvedPath = `${(basePath == null ? void 0 : basePath.endsWith("/")) ? basePath.slice(0, -1) : basePath || ""}/WriteGetObjectResponse`; | |
const query = map({ | |
"x-id": [, "WriteGetObjectResponse"] | |
}); | |
let body; | |
if (input.Body !== void 0) { | |
body = input.Body; | |
} | |
let contents; | |
if (input.Body !== void 0) { | |
contents = input.Body; | |
body = contents; | |
} | |
let { hostname: resolvedHostname } = await context.endpoint(); | |
if (context.disableHostPrefix !== true) { | |
resolvedHostname = "{RequestRoute}." + resolvedHostname; | |
if (input.RequestRoute === void 0) { | |
throw new Error("Empty value provided for input host prefix: RequestRoute."); | |
} | |
resolvedHostname = resolvedHostname.replace("{RequestRoute}", input.RequestRoute); | |
if (!(0, protocol_http_1.isValidHostname)(resolvedHostname)) { | |
throw new Error("ValidationError: prefixed hostname must be hostname compatible."); | |
} | |
} | |
return new protocol_http_1.HttpRequest({ | |
protocol, | |
hostname: resolvedHostname, | |
port, | |
method: "POST", | |
headers, | |
path: resolvedPath, | |
query, | |
body | |
}); | |
}; | |
exports.serializeAws_restXmlWriteGetObjectResponseCommand = serializeAws_restXmlWriteGetObjectResponseCommand; | |
var deserializeAws_restXmlAbortMultipartUploadCommand = async (output, context) => { | |
if (output.statusCode !== 204 && output.statusCode >= 300) { | |
return deserializeAws_restXmlAbortMultipartUploadCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output), | |
RequestCharged: [, output.headers["x-amz-request-charged"]] | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlAbortMultipartUploadCommand = deserializeAws_restXmlAbortMultipartUploadCommand; | |
var deserializeAws_restXmlAbortMultipartUploadCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
switch (errorCode) { | |
case "NoSuchUpload": | |
case "com.amazonaws.s3#NoSuchUpload": | |
throw await deserializeAws_restXmlNoSuchUploadResponse(parsedOutput, context); | |
default: | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
} | |
}; | |
var deserializeAws_restXmlCompleteMultipartUploadCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlCompleteMultipartUploadCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output), | |
Expiration: [, output.headers["x-amz-expiration"]], | |
ServerSideEncryption: [, output.headers["x-amz-server-side-encryption"]], | |
VersionId: [, output.headers["x-amz-version-id"]], | |
SSEKMSKeyId: [, output.headers["x-amz-server-side-encryption-aws-kms-key-id"]], | |
BucketKeyEnabled: [ | |
() => void 0 !== output.headers["x-amz-server-side-encryption-bucket-key-enabled"], | |
() => (0, smithy_client_1.parseBoolean)(output.headers["x-amz-server-side-encryption-bucket-key-enabled"]) | |
], | |
RequestCharged: [, output.headers["x-amz-request-charged"]] | |
}); | |
const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body"); | |
if (data["Bucket"] !== void 0) { | |
contents.Bucket = (0, smithy_client_1.expectString)(data["Bucket"]); | |
} | |
if (data["ChecksumCRC32"] !== void 0) { | |
contents.ChecksumCRC32 = (0, smithy_client_1.expectString)(data["ChecksumCRC32"]); | |
} | |
if (data["ChecksumCRC32C"] !== void 0) { | |
contents.ChecksumCRC32C = (0, smithy_client_1.expectString)(data["ChecksumCRC32C"]); | |
} | |
if (data["ChecksumSHA1"] !== void 0) { | |
contents.ChecksumSHA1 = (0, smithy_client_1.expectString)(data["ChecksumSHA1"]); | |
} | |
if (data["ChecksumSHA256"] !== void 0) { | |
contents.ChecksumSHA256 = (0, smithy_client_1.expectString)(data["ChecksumSHA256"]); | |
} | |
if (data["ETag"] !== void 0) { | |
contents.ETag = (0, smithy_client_1.expectString)(data["ETag"]); | |
} | |
if (data["Key"] !== void 0) { | |
contents.Key = (0, smithy_client_1.expectString)(data["Key"]); | |
} | |
if (data["Location"] !== void 0) { | |
contents.Location = (0, smithy_client_1.expectString)(data["Location"]); | |
} | |
return contents; | |
}; | |
exports.deserializeAws_restXmlCompleteMultipartUploadCommand = deserializeAws_restXmlCompleteMultipartUploadCommand; | |
var deserializeAws_restXmlCompleteMultipartUploadCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlCopyObjectCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlCopyObjectCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output), | |
Expiration: [, output.headers["x-amz-expiration"]], | |
CopySourceVersionId: [, output.headers["x-amz-copy-source-version-id"]], | |
VersionId: [, output.headers["x-amz-version-id"]], | |
ServerSideEncryption: [, output.headers["x-amz-server-side-encryption"]], | |
SSECustomerAlgorithm: [, output.headers["x-amz-server-side-encryption-customer-algorithm"]], | |
SSECustomerKeyMD5: [, output.headers["x-amz-server-side-encryption-customer-key-md5"]], | |
SSEKMSKeyId: [, output.headers["x-amz-server-side-encryption-aws-kms-key-id"]], | |
SSEKMSEncryptionContext: [, output.headers["x-amz-server-side-encryption-context"]], | |
BucketKeyEnabled: [ | |
() => void 0 !== output.headers["x-amz-server-side-encryption-bucket-key-enabled"], | |
() => (0, smithy_client_1.parseBoolean)(output.headers["x-amz-server-side-encryption-bucket-key-enabled"]) | |
], | |
RequestCharged: [, output.headers["x-amz-request-charged"]] | |
}); | |
const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context)); | |
contents.CopyObjectResult = deserializeAws_restXmlCopyObjectResult(data, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlCopyObjectCommand = deserializeAws_restXmlCopyObjectCommand; | |
var deserializeAws_restXmlCopyObjectCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
switch (errorCode) { | |
case "ObjectNotInActiveTierError": | |
case "com.amazonaws.s3#ObjectNotInActiveTierError": | |
throw await deserializeAws_restXmlObjectNotInActiveTierErrorResponse(parsedOutput, context); | |
default: | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
} | |
}; | |
var deserializeAws_restXmlCreateBucketCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlCreateBucketCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output), | |
Location: [, output.headers["location"]] | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlCreateBucketCommand = deserializeAws_restXmlCreateBucketCommand; | |
var deserializeAws_restXmlCreateBucketCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
switch (errorCode) { | |
case "BucketAlreadyExists": | |
case "com.amazonaws.s3#BucketAlreadyExists": | |
throw await deserializeAws_restXmlBucketAlreadyExistsResponse(parsedOutput, context); | |
case "BucketAlreadyOwnedByYou": | |
case "com.amazonaws.s3#BucketAlreadyOwnedByYou": | |
throw await deserializeAws_restXmlBucketAlreadyOwnedByYouResponse(parsedOutput, context); | |
default: | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
} | |
}; | |
var deserializeAws_restXmlCreateMultipartUploadCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlCreateMultipartUploadCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output), | |
AbortDate: [ | |
() => void 0 !== output.headers["x-amz-abort-date"], | |
() => (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc7231DateTime)(output.headers["x-amz-abort-date"])) | |
], | |
AbortRuleId: [, output.headers["x-amz-abort-rule-id"]], | |
ServerSideEncryption: [, output.headers["x-amz-server-side-encryption"]], | |
SSECustomerAlgorithm: [, output.headers["x-amz-server-side-encryption-customer-algorithm"]], | |
SSECustomerKeyMD5: [, output.headers["x-amz-server-side-encryption-customer-key-md5"]], | |
SSEKMSKeyId: [, output.headers["x-amz-server-side-encryption-aws-kms-key-id"]], | |
SSEKMSEncryptionContext: [, output.headers["x-amz-server-side-encryption-context"]], | |
BucketKeyEnabled: [ | |
() => void 0 !== output.headers["x-amz-server-side-encryption-bucket-key-enabled"], | |
() => (0, smithy_client_1.parseBoolean)(output.headers["x-amz-server-side-encryption-bucket-key-enabled"]) | |
], | |
RequestCharged: [, output.headers["x-amz-request-charged"]], | |
ChecksumAlgorithm: [, output.headers["x-amz-checksum-algorithm"]] | |
}); | |
const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body"); | |
if (data["Bucket"] !== void 0) { | |
contents.Bucket = (0, smithy_client_1.expectString)(data["Bucket"]); | |
} | |
if (data["Key"] !== void 0) { | |
contents.Key = (0, smithy_client_1.expectString)(data["Key"]); | |
} | |
if (data["UploadId"] !== void 0) { | |
contents.UploadId = (0, smithy_client_1.expectString)(data["UploadId"]); | |
} | |
return contents; | |
}; | |
exports.deserializeAws_restXmlCreateMultipartUploadCommand = deserializeAws_restXmlCreateMultipartUploadCommand; | |
var deserializeAws_restXmlCreateMultipartUploadCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlDeleteBucketCommand = async (output, context) => { | |
if (output.statusCode !== 204 && output.statusCode >= 300) { | |
return deserializeAws_restXmlDeleteBucketCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlDeleteBucketCommand = deserializeAws_restXmlDeleteBucketCommand; | |
var deserializeAws_restXmlDeleteBucketCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlDeleteBucketAnalyticsConfigurationCommand = async (output, context) => { | |
if (output.statusCode !== 204 && output.statusCode >= 300) { | |
return deserializeAws_restXmlDeleteBucketAnalyticsConfigurationCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlDeleteBucketAnalyticsConfigurationCommand = deserializeAws_restXmlDeleteBucketAnalyticsConfigurationCommand; | |
var deserializeAws_restXmlDeleteBucketAnalyticsConfigurationCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlDeleteBucketCorsCommand = async (output, context) => { | |
if (output.statusCode !== 204 && output.statusCode >= 300) { | |
return deserializeAws_restXmlDeleteBucketCorsCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlDeleteBucketCorsCommand = deserializeAws_restXmlDeleteBucketCorsCommand; | |
var deserializeAws_restXmlDeleteBucketCorsCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlDeleteBucketEncryptionCommand = async (output, context) => { | |
if (output.statusCode !== 204 && output.statusCode >= 300) { | |
return deserializeAws_restXmlDeleteBucketEncryptionCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlDeleteBucketEncryptionCommand = deserializeAws_restXmlDeleteBucketEncryptionCommand; | |
var deserializeAws_restXmlDeleteBucketEncryptionCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommand = async (output, context) => { | |
if (output.statusCode !== 204 && output.statusCode >= 300) { | |
return deserializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommand = deserializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommand; | |
var deserializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlDeleteBucketInventoryConfigurationCommand = async (output, context) => { | |
if (output.statusCode !== 204 && output.statusCode >= 300) { | |
return deserializeAws_restXmlDeleteBucketInventoryConfigurationCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlDeleteBucketInventoryConfigurationCommand = deserializeAws_restXmlDeleteBucketInventoryConfigurationCommand; | |
var deserializeAws_restXmlDeleteBucketInventoryConfigurationCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlDeleteBucketLifecycleCommand = async (output, context) => { | |
if (output.statusCode !== 204 && output.statusCode >= 300) { | |
return deserializeAws_restXmlDeleteBucketLifecycleCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlDeleteBucketLifecycleCommand = deserializeAws_restXmlDeleteBucketLifecycleCommand; | |
var deserializeAws_restXmlDeleteBucketLifecycleCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlDeleteBucketMetricsConfigurationCommand = async (output, context) => { | |
if (output.statusCode !== 204 && output.statusCode >= 300) { | |
return deserializeAws_restXmlDeleteBucketMetricsConfigurationCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlDeleteBucketMetricsConfigurationCommand = deserializeAws_restXmlDeleteBucketMetricsConfigurationCommand; | |
var deserializeAws_restXmlDeleteBucketMetricsConfigurationCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlDeleteBucketOwnershipControlsCommand = async (output, context) => { | |
if (output.statusCode !== 204 && output.statusCode >= 300) { | |
return deserializeAws_restXmlDeleteBucketOwnershipControlsCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlDeleteBucketOwnershipControlsCommand = deserializeAws_restXmlDeleteBucketOwnershipControlsCommand; | |
var deserializeAws_restXmlDeleteBucketOwnershipControlsCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlDeleteBucketPolicyCommand = async (output, context) => { | |
if (output.statusCode !== 204 && output.statusCode >= 300) { | |
return deserializeAws_restXmlDeleteBucketPolicyCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlDeleteBucketPolicyCommand = deserializeAws_restXmlDeleteBucketPolicyCommand; | |
var deserializeAws_restXmlDeleteBucketPolicyCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlDeleteBucketReplicationCommand = async (output, context) => { | |
if (output.statusCode !== 204 && output.statusCode >= 300) { | |
return deserializeAws_restXmlDeleteBucketReplicationCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlDeleteBucketReplicationCommand = deserializeAws_restXmlDeleteBucketReplicationCommand; | |
var deserializeAws_restXmlDeleteBucketReplicationCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlDeleteBucketTaggingCommand = async (output, context) => { | |
if (output.statusCode !== 204 && output.statusCode >= 300) { | |
return deserializeAws_restXmlDeleteBucketTaggingCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlDeleteBucketTaggingCommand = deserializeAws_restXmlDeleteBucketTaggingCommand; | |
var deserializeAws_restXmlDeleteBucketTaggingCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlDeleteBucketWebsiteCommand = async (output, context) => { | |
if (output.statusCode !== 204 && output.statusCode >= 300) { | |
return deserializeAws_restXmlDeleteBucketWebsiteCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlDeleteBucketWebsiteCommand = deserializeAws_restXmlDeleteBucketWebsiteCommand; | |
var deserializeAws_restXmlDeleteBucketWebsiteCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlDeleteObjectCommand = async (output, context) => { | |
if (output.statusCode !== 204 && output.statusCode >= 300) { | |
return deserializeAws_restXmlDeleteObjectCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output), | |
DeleteMarker: [ | |
() => void 0 !== output.headers["x-amz-delete-marker"], | |
() => (0, smithy_client_1.parseBoolean)(output.headers["x-amz-delete-marker"]) | |
], | |
VersionId: [, output.headers["x-amz-version-id"]], | |
RequestCharged: [, output.headers["x-amz-request-charged"]] | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlDeleteObjectCommand = deserializeAws_restXmlDeleteObjectCommand; | |
var deserializeAws_restXmlDeleteObjectCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlDeleteObjectsCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlDeleteObjectsCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output), | |
RequestCharged: [, output.headers["x-amz-request-charged"]] | |
}); | |
const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body"); | |
if (data.Deleted === "") { | |
contents.Deleted = []; | |
} else if (data["Deleted"] !== void 0) { | |
contents.Deleted = deserializeAws_restXmlDeletedObjects((0, smithy_client_1.getArrayIfSingleItem)(data["Deleted"]), context); | |
} | |
if (data.Error === "") { | |
contents.Errors = []; | |
} else if (data["Error"] !== void 0) { | |
contents.Errors = deserializeAws_restXmlErrors((0, smithy_client_1.getArrayIfSingleItem)(data["Error"]), context); | |
} | |
return contents; | |
}; | |
exports.deserializeAws_restXmlDeleteObjectsCommand = deserializeAws_restXmlDeleteObjectsCommand; | |
var deserializeAws_restXmlDeleteObjectsCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlDeleteObjectTaggingCommand = async (output, context) => { | |
if (output.statusCode !== 204 && output.statusCode >= 300) { | |
return deserializeAws_restXmlDeleteObjectTaggingCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output), | |
VersionId: [, output.headers["x-amz-version-id"]] | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlDeleteObjectTaggingCommand = deserializeAws_restXmlDeleteObjectTaggingCommand; | |
var deserializeAws_restXmlDeleteObjectTaggingCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlDeletePublicAccessBlockCommand = async (output, context) => { | |
if (output.statusCode !== 204 && output.statusCode >= 300) { | |
return deserializeAws_restXmlDeletePublicAccessBlockCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlDeletePublicAccessBlockCommand = deserializeAws_restXmlDeletePublicAccessBlockCommand; | |
var deserializeAws_restXmlDeletePublicAccessBlockCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlGetBucketAccelerateConfigurationCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetBucketAccelerateConfigurationCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body"); | |
if (data["Status"] !== void 0) { | |
contents.Status = (0, smithy_client_1.expectString)(data["Status"]); | |
} | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetBucketAccelerateConfigurationCommand = deserializeAws_restXmlGetBucketAccelerateConfigurationCommand; | |
var deserializeAws_restXmlGetBucketAccelerateConfigurationCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlGetBucketAclCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetBucketAclCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body"); | |
if (data.AccessControlList === "") { | |
contents.Grants = []; | |
} else if (data["AccessControlList"] !== void 0 && data["AccessControlList"]["Grant"] !== void 0) { | |
contents.Grants = deserializeAws_restXmlGrants((0, smithy_client_1.getArrayIfSingleItem)(data["AccessControlList"]["Grant"]), context); | |
} | |
if (data["Owner"] !== void 0) { | |
contents.Owner = deserializeAws_restXmlOwner(data["Owner"], context); | |
} | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetBucketAclCommand = deserializeAws_restXmlGetBucketAclCommand; | |
var deserializeAws_restXmlGetBucketAclCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlGetBucketAnalyticsConfigurationCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetBucketAnalyticsConfigurationCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context)); | |
contents.AnalyticsConfiguration = deserializeAws_restXmlAnalyticsConfiguration(data, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetBucketAnalyticsConfigurationCommand = deserializeAws_restXmlGetBucketAnalyticsConfigurationCommand; | |
var deserializeAws_restXmlGetBucketAnalyticsConfigurationCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlGetBucketCorsCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetBucketCorsCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body"); | |
if (data.CORSRule === "") { | |
contents.CORSRules = []; | |
} else if (data["CORSRule"] !== void 0) { | |
contents.CORSRules = deserializeAws_restXmlCORSRules((0, smithy_client_1.getArrayIfSingleItem)(data["CORSRule"]), context); | |
} | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetBucketCorsCommand = deserializeAws_restXmlGetBucketCorsCommand; | |
var deserializeAws_restXmlGetBucketCorsCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlGetBucketEncryptionCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetBucketEncryptionCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context)); | |
contents.ServerSideEncryptionConfiguration = deserializeAws_restXmlServerSideEncryptionConfiguration(data, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetBucketEncryptionCommand = deserializeAws_restXmlGetBucketEncryptionCommand; | |
var deserializeAws_restXmlGetBucketEncryptionCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlGetBucketIntelligentTieringConfigurationCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetBucketIntelligentTieringConfigurationCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context)); | |
contents.IntelligentTieringConfiguration = deserializeAws_restXmlIntelligentTieringConfiguration(data, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetBucketIntelligentTieringConfigurationCommand = deserializeAws_restXmlGetBucketIntelligentTieringConfigurationCommand; | |
var deserializeAws_restXmlGetBucketIntelligentTieringConfigurationCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlGetBucketInventoryConfigurationCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetBucketInventoryConfigurationCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context)); | |
contents.InventoryConfiguration = deserializeAws_restXmlInventoryConfiguration(data, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetBucketInventoryConfigurationCommand = deserializeAws_restXmlGetBucketInventoryConfigurationCommand; | |
var deserializeAws_restXmlGetBucketInventoryConfigurationCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlGetBucketLifecycleConfigurationCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetBucketLifecycleConfigurationCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body"); | |
if (data.Rule === "") { | |
contents.Rules = []; | |
} else if (data["Rule"] !== void 0) { | |
contents.Rules = deserializeAws_restXmlLifecycleRules((0, smithy_client_1.getArrayIfSingleItem)(data["Rule"]), context); | |
} | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetBucketLifecycleConfigurationCommand = deserializeAws_restXmlGetBucketLifecycleConfigurationCommand; | |
var deserializeAws_restXmlGetBucketLifecycleConfigurationCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlGetBucketLocationCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetBucketLocationCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body"); | |
if (data["LocationConstraint"] !== void 0) { | |
contents.LocationConstraint = (0, smithy_client_1.expectString)(data["LocationConstraint"]); | |
} | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetBucketLocationCommand = deserializeAws_restXmlGetBucketLocationCommand; | |
var deserializeAws_restXmlGetBucketLocationCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlGetBucketLoggingCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetBucketLoggingCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body"); | |
if (data["LoggingEnabled"] !== void 0) { | |
contents.LoggingEnabled = deserializeAws_restXmlLoggingEnabled(data["LoggingEnabled"], context); | |
} | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetBucketLoggingCommand = deserializeAws_restXmlGetBucketLoggingCommand; | |
var deserializeAws_restXmlGetBucketLoggingCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlGetBucketMetricsConfigurationCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetBucketMetricsConfigurationCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context)); | |
contents.MetricsConfiguration = deserializeAws_restXmlMetricsConfiguration(data, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetBucketMetricsConfigurationCommand = deserializeAws_restXmlGetBucketMetricsConfigurationCommand; | |
var deserializeAws_restXmlGetBucketMetricsConfigurationCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlGetBucketNotificationConfigurationCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetBucketNotificationConfigurationCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body"); | |
if (data["EventBridgeConfiguration"] !== void 0) { | |
contents.EventBridgeConfiguration = deserializeAws_restXmlEventBridgeConfiguration(data["EventBridgeConfiguration"], context); | |
} | |
if (data.CloudFunctionConfiguration === "") { | |
contents.LambdaFunctionConfigurations = []; | |
} else if (data["CloudFunctionConfiguration"] !== void 0) { | |
contents.LambdaFunctionConfigurations = deserializeAws_restXmlLambdaFunctionConfigurationList((0, smithy_client_1.getArrayIfSingleItem)(data["CloudFunctionConfiguration"]), context); | |
} | |
if (data.QueueConfiguration === "") { | |
contents.QueueConfigurations = []; | |
} else if (data["QueueConfiguration"] !== void 0) { | |
contents.QueueConfigurations = deserializeAws_restXmlQueueConfigurationList((0, smithy_client_1.getArrayIfSingleItem)(data["QueueConfiguration"]), context); | |
} | |
if (data.TopicConfiguration === "") { | |
contents.TopicConfigurations = []; | |
} else if (data["TopicConfiguration"] !== void 0) { | |
contents.TopicConfigurations = deserializeAws_restXmlTopicConfigurationList((0, smithy_client_1.getArrayIfSingleItem)(data["TopicConfiguration"]), context); | |
} | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetBucketNotificationConfigurationCommand = deserializeAws_restXmlGetBucketNotificationConfigurationCommand; | |
var deserializeAws_restXmlGetBucketNotificationConfigurationCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlGetBucketOwnershipControlsCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetBucketOwnershipControlsCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context)); | |
contents.OwnershipControls = deserializeAws_restXmlOwnershipControls(data, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetBucketOwnershipControlsCommand = deserializeAws_restXmlGetBucketOwnershipControlsCommand; | |
var deserializeAws_restXmlGetBucketOwnershipControlsCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlGetBucketPolicyCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetBucketPolicyCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = await collectBodyString(output.body, context); | |
contents.Policy = (0, smithy_client_1.expectString)(data); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetBucketPolicyCommand = deserializeAws_restXmlGetBucketPolicyCommand; | |
var deserializeAws_restXmlGetBucketPolicyCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlGetBucketPolicyStatusCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetBucketPolicyStatusCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context)); | |
contents.PolicyStatus = deserializeAws_restXmlPolicyStatus(data, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetBucketPolicyStatusCommand = deserializeAws_restXmlGetBucketPolicyStatusCommand; | |
var deserializeAws_restXmlGetBucketPolicyStatusCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlGetBucketReplicationCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetBucketReplicationCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context)); | |
contents.ReplicationConfiguration = deserializeAws_restXmlReplicationConfiguration(data, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetBucketReplicationCommand = deserializeAws_restXmlGetBucketReplicationCommand; | |
var deserializeAws_restXmlGetBucketReplicationCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlGetBucketRequestPaymentCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetBucketRequestPaymentCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body"); | |
if (data["Payer"] !== void 0) { | |
contents.Payer = (0, smithy_client_1.expectString)(data["Payer"]); | |
} | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetBucketRequestPaymentCommand = deserializeAws_restXmlGetBucketRequestPaymentCommand; | |
var deserializeAws_restXmlGetBucketRequestPaymentCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlGetBucketTaggingCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetBucketTaggingCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body"); | |
if (data.TagSet === "") { | |
contents.TagSet = []; | |
} else if (data["TagSet"] !== void 0 && data["TagSet"]["Tag"] !== void 0) { | |
contents.TagSet = deserializeAws_restXmlTagSet((0, smithy_client_1.getArrayIfSingleItem)(data["TagSet"]["Tag"]), context); | |
} | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetBucketTaggingCommand = deserializeAws_restXmlGetBucketTaggingCommand; | |
var deserializeAws_restXmlGetBucketTaggingCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlGetBucketVersioningCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetBucketVersioningCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body"); | |
if (data["MfaDelete"] !== void 0) { | |
contents.MFADelete = (0, smithy_client_1.expectString)(data["MfaDelete"]); | |
} | |
if (data["Status"] !== void 0) { | |
contents.Status = (0, smithy_client_1.expectString)(data["Status"]); | |
} | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetBucketVersioningCommand = deserializeAws_restXmlGetBucketVersioningCommand; | |
var deserializeAws_restXmlGetBucketVersioningCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlGetBucketWebsiteCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetBucketWebsiteCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body"); | |
if (data["ErrorDocument"] !== void 0) { | |
contents.ErrorDocument = deserializeAws_restXmlErrorDocument(data["ErrorDocument"], context); | |
} | |
if (data["IndexDocument"] !== void 0) { | |
contents.IndexDocument = deserializeAws_restXmlIndexDocument(data["IndexDocument"], context); | |
} | |
if (data["RedirectAllRequestsTo"] !== void 0) { | |
contents.RedirectAllRequestsTo = deserializeAws_restXmlRedirectAllRequestsTo(data["RedirectAllRequestsTo"], context); | |
} | |
if (data.RoutingRules === "") { | |
contents.RoutingRules = []; | |
} else if (data["RoutingRules"] !== void 0 && data["RoutingRules"]["RoutingRule"] !== void 0) { | |
contents.RoutingRules = deserializeAws_restXmlRoutingRules((0, smithy_client_1.getArrayIfSingleItem)(data["RoutingRules"]["RoutingRule"]), context); | |
} | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetBucketWebsiteCommand = deserializeAws_restXmlGetBucketWebsiteCommand; | |
var deserializeAws_restXmlGetBucketWebsiteCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlGetObjectCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetObjectCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output), | |
DeleteMarker: [ | |
() => void 0 !== output.headers["x-amz-delete-marker"], | |
() => (0, smithy_client_1.parseBoolean)(output.headers["x-amz-delete-marker"]) | |
], | |
AcceptRanges: [, output.headers["accept-ranges"]], | |
Expiration: [, output.headers["x-amz-expiration"]], | |
Restore: [, output.headers["x-amz-restore"]], | |
LastModified: [ | |
() => void 0 !== output.headers["last-modified"], | |
() => (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc7231DateTime)(output.headers["last-modified"])) | |
], | |
ContentLength: [ | |
() => void 0 !== output.headers["content-length"], | |
() => (0, smithy_client_1.strictParseLong)(output.headers["content-length"]) | |
], | |
ETag: [, output.headers["etag"]], | |
ChecksumCRC32: [, output.headers["x-amz-checksum-crc32"]], | |
ChecksumCRC32C: [, output.headers["x-amz-checksum-crc32c"]], | |
ChecksumSHA1: [, output.headers["x-amz-checksum-sha1"]], | |
ChecksumSHA256: [, output.headers["x-amz-checksum-sha256"]], | |
MissingMeta: [ | |
() => void 0 !== output.headers["x-amz-missing-meta"], | |
() => (0, smithy_client_1.strictParseInt32)(output.headers["x-amz-missing-meta"]) | |
], | |
VersionId: [, output.headers["x-amz-version-id"]], | |
CacheControl: [, output.headers["cache-control"]], | |
ContentDisposition: [, output.headers["content-disposition"]], | |
ContentEncoding: [, output.headers["content-encoding"]], | |
ContentLanguage: [, output.headers["content-language"]], | |
ContentRange: [, output.headers["content-range"]], | |
ContentType: [, output.headers["content-type"]], | |
Expires: [ | |
() => void 0 !== output.headers["expires"], | |
() => (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc7231DateTime)(output.headers["expires"])) | |
], | |
WebsiteRedirectLocation: [, output.headers["x-amz-website-redirect-location"]], | |
ServerSideEncryption: [, output.headers["x-amz-server-side-encryption"]], | |
SSECustomerAlgorithm: [, output.headers["x-amz-server-side-encryption-customer-algorithm"]], | |
SSECustomerKeyMD5: [, output.headers["x-amz-server-side-encryption-customer-key-md5"]], | |
SSEKMSKeyId: [, output.headers["x-amz-server-side-encryption-aws-kms-key-id"]], | |
BucketKeyEnabled: [ | |
() => void 0 !== output.headers["x-amz-server-side-encryption-bucket-key-enabled"], | |
() => (0, smithy_client_1.parseBoolean)(output.headers["x-amz-server-side-encryption-bucket-key-enabled"]) | |
], | |
StorageClass: [, output.headers["x-amz-storage-class"]], | |
RequestCharged: [, output.headers["x-amz-request-charged"]], | |
ReplicationStatus: [, output.headers["x-amz-replication-status"]], | |
PartsCount: [ | |
() => void 0 !== output.headers["x-amz-mp-parts-count"], | |
() => (0, smithy_client_1.strictParseInt32)(output.headers["x-amz-mp-parts-count"]) | |
], | |
TagCount: [ | |
() => void 0 !== output.headers["x-amz-tagging-count"], | |
() => (0, smithy_client_1.strictParseInt32)(output.headers["x-amz-tagging-count"]) | |
], | |
ObjectLockMode: [, output.headers["x-amz-object-lock-mode"]], | |
ObjectLockRetainUntilDate: [ | |
() => void 0 !== output.headers["x-amz-object-lock-retain-until-date"], | |
() => (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output.headers["x-amz-object-lock-retain-until-date"])) | |
], | |
ObjectLockLegalHoldStatus: [, output.headers["x-amz-object-lock-legal-hold"]], | |
Metadata: [ | |
, | |
Object.keys(output.headers).filter((header) => header.startsWith("x-amz-meta-")).reduce((acc, header) => { | |
acc[header.substring(11)] = output.headers[header]; | |
return acc; | |
}, {}) | |
] | |
}); | |
const data = output.body; | |
context.sdkStreamMixin(data); | |
contents.Body = data; | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetObjectCommand = deserializeAws_restXmlGetObjectCommand; | |
var deserializeAws_restXmlGetObjectCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
switch (errorCode) { | |
case "InvalidObjectState": | |
case "com.amazonaws.s3#InvalidObjectState": | |
throw await deserializeAws_restXmlInvalidObjectStateResponse(parsedOutput, context); | |
case "NoSuchKey": | |
case "com.amazonaws.s3#NoSuchKey": | |
throw await deserializeAws_restXmlNoSuchKeyResponse(parsedOutput, context); | |
default: | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
} | |
}; | |
var deserializeAws_restXmlGetObjectAclCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetObjectAclCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output), | |
RequestCharged: [, output.headers["x-amz-request-charged"]] | |
}); | |
const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body"); | |
if (data.AccessControlList === "") { | |
contents.Grants = []; | |
} else if (data["AccessControlList"] !== void 0 && data["AccessControlList"]["Grant"] !== void 0) { | |
contents.Grants = deserializeAws_restXmlGrants((0, smithy_client_1.getArrayIfSingleItem)(data["AccessControlList"]["Grant"]), context); | |
} | |
if (data["Owner"] !== void 0) { | |
contents.Owner = deserializeAws_restXmlOwner(data["Owner"], context); | |
} | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetObjectAclCommand = deserializeAws_restXmlGetObjectAclCommand; | |
var deserializeAws_restXmlGetObjectAclCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
switch (errorCode) { | |
case "NoSuchKey": | |
case "com.amazonaws.s3#NoSuchKey": | |
throw await deserializeAws_restXmlNoSuchKeyResponse(parsedOutput, context); | |
default: | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
} | |
}; | |
var deserializeAws_restXmlGetObjectAttributesCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetObjectAttributesCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output), | |
DeleteMarker: [ | |
() => void 0 !== output.headers["x-amz-delete-marker"], | |
() => (0, smithy_client_1.parseBoolean)(output.headers["x-amz-delete-marker"]) | |
], | |
LastModified: [ | |
() => void 0 !== output.headers["last-modified"], | |
() => (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc7231DateTime)(output.headers["last-modified"])) | |
], | |
VersionId: [, output.headers["x-amz-version-id"]], | |
RequestCharged: [, output.headers["x-amz-request-charged"]] | |
}); | |
const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body"); | |
if (data["Checksum"] !== void 0) { | |
contents.Checksum = deserializeAws_restXmlChecksum(data["Checksum"], context); | |
} | |
if (data["ETag"] !== void 0) { | |
contents.ETag = (0, smithy_client_1.expectString)(data["ETag"]); | |
} | |
if (data["ObjectParts"] !== void 0) { | |
contents.ObjectParts = deserializeAws_restXmlGetObjectAttributesParts(data["ObjectParts"], context); | |
} | |
if (data["ObjectSize"] !== void 0) { | |
contents.ObjectSize = (0, smithy_client_1.strictParseLong)(data["ObjectSize"]); | |
} | |
if (data["StorageClass"] !== void 0) { | |
contents.StorageClass = (0, smithy_client_1.expectString)(data["StorageClass"]); | |
} | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetObjectAttributesCommand = deserializeAws_restXmlGetObjectAttributesCommand; | |
var deserializeAws_restXmlGetObjectAttributesCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
switch (errorCode) { | |
case "NoSuchKey": | |
case "com.amazonaws.s3#NoSuchKey": | |
throw await deserializeAws_restXmlNoSuchKeyResponse(parsedOutput, context); | |
default: | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
} | |
}; | |
var deserializeAws_restXmlGetObjectLegalHoldCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetObjectLegalHoldCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context)); | |
contents.LegalHold = deserializeAws_restXmlObjectLockLegalHold(data, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetObjectLegalHoldCommand = deserializeAws_restXmlGetObjectLegalHoldCommand; | |
var deserializeAws_restXmlGetObjectLegalHoldCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlGetObjectLockConfigurationCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetObjectLockConfigurationCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context)); | |
contents.ObjectLockConfiguration = deserializeAws_restXmlObjectLockConfiguration(data, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetObjectLockConfigurationCommand = deserializeAws_restXmlGetObjectLockConfigurationCommand; | |
var deserializeAws_restXmlGetObjectLockConfigurationCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlGetObjectRetentionCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetObjectRetentionCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context)); | |
contents.Retention = deserializeAws_restXmlObjectLockRetention(data, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetObjectRetentionCommand = deserializeAws_restXmlGetObjectRetentionCommand; | |
var deserializeAws_restXmlGetObjectRetentionCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlGetObjectTaggingCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetObjectTaggingCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output), | |
VersionId: [, output.headers["x-amz-version-id"]] | |
}); | |
const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body"); | |
if (data.TagSet === "") { | |
contents.TagSet = []; | |
} else if (data["TagSet"] !== void 0 && data["TagSet"]["Tag"] !== void 0) { | |
contents.TagSet = deserializeAws_restXmlTagSet((0, smithy_client_1.getArrayIfSingleItem)(data["TagSet"]["Tag"]), context); | |
} | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetObjectTaggingCommand = deserializeAws_restXmlGetObjectTaggingCommand; | |
var deserializeAws_restXmlGetObjectTaggingCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlGetObjectTorrentCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetObjectTorrentCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output), | |
RequestCharged: [, output.headers["x-amz-request-charged"]] | |
}); | |
const data = output.body; | |
context.sdkStreamMixin(data); | |
contents.Body = data; | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetObjectTorrentCommand = deserializeAws_restXmlGetObjectTorrentCommand; | |
var deserializeAws_restXmlGetObjectTorrentCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlGetPublicAccessBlockCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlGetPublicAccessBlockCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context)); | |
contents.PublicAccessBlockConfiguration = deserializeAws_restXmlPublicAccessBlockConfiguration(data, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlGetPublicAccessBlockCommand = deserializeAws_restXmlGetPublicAccessBlockCommand; | |
var deserializeAws_restXmlGetPublicAccessBlockCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlHeadBucketCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlHeadBucketCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlHeadBucketCommand = deserializeAws_restXmlHeadBucketCommand; | |
var deserializeAws_restXmlHeadBucketCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
switch (errorCode) { | |
case "NotFound": | |
case "com.amazonaws.s3#NotFound": | |
throw await deserializeAws_restXmlNotFoundResponse(parsedOutput, context); | |
default: | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
} | |
}; | |
var deserializeAws_restXmlHeadObjectCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlHeadObjectCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output), | |
DeleteMarker: [ | |
() => void 0 !== output.headers["x-amz-delete-marker"], | |
() => (0, smithy_client_1.parseBoolean)(output.headers["x-amz-delete-marker"]) | |
], | |
AcceptRanges: [, output.headers["accept-ranges"]], | |
Expiration: [, output.headers["x-amz-expiration"]], | |
Restore: [, output.headers["x-amz-restore"]], | |
ArchiveStatus: [, output.headers["x-amz-archive-status"]], | |
LastModified: [ | |
() => void 0 !== output.headers["last-modified"], | |
() => (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc7231DateTime)(output.headers["last-modified"])) | |
], | |
ContentLength: [ | |
() => void 0 !== output.headers["content-length"], | |
() => (0, smithy_client_1.strictParseLong)(output.headers["content-length"]) | |
], | |
ChecksumCRC32: [, output.headers["x-amz-checksum-crc32"]], | |
ChecksumCRC32C: [, output.headers["x-amz-checksum-crc32c"]], | |
ChecksumSHA1: [, output.headers["x-amz-checksum-sha1"]], | |
ChecksumSHA256: [, output.headers["x-amz-checksum-sha256"]], | |
ETag: [, output.headers["etag"]], | |
MissingMeta: [ | |
() => void 0 !== output.headers["x-amz-missing-meta"], | |
() => (0, smithy_client_1.strictParseInt32)(output.headers["x-amz-missing-meta"]) | |
], | |
VersionId: [, output.headers["x-amz-version-id"]], | |
CacheControl: [, output.headers["cache-control"]], | |
ContentDisposition: [, output.headers["content-disposition"]], | |
ContentEncoding: [, output.headers["content-encoding"]], | |
ContentLanguage: [, output.headers["content-language"]], | |
ContentType: [, output.headers["content-type"]], | |
Expires: [ | |
() => void 0 !== output.headers["expires"], | |
() => (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc7231DateTime)(output.headers["expires"])) | |
], | |
WebsiteRedirectLocation: [, output.headers["x-amz-website-redirect-location"]], | |
ServerSideEncryption: [, output.headers["x-amz-server-side-encryption"]], | |
SSECustomerAlgorithm: [, output.headers["x-amz-server-side-encryption-customer-algorithm"]], | |
SSECustomerKeyMD5: [, output.headers["x-amz-server-side-encryption-customer-key-md5"]], | |
SSEKMSKeyId: [, output.headers["x-amz-server-side-encryption-aws-kms-key-id"]], | |
BucketKeyEnabled: [ | |
() => void 0 !== output.headers["x-amz-server-side-encryption-bucket-key-enabled"], | |
() => (0, smithy_client_1.parseBoolean)(output.headers["x-amz-server-side-encryption-bucket-key-enabled"]) | |
], | |
StorageClass: [, output.headers["x-amz-storage-class"]], | |
RequestCharged: [, output.headers["x-amz-request-charged"]], | |
ReplicationStatus: [, output.headers["x-amz-replication-status"]], | |
PartsCount: [ | |
() => void 0 !== output.headers["x-amz-mp-parts-count"], | |
() => (0, smithy_client_1.strictParseInt32)(output.headers["x-amz-mp-parts-count"]) | |
], | |
ObjectLockMode: [, output.headers["x-amz-object-lock-mode"]], | |
ObjectLockRetainUntilDate: [ | |
() => void 0 !== output.headers["x-amz-object-lock-retain-until-date"], | |
() => (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output.headers["x-amz-object-lock-retain-until-date"])) | |
], | |
ObjectLockLegalHoldStatus: [, output.headers["x-amz-object-lock-legal-hold"]], | |
Metadata: [ | |
, | |
Object.keys(output.headers).filter((header) => header.startsWith("x-amz-meta-")).reduce((acc, header) => { | |
acc[header.substring(11)] = output.headers[header]; | |
return acc; | |
}, {}) | |
] | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlHeadObjectCommand = deserializeAws_restXmlHeadObjectCommand; | |
var deserializeAws_restXmlHeadObjectCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
switch (errorCode) { | |
case "NotFound": | |
case "com.amazonaws.s3#NotFound": | |
throw await deserializeAws_restXmlNotFoundResponse(parsedOutput, context); | |
default: | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
} | |
}; | |
var deserializeAws_restXmlListBucketAnalyticsConfigurationsCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlListBucketAnalyticsConfigurationsCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body"); | |
if (data.AnalyticsConfiguration === "") { | |
contents.AnalyticsConfigurationList = []; | |
} else if (data["AnalyticsConfiguration"] !== void 0) { | |
contents.AnalyticsConfigurationList = deserializeAws_restXmlAnalyticsConfigurationList((0, smithy_client_1.getArrayIfSingleItem)(data["AnalyticsConfiguration"]), context); | |
} | |
if (data["ContinuationToken"] !== void 0) { | |
contents.ContinuationToken = (0, smithy_client_1.expectString)(data["ContinuationToken"]); | |
} | |
if (data["IsTruncated"] !== void 0) { | |
contents.IsTruncated = (0, smithy_client_1.parseBoolean)(data["IsTruncated"]); | |
} | |
if (data["NextContinuationToken"] !== void 0) { | |
contents.NextContinuationToken = (0, smithy_client_1.expectString)(data["NextContinuationToken"]); | |
} | |
return contents; | |
}; | |
exports.deserializeAws_restXmlListBucketAnalyticsConfigurationsCommand = deserializeAws_restXmlListBucketAnalyticsConfigurationsCommand; | |
var deserializeAws_restXmlListBucketAnalyticsConfigurationsCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlListBucketIntelligentTieringConfigurationsCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlListBucketIntelligentTieringConfigurationsCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body"); | |
if (data["ContinuationToken"] !== void 0) { | |
contents.ContinuationToken = (0, smithy_client_1.expectString)(data["ContinuationToken"]); | |
} | |
if (data.IntelligentTieringConfiguration === "") { | |
contents.IntelligentTieringConfigurationList = []; | |
} else if (data["IntelligentTieringConfiguration"] !== void 0) { | |
contents.IntelligentTieringConfigurationList = deserializeAws_restXmlIntelligentTieringConfigurationList((0, smithy_client_1.getArrayIfSingleItem)(data["IntelligentTieringConfiguration"]), context); | |
} | |
if (data["IsTruncated"] !== void 0) { | |
contents.IsTruncated = (0, smithy_client_1.parseBoolean)(data["IsTruncated"]); | |
} | |
if (data["NextContinuationToken"] !== void 0) { | |
contents.NextContinuationToken = (0, smithy_client_1.expectString)(data["NextContinuationToken"]); | |
} | |
return contents; | |
}; | |
exports.deserializeAws_restXmlListBucketIntelligentTieringConfigurationsCommand = deserializeAws_restXmlListBucketIntelligentTieringConfigurationsCommand; | |
var deserializeAws_restXmlListBucketIntelligentTieringConfigurationsCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlListBucketInventoryConfigurationsCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlListBucketInventoryConfigurationsCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body"); | |
if (data["ContinuationToken"] !== void 0) { | |
contents.ContinuationToken = (0, smithy_client_1.expectString)(data["ContinuationToken"]); | |
} | |
if (data.InventoryConfiguration === "") { | |
contents.InventoryConfigurationList = []; | |
} else if (data["InventoryConfiguration"] !== void 0) { | |
contents.InventoryConfigurationList = deserializeAws_restXmlInventoryConfigurationList((0, smithy_client_1.getArrayIfSingleItem)(data["InventoryConfiguration"]), context); | |
} | |
if (data["IsTruncated"] !== void 0) { | |
contents.IsTruncated = (0, smithy_client_1.parseBoolean)(data["IsTruncated"]); | |
} | |
if (data["NextContinuationToken"] !== void 0) { | |
contents.NextContinuationToken = (0, smithy_client_1.expectString)(data["NextContinuationToken"]); | |
} | |
return contents; | |
}; | |
exports.deserializeAws_restXmlListBucketInventoryConfigurationsCommand = deserializeAws_restXmlListBucketInventoryConfigurationsCommand; | |
var deserializeAws_restXmlListBucketInventoryConfigurationsCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlListBucketMetricsConfigurationsCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlListBucketMetricsConfigurationsCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body"); | |
if (data["ContinuationToken"] !== void 0) { | |
contents.ContinuationToken = (0, smithy_client_1.expectString)(data["ContinuationToken"]); | |
} | |
if (data["IsTruncated"] !== void 0) { | |
contents.IsTruncated = (0, smithy_client_1.parseBoolean)(data["IsTruncated"]); | |
} | |
if (data.MetricsConfiguration === "") { | |
contents.MetricsConfigurationList = []; | |
} else if (data["MetricsConfiguration"] !== void 0) { | |
contents.MetricsConfigurationList = deserializeAws_restXmlMetricsConfigurationList((0, smithy_client_1.getArrayIfSingleItem)(data["MetricsConfiguration"]), context); | |
} | |
if (data["NextContinuationToken"] !== void 0) { | |
contents.NextContinuationToken = (0, smithy_client_1.expectString)(data["NextContinuationToken"]); | |
} | |
return contents; | |
}; | |
exports.deserializeAws_restXmlListBucketMetricsConfigurationsCommand = deserializeAws_restXmlListBucketMetricsConfigurationsCommand; | |
var deserializeAws_restXmlListBucketMetricsConfigurationsCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlListBucketsCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlListBucketsCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body"); | |
if (data.Buckets === "") { | |
contents.Buckets = []; | |
} else if (data["Buckets"] !== void 0 && data["Buckets"]["Bucket"] !== void 0) { | |
contents.Buckets = deserializeAws_restXmlBuckets((0, smithy_client_1.getArrayIfSingleItem)(data["Buckets"]["Bucket"]), context); | |
} | |
if (data["Owner"] !== void 0) { | |
contents.Owner = deserializeAws_restXmlOwner(data["Owner"], context); | |
} | |
return contents; | |
}; | |
exports.deserializeAws_restXmlListBucketsCommand = deserializeAws_restXmlListBucketsCommand; | |
var deserializeAws_restXmlListBucketsCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlListMultipartUploadsCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlListMultipartUploadsCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body"); | |
if (data["Bucket"] !== void 0) { | |
contents.Bucket = (0, smithy_client_1.expectString)(data["Bucket"]); | |
} | |
if (data.CommonPrefixes === "") { | |
contents.CommonPrefixes = []; | |
} else if (data["CommonPrefixes"] !== void 0) { | |
contents.CommonPrefixes = deserializeAws_restXmlCommonPrefixList((0, smithy_client_1.getArrayIfSingleItem)(data["CommonPrefixes"]), context); | |
} | |
if (data["Delimiter"] !== void 0) { | |
contents.Delimiter = (0, smithy_client_1.expectString)(data["Delimiter"]); | |
} | |
if (data["EncodingType"] !== void 0) { | |
contents.EncodingType = (0, smithy_client_1.expectString)(data["EncodingType"]); | |
} | |
if (data["IsTruncated"] !== void 0) { | |
contents.IsTruncated = (0, smithy_client_1.parseBoolean)(data["IsTruncated"]); | |
} | |
if (data["KeyMarker"] !== void 0) { | |
contents.KeyMarker = (0, smithy_client_1.expectString)(data["KeyMarker"]); | |
} | |
if (data["MaxUploads"] !== void 0) { | |
contents.MaxUploads = (0, smithy_client_1.strictParseInt32)(data["MaxUploads"]); | |
} | |
if (data["NextKeyMarker"] !== void 0) { | |
contents.NextKeyMarker = (0, smithy_client_1.expectString)(data["NextKeyMarker"]); | |
} | |
if (data["NextUploadIdMarker"] !== void 0) { | |
contents.NextUploadIdMarker = (0, smithy_client_1.expectString)(data["NextUploadIdMarker"]); | |
} | |
if (data["Prefix"] !== void 0) { | |
contents.Prefix = (0, smithy_client_1.expectString)(data["Prefix"]); | |
} | |
if (data["UploadIdMarker"] !== void 0) { | |
contents.UploadIdMarker = (0, smithy_client_1.expectString)(data["UploadIdMarker"]); | |
} | |
if (data.Upload === "") { | |
contents.Uploads = []; | |
} else if (data["Upload"] !== void 0) { | |
contents.Uploads = deserializeAws_restXmlMultipartUploadList((0, smithy_client_1.getArrayIfSingleItem)(data["Upload"]), context); | |
} | |
return contents; | |
}; | |
exports.deserializeAws_restXmlListMultipartUploadsCommand = deserializeAws_restXmlListMultipartUploadsCommand; | |
var deserializeAws_restXmlListMultipartUploadsCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlListObjectsCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlListObjectsCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body"); | |
if (data.CommonPrefixes === "") { | |
contents.CommonPrefixes = []; | |
} else if (data["CommonPrefixes"] !== void 0) { | |
contents.CommonPrefixes = deserializeAws_restXmlCommonPrefixList((0, smithy_client_1.getArrayIfSingleItem)(data["CommonPrefixes"]), context); | |
} | |
if (data.Contents === "") { | |
contents.Contents = []; | |
} else if (data["Contents"] !== void 0) { | |
contents.Contents = deserializeAws_restXmlObjectList((0, smithy_client_1.getArrayIfSingleItem)(data["Contents"]), context); | |
} | |
if (data["Delimiter"] !== void 0) { | |
contents.Delimiter = (0, smithy_client_1.expectString)(data["Delimiter"]); | |
} | |
if (data["EncodingType"] !== void 0) { | |
contents.EncodingType = (0, smithy_client_1.expectString)(data["EncodingType"]); | |
} | |
if (data["IsTruncated"] !== void 0) { | |
contents.IsTruncated = (0, smithy_client_1.parseBoolean)(data["IsTruncated"]); | |
} | |
if (data["Marker"] !== void 0) { | |
contents.Marker = (0, smithy_client_1.expectString)(data["Marker"]); | |
} | |
if (data["MaxKeys"] !== void 0) { | |
contents.MaxKeys = (0, smithy_client_1.strictParseInt32)(data["MaxKeys"]); | |
} | |
if (data["Name"] !== void 0) { | |
contents.Name = (0, smithy_client_1.expectString)(data["Name"]); | |
} | |
if (data["NextMarker"] !== void 0) { | |
contents.NextMarker = (0, smithy_client_1.expectString)(data["NextMarker"]); | |
} | |
if (data["Prefix"] !== void 0) { | |
contents.Prefix = (0, smithy_client_1.expectString)(data["Prefix"]); | |
} | |
return contents; | |
}; | |
exports.deserializeAws_restXmlListObjectsCommand = deserializeAws_restXmlListObjectsCommand; | |
var deserializeAws_restXmlListObjectsCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
switch (errorCode) { | |
case "NoSuchBucket": | |
case "com.amazonaws.s3#NoSuchBucket": | |
throw await deserializeAws_restXmlNoSuchBucketResponse(parsedOutput, context); | |
default: | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
} | |
}; | |
var deserializeAws_restXmlListObjectsV2Command = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlListObjectsV2CommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body"); | |
if (data.CommonPrefixes === "") { | |
contents.CommonPrefixes = []; | |
} else if (data["CommonPrefixes"] !== void 0) { | |
contents.CommonPrefixes = deserializeAws_restXmlCommonPrefixList((0, smithy_client_1.getArrayIfSingleItem)(data["CommonPrefixes"]), context); | |
} | |
if (data.Contents === "") { | |
contents.Contents = []; | |
} else if (data["Contents"] !== void 0) { | |
contents.Contents = deserializeAws_restXmlObjectList((0, smithy_client_1.getArrayIfSingleItem)(data["Contents"]), context); | |
} | |
if (data["ContinuationToken"] !== void 0) { | |
contents.ContinuationToken = (0, smithy_client_1.expectString)(data["ContinuationToken"]); | |
} | |
if (data["Delimiter"] !== void 0) { | |
contents.Delimiter = (0, smithy_client_1.expectString)(data["Delimiter"]); | |
} | |
if (data["EncodingType"] !== void 0) { | |
contents.EncodingType = (0, smithy_client_1.expectString)(data["EncodingType"]); | |
} | |
if (data["IsTruncated"] !== void 0) { | |
contents.IsTruncated = (0, smithy_client_1.parseBoolean)(data["IsTruncated"]); | |
} | |
if (data["KeyCount"] !== void 0) { | |
contents.KeyCount = (0, smithy_client_1.strictParseInt32)(data["KeyCount"]); | |
} | |
if (data["MaxKeys"] !== void 0) { | |
contents.MaxKeys = (0, smithy_client_1.strictParseInt32)(data["MaxKeys"]); | |
} | |
if (data["Name"] !== void 0) { | |
contents.Name = (0, smithy_client_1.expectString)(data["Name"]); | |
} | |
if (data["NextContinuationToken"] !== void 0) { | |
contents.NextContinuationToken = (0, smithy_client_1.expectString)(data["NextContinuationToken"]); | |
} | |
if (data["Prefix"] !== void 0) { | |
contents.Prefix = (0, smithy_client_1.expectString)(data["Prefix"]); | |
} | |
if (data["StartAfter"] !== void 0) { | |
contents.StartAfter = (0, smithy_client_1.expectString)(data["StartAfter"]); | |
} | |
return contents; | |
}; | |
exports.deserializeAws_restXmlListObjectsV2Command = deserializeAws_restXmlListObjectsV2Command; | |
var deserializeAws_restXmlListObjectsV2CommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
switch (errorCode) { | |
case "NoSuchBucket": | |
case "com.amazonaws.s3#NoSuchBucket": | |
throw await deserializeAws_restXmlNoSuchBucketResponse(parsedOutput, context); | |
default: | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
} | |
}; | |
var deserializeAws_restXmlListObjectVersionsCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlListObjectVersionsCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body"); | |
if (data.CommonPrefixes === "") { | |
contents.CommonPrefixes = []; | |
} else if (data["CommonPrefixes"] !== void 0) { | |
contents.CommonPrefixes = deserializeAws_restXmlCommonPrefixList((0, smithy_client_1.getArrayIfSingleItem)(data["CommonPrefixes"]), context); | |
} | |
if (data.DeleteMarker === "") { | |
contents.DeleteMarkers = []; | |
} else if (data["DeleteMarker"] !== void 0) { | |
contents.DeleteMarkers = deserializeAws_restXmlDeleteMarkers((0, smithy_client_1.getArrayIfSingleItem)(data["DeleteMarker"]), context); | |
} | |
if (data["Delimiter"] !== void 0) { | |
contents.Delimiter = (0, smithy_client_1.expectString)(data["Delimiter"]); | |
} | |
if (data["EncodingType"] !== void 0) { | |
contents.EncodingType = (0, smithy_client_1.expectString)(data["EncodingType"]); | |
} | |
if (data["IsTruncated"] !== void 0) { | |
contents.IsTruncated = (0, smithy_client_1.parseBoolean)(data["IsTruncated"]); | |
} | |
if (data["KeyMarker"] !== void 0) { | |
contents.KeyMarker = (0, smithy_client_1.expectString)(data["KeyMarker"]); | |
} | |
if (data["MaxKeys"] !== void 0) { | |
contents.MaxKeys = (0, smithy_client_1.strictParseInt32)(data["MaxKeys"]); | |
} | |
if (data["Name"] !== void 0) { | |
contents.Name = (0, smithy_client_1.expectString)(data["Name"]); | |
} | |
if (data["NextKeyMarker"] !== void 0) { | |
contents.NextKeyMarker = (0, smithy_client_1.expectString)(data["NextKeyMarker"]); | |
} | |
if (data["NextVersionIdMarker"] !== void 0) { | |
contents.NextVersionIdMarker = (0, smithy_client_1.expectString)(data["NextVersionIdMarker"]); | |
} | |
if (data["Prefix"] !== void 0) { | |
contents.Prefix = (0, smithy_client_1.expectString)(data["Prefix"]); | |
} | |
if (data["VersionIdMarker"] !== void 0) { | |
contents.VersionIdMarker = (0, smithy_client_1.expectString)(data["VersionIdMarker"]); | |
} | |
if (data.Version === "") { | |
contents.Versions = []; | |
} else if (data["Version"] !== void 0) { | |
contents.Versions = deserializeAws_restXmlObjectVersionList((0, smithy_client_1.getArrayIfSingleItem)(data["Version"]), context); | |
} | |
return contents; | |
}; | |
exports.deserializeAws_restXmlListObjectVersionsCommand = deserializeAws_restXmlListObjectVersionsCommand; | |
var deserializeAws_restXmlListObjectVersionsCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlListPartsCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlListPartsCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output), | |
AbortDate: [ | |
() => void 0 !== output.headers["x-amz-abort-date"], | |
() => (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc7231DateTime)(output.headers["x-amz-abort-date"])) | |
], | |
AbortRuleId: [, output.headers["x-amz-abort-rule-id"]], | |
RequestCharged: [, output.headers["x-amz-request-charged"]] | |
}); | |
const data = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.expectObject)(await parseBody(output.body, context)), "body"); | |
if (data["Bucket"] !== void 0) { | |
contents.Bucket = (0, smithy_client_1.expectString)(data["Bucket"]); | |
} | |
if (data["ChecksumAlgorithm"] !== void 0) { | |
contents.ChecksumAlgorithm = (0, smithy_client_1.expectString)(data["ChecksumAlgorithm"]); | |
} | |
if (data["Initiator"] !== void 0) { | |
contents.Initiator = deserializeAws_restXmlInitiator(data["Initiator"], context); | |
} | |
if (data["IsTruncated"] !== void 0) { | |
contents.IsTruncated = (0, smithy_client_1.parseBoolean)(data["IsTruncated"]); | |
} | |
if (data["Key"] !== void 0) { | |
contents.Key = (0, smithy_client_1.expectString)(data["Key"]); | |
} | |
if (data["MaxParts"] !== void 0) { | |
contents.MaxParts = (0, smithy_client_1.strictParseInt32)(data["MaxParts"]); | |
} | |
if (data["NextPartNumberMarker"] !== void 0) { | |
contents.NextPartNumberMarker = (0, smithy_client_1.expectString)(data["NextPartNumberMarker"]); | |
} | |
if (data["Owner"] !== void 0) { | |
contents.Owner = deserializeAws_restXmlOwner(data["Owner"], context); | |
} | |
if (data["PartNumberMarker"] !== void 0) { | |
contents.PartNumberMarker = (0, smithy_client_1.expectString)(data["PartNumberMarker"]); | |
} | |
if (data.Part === "") { | |
contents.Parts = []; | |
} else if (data["Part"] !== void 0) { | |
contents.Parts = deserializeAws_restXmlParts((0, smithy_client_1.getArrayIfSingleItem)(data["Part"]), context); | |
} | |
if (data["StorageClass"] !== void 0) { | |
contents.StorageClass = (0, smithy_client_1.expectString)(data["StorageClass"]); | |
} | |
if (data["UploadId"] !== void 0) { | |
contents.UploadId = (0, smithy_client_1.expectString)(data["UploadId"]); | |
} | |
return contents; | |
}; | |
exports.deserializeAws_restXmlListPartsCommand = deserializeAws_restXmlListPartsCommand; | |
var deserializeAws_restXmlListPartsCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlPutBucketAccelerateConfigurationCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlPutBucketAccelerateConfigurationCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlPutBucketAccelerateConfigurationCommand = deserializeAws_restXmlPutBucketAccelerateConfigurationCommand; | |
var deserializeAws_restXmlPutBucketAccelerateConfigurationCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlPutBucketAclCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlPutBucketAclCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlPutBucketAclCommand = deserializeAws_restXmlPutBucketAclCommand; | |
var deserializeAws_restXmlPutBucketAclCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlPutBucketAnalyticsConfigurationCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlPutBucketAnalyticsConfigurationCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlPutBucketAnalyticsConfigurationCommand = deserializeAws_restXmlPutBucketAnalyticsConfigurationCommand; | |
var deserializeAws_restXmlPutBucketAnalyticsConfigurationCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlPutBucketCorsCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlPutBucketCorsCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlPutBucketCorsCommand = deserializeAws_restXmlPutBucketCorsCommand; | |
var deserializeAws_restXmlPutBucketCorsCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlPutBucketEncryptionCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlPutBucketEncryptionCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlPutBucketEncryptionCommand = deserializeAws_restXmlPutBucketEncryptionCommand; | |
var deserializeAws_restXmlPutBucketEncryptionCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlPutBucketIntelligentTieringConfigurationCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlPutBucketIntelligentTieringConfigurationCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlPutBucketIntelligentTieringConfigurationCommand = deserializeAws_restXmlPutBucketIntelligentTieringConfigurationCommand; | |
var deserializeAws_restXmlPutBucketIntelligentTieringConfigurationCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlPutBucketInventoryConfigurationCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlPutBucketInventoryConfigurationCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlPutBucketInventoryConfigurationCommand = deserializeAws_restXmlPutBucketInventoryConfigurationCommand; | |
var deserializeAws_restXmlPutBucketInventoryConfigurationCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlPutBucketLifecycleConfigurationCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlPutBucketLifecycleConfigurationCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlPutBucketLifecycleConfigurationCommand = deserializeAws_restXmlPutBucketLifecycleConfigurationCommand; | |
var deserializeAws_restXmlPutBucketLifecycleConfigurationCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlPutBucketLoggingCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlPutBucketLoggingCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlPutBucketLoggingCommand = deserializeAws_restXmlPutBucketLoggingCommand; | |
var deserializeAws_restXmlPutBucketLoggingCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlPutBucketMetricsConfigurationCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlPutBucketMetricsConfigurationCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlPutBucketMetricsConfigurationCommand = deserializeAws_restXmlPutBucketMetricsConfigurationCommand; | |
var deserializeAws_restXmlPutBucketMetricsConfigurationCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlPutBucketNotificationConfigurationCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlPutBucketNotificationConfigurationCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlPutBucketNotificationConfigurationCommand = deserializeAws_restXmlPutBucketNotificationConfigurationCommand; | |
var deserializeAws_restXmlPutBucketNotificationConfigurationCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlPutBucketOwnershipControlsCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlPutBucketOwnershipControlsCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlPutBucketOwnershipControlsCommand = deserializeAws_restXmlPutBucketOwnershipControlsCommand; | |
var deserializeAws_restXmlPutBucketOwnershipControlsCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlPutBucketPolicyCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlPutBucketPolicyCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlPutBucketPolicyCommand = deserializeAws_restXmlPutBucketPolicyCommand; | |
var deserializeAws_restXmlPutBucketPolicyCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlPutBucketReplicationCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlPutBucketReplicationCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlPutBucketReplicationCommand = deserializeAws_restXmlPutBucketReplicationCommand; | |
var deserializeAws_restXmlPutBucketReplicationCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlPutBucketRequestPaymentCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlPutBucketRequestPaymentCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlPutBucketRequestPaymentCommand = deserializeAws_restXmlPutBucketRequestPaymentCommand; | |
var deserializeAws_restXmlPutBucketRequestPaymentCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlPutBucketTaggingCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlPutBucketTaggingCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlPutBucketTaggingCommand = deserializeAws_restXmlPutBucketTaggingCommand; | |
var deserializeAws_restXmlPutBucketTaggingCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlPutBucketVersioningCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlPutBucketVersioningCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlPutBucketVersioningCommand = deserializeAws_restXmlPutBucketVersioningCommand; | |
var deserializeAws_restXmlPutBucketVersioningCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlPutBucketWebsiteCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlPutBucketWebsiteCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlPutBucketWebsiteCommand = deserializeAws_restXmlPutBucketWebsiteCommand; | |
var deserializeAws_restXmlPutBucketWebsiteCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlPutObjectCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlPutObjectCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output), | |
Expiration: [, output.headers["x-amz-expiration"]], | |
ETag: [, output.headers["etag"]], | |
ChecksumCRC32: [, output.headers["x-amz-checksum-crc32"]], | |
ChecksumCRC32C: [, output.headers["x-amz-checksum-crc32c"]], | |
ChecksumSHA1: [, output.headers["x-amz-checksum-sha1"]], | |
ChecksumSHA256: [, output.headers["x-amz-checksum-sha256"]], | |
ServerSideEncryption: [, output.headers["x-amz-server-side-encryption"]], | |
VersionId: [, output.headers["x-amz-version-id"]], | |
SSECustomerAlgorithm: [, output.headers["x-amz-server-side-encryption-customer-algorithm"]], | |
SSECustomerKeyMD5: [, output.headers["x-amz-server-side-encryption-customer-key-md5"]], | |
SSEKMSKeyId: [, output.headers["x-amz-server-side-encryption-aws-kms-key-id"]], | |
SSEKMSEncryptionContext: [, output.headers["x-amz-server-side-encryption-context"]], | |
BucketKeyEnabled: [ | |
() => void 0 !== output.headers["x-amz-server-side-encryption-bucket-key-enabled"], | |
() => (0, smithy_client_1.parseBoolean)(output.headers["x-amz-server-side-encryption-bucket-key-enabled"]) | |
], | |
RequestCharged: [, output.headers["x-amz-request-charged"]] | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlPutObjectCommand = deserializeAws_restXmlPutObjectCommand; | |
var deserializeAws_restXmlPutObjectCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlPutObjectAclCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlPutObjectAclCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output), | |
RequestCharged: [, output.headers["x-amz-request-charged"]] | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlPutObjectAclCommand = deserializeAws_restXmlPutObjectAclCommand; | |
var deserializeAws_restXmlPutObjectAclCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
switch (errorCode) { | |
case "NoSuchKey": | |
case "com.amazonaws.s3#NoSuchKey": | |
throw await deserializeAws_restXmlNoSuchKeyResponse(parsedOutput, context); | |
default: | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
} | |
}; | |
var deserializeAws_restXmlPutObjectLegalHoldCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlPutObjectLegalHoldCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output), | |
RequestCharged: [, output.headers["x-amz-request-charged"]] | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlPutObjectLegalHoldCommand = deserializeAws_restXmlPutObjectLegalHoldCommand; | |
var deserializeAws_restXmlPutObjectLegalHoldCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlPutObjectLockConfigurationCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlPutObjectLockConfigurationCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output), | |
RequestCharged: [, output.headers["x-amz-request-charged"]] | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlPutObjectLockConfigurationCommand = deserializeAws_restXmlPutObjectLockConfigurationCommand; | |
var deserializeAws_restXmlPutObjectLockConfigurationCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlPutObjectRetentionCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlPutObjectRetentionCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output), | |
RequestCharged: [, output.headers["x-amz-request-charged"]] | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlPutObjectRetentionCommand = deserializeAws_restXmlPutObjectRetentionCommand; | |
var deserializeAws_restXmlPutObjectRetentionCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlPutObjectTaggingCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlPutObjectTaggingCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output), | |
VersionId: [, output.headers["x-amz-version-id"]] | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlPutObjectTaggingCommand = deserializeAws_restXmlPutObjectTaggingCommand; | |
var deserializeAws_restXmlPutObjectTaggingCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlPutPublicAccessBlockCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlPutPublicAccessBlockCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlPutPublicAccessBlockCommand = deserializeAws_restXmlPutPublicAccessBlockCommand; | |
var deserializeAws_restXmlPutPublicAccessBlockCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlRestoreObjectCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlRestoreObjectCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output), | |
RequestCharged: [, output.headers["x-amz-request-charged"]], | |
RestoreOutputPath: [, output.headers["x-amz-restore-output-path"]] | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlRestoreObjectCommand = deserializeAws_restXmlRestoreObjectCommand; | |
var deserializeAws_restXmlRestoreObjectCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
switch (errorCode) { | |
case "ObjectAlreadyInActiveTierError": | |
case "com.amazonaws.s3#ObjectAlreadyInActiveTierError": | |
throw await deserializeAws_restXmlObjectAlreadyInActiveTierErrorResponse(parsedOutput, context); | |
default: | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
} | |
}; | |
var deserializeAws_restXmlSelectObjectContentCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlSelectObjectContentCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
const data = output.body; | |
contents.Payload = deserializeAws_restXmlSelectObjectContentEventStream(data, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlSelectObjectContentCommand = deserializeAws_restXmlSelectObjectContentCommand; | |
var deserializeAws_restXmlSelectObjectContentCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlUploadPartCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlUploadPartCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output), | |
ServerSideEncryption: [, output.headers["x-amz-server-side-encryption"]], | |
ETag: [, output.headers["etag"]], | |
ChecksumCRC32: [, output.headers["x-amz-checksum-crc32"]], | |
ChecksumCRC32C: [, output.headers["x-amz-checksum-crc32c"]], | |
ChecksumSHA1: [, output.headers["x-amz-checksum-sha1"]], | |
ChecksumSHA256: [, output.headers["x-amz-checksum-sha256"]], | |
SSECustomerAlgorithm: [, output.headers["x-amz-server-side-encryption-customer-algorithm"]], | |
SSECustomerKeyMD5: [, output.headers["x-amz-server-side-encryption-customer-key-md5"]], | |
SSEKMSKeyId: [, output.headers["x-amz-server-side-encryption-aws-kms-key-id"]], | |
BucketKeyEnabled: [ | |
() => void 0 !== output.headers["x-amz-server-side-encryption-bucket-key-enabled"], | |
() => (0, smithy_client_1.parseBoolean)(output.headers["x-amz-server-side-encryption-bucket-key-enabled"]) | |
], | |
RequestCharged: [, output.headers["x-amz-request-charged"]] | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlUploadPartCommand = deserializeAws_restXmlUploadPartCommand; | |
var deserializeAws_restXmlUploadPartCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlUploadPartCopyCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlUploadPartCopyCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output), | |
CopySourceVersionId: [, output.headers["x-amz-copy-source-version-id"]], | |
ServerSideEncryption: [, output.headers["x-amz-server-side-encryption"]], | |
SSECustomerAlgorithm: [, output.headers["x-amz-server-side-encryption-customer-algorithm"]], | |
SSECustomerKeyMD5: [, output.headers["x-amz-server-side-encryption-customer-key-md5"]], | |
SSEKMSKeyId: [, output.headers["x-amz-server-side-encryption-aws-kms-key-id"]], | |
BucketKeyEnabled: [ | |
() => void 0 !== output.headers["x-amz-server-side-encryption-bucket-key-enabled"], | |
() => (0, smithy_client_1.parseBoolean)(output.headers["x-amz-server-side-encryption-bucket-key-enabled"]) | |
], | |
RequestCharged: [, output.headers["x-amz-request-charged"]] | |
}); | |
const data = (0, smithy_client_1.expectObject)(await parseBody(output.body, context)); | |
contents.CopyPartResult = deserializeAws_restXmlCopyPartResult(data, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlUploadPartCopyCommand = deserializeAws_restXmlUploadPartCopyCommand; | |
var deserializeAws_restXmlUploadPartCopyCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var deserializeAws_restXmlWriteGetObjectResponseCommand = async (output, context) => { | |
if (output.statusCode !== 200 && output.statusCode >= 300) { | |
return deserializeAws_restXmlWriteGetObjectResponseCommandError(output, context); | |
} | |
const contents = map({ | |
$metadata: deserializeMetadata(output) | |
}); | |
await collectBody(output.body, context); | |
return contents; | |
}; | |
exports.deserializeAws_restXmlWriteGetObjectResponseCommand = deserializeAws_restXmlWriteGetObjectResponseCommand; | |
var deserializeAws_restXmlWriteGetObjectResponseCommandError = async (output, context) => { | |
const parsedOutput = { | |
...output, | |
body: await parseErrorBody(output.body, context) | |
}; | |
const errorCode = loadRestXmlErrorCode(output, parsedOutput.body); | |
const parsedBody = parsedOutput.body; | |
(0, smithy_client_1.throwDefaultError)({ | |
output, | |
parsedBody, | |
exceptionCtor: S3ServiceException_1.S3ServiceException, | |
errorCode | |
}); | |
}; | |
var map = smithy_client_1.map; | |
var deserializeAws_restXmlBucketAlreadyExistsResponse = async (parsedOutput, context) => { | |
const contents = map({}); | |
const data = parsedOutput.body; | |
const exception = new models_0_1.BucketAlreadyExists({ | |
$metadata: deserializeMetadata(parsedOutput), | |
...contents | |
}); | |
return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body); | |
}; | |
var deserializeAws_restXmlBucketAlreadyOwnedByYouResponse = async (parsedOutput, context) => { | |
const contents = map({}); | |
const data = parsedOutput.body; | |
const exception = new models_0_1.BucketAlreadyOwnedByYou({ | |
$metadata: deserializeMetadata(parsedOutput), | |
...contents | |
}); | |
return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body); | |
}; | |
var deserializeAws_restXmlInvalidObjectStateResponse = async (parsedOutput, context) => { | |
const contents = map({}); | |
const data = parsedOutput.body; | |
if (data["AccessTier"] !== void 0) { | |
contents.AccessTier = (0, smithy_client_1.expectString)(data["AccessTier"]); | |
} | |
if (data["StorageClass"] !== void 0) { | |
contents.StorageClass = (0, smithy_client_1.expectString)(data["StorageClass"]); | |
} | |
const exception = new models_0_1.InvalidObjectState({ | |
$metadata: deserializeMetadata(parsedOutput), | |
...contents | |
}); | |
return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body); | |
}; | |
var deserializeAws_restXmlNoSuchBucketResponse = async (parsedOutput, context) => { | |
const contents = map({}); | |
const data = parsedOutput.body; | |
const exception = new models_0_1.NoSuchBucket({ | |
$metadata: deserializeMetadata(parsedOutput), | |
...contents | |
}); | |
return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body); | |
}; | |
var deserializeAws_restXmlNoSuchKeyResponse = async (parsedOutput, context) => { | |
const contents = map({}); | |
const data = parsedOutput.body; | |
const exception = new models_0_1.NoSuchKey({ | |
$metadata: deserializeMetadata(parsedOutput), | |
...contents | |
}); | |
return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body); | |
}; | |
var deserializeAws_restXmlNoSuchUploadResponse = async (parsedOutput, context) => { | |
const contents = map({}); | |
const data = parsedOutput.body; | |
const exception = new models_0_1.NoSuchUpload({ | |
$metadata: deserializeMetadata(parsedOutput), | |
...contents | |
}); | |
return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body); | |
}; | |
var deserializeAws_restXmlNotFoundResponse = async (parsedOutput, context) => { | |
const contents = map({}); | |
const data = parsedOutput.body; | |
const exception = new models_0_1.NotFound({ | |
$metadata: deserializeMetadata(parsedOutput), | |
...contents | |
}); | |
return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body); | |
}; | |
var deserializeAws_restXmlObjectAlreadyInActiveTierErrorResponse = async (parsedOutput, context) => { | |
const contents = map({}); | |
const data = parsedOutput.body; | |
const exception = new models_1_1.ObjectAlreadyInActiveTierError({ | |
$metadata: deserializeMetadata(parsedOutput), | |
...contents | |
}); | |
return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body); | |
}; | |
var deserializeAws_restXmlObjectNotInActiveTierErrorResponse = async (parsedOutput, context) => { | |
const contents = map({}); | |
const data = parsedOutput.body; | |
const exception = new models_0_1.ObjectNotInActiveTierError({ | |
$metadata: deserializeMetadata(parsedOutput), | |
...contents | |
}); | |
return (0, smithy_client_1.decorateServiceException)(exception, parsedOutput.body); | |
}; | |
var deserializeAws_restXmlSelectObjectContentEventStream = (output, context) => { | |
return context.eventStreamMarshaller.deserialize(output, async (event) => { | |
if (event["Records"] != null) { | |
return { | |
Records: await deserializeAws_restXmlRecordsEvent_event(event["Records"], context) | |
}; | |
} | |
if (event["Stats"] != null) { | |
return { | |
Stats: await deserializeAws_restXmlStatsEvent_event(event["Stats"], context) | |
}; | |
} | |
if (event["Progress"] != null) { | |
return { | |
Progress: await deserializeAws_restXmlProgressEvent_event(event["Progress"], context) | |
}; | |
} | |
if (event["Cont"] != null) { | |
return { | |
Cont: await deserializeAws_restXmlContinuationEvent_event(event["Cont"], context) | |
}; | |
} | |
if (event["End"] != null) { | |
return { | |
End: await deserializeAws_restXmlEndEvent_event(event["End"], context) | |
}; | |
} | |
return { $unknown: output }; | |
}); | |
}; | |
var deserializeAws_restXmlContinuationEvent_event = async (output, context) => { | |
const contents = {}; | |
const data = await parseBody(output.body, context); | |
Object.assign(contents, deserializeAws_restXmlContinuationEvent(data, context)); | |
return contents; | |
}; | |
var deserializeAws_restXmlEndEvent_event = async (output, context) => { | |
const contents = {}; | |
const data = await parseBody(output.body, context); | |
Object.assign(contents, deserializeAws_restXmlEndEvent(data, context)); | |
return contents; | |
}; | |
var deserializeAws_restXmlProgressEvent_event = async (output, context) => { | |
const contents = {}; | |
const data = await parseBody(output.body, context); | |
contents.Details = deserializeAws_restXmlProgress(data, context); | |
return contents; | |
}; | |
var deserializeAws_restXmlRecordsEvent_event = async (output, context) => { | |
const contents = {}; | |
contents.Payload = output.body; | |
return contents; | |
}; | |
var deserializeAws_restXmlStatsEvent_event = async (output, context) => { | |
const contents = {}; | |
const data = await parseBody(output.body, context); | |
contents.Details = deserializeAws_restXmlStats(data, context); | |
return contents; | |
}; | |
var serializeAws_restXmlAbortIncompleteMultipartUpload = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("AbortIncompleteMultipartUpload"); | |
if (input.DaysAfterInitiation != null) { | |
const node = xml_builder_1.XmlNode.of("DaysAfterInitiation", String(input.DaysAfterInitiation)).withName("DaysAfterInitiation"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlAccelerateConfiguration = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("AccelerateConfiguration"); | |
if (input.Status != null) { | |
const node = xml_builder_1.XmlNode.of("BucketAccelerateStatus", input.Status).withName("Status"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlAccessControlPolicy = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("AccessControlPolicy"); | |
if (input.Grants != null) { | |
const nodes = serializeAws_restXmlGrants(input.Grants, context); | |
const containerNode = new xml_builder_1.XmlNode("AccessControlList"); | |
nodes.map((node) => { | |
containerNode.addChildNode(node); | |
}); | |
bodyNode.addChildNode(containerNode); | |
} | |
if (input.Owner != null) { | |
const node = serializeAws_restXmlOwner(input.Owner, context).withName("Owner"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlAccessControlTranslation = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("AccessControlTranslation"); | |
if (input.Owner != null) { | |
const node = xml_builder_1.XmlNode.of("OwnerOverride", input.Owner).withName("Owner"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlAllowedHeaders = (input, context) => { | |
return input.filter((e) => e != null).map((entry) => { | |
const node = xml_builder_1.XmlNode.of("AllowedHeader", entry); | |
return node.withName("member"); | |
}); | |
}; | |
var serializeAws_restXmlAllowedMethods = (input, context) => { | |
return input.filter((e) => e != null).map((entry) => { | |
const node = xml_builder_1.XmlNode.of("AllowedMethod", entry); | |
return node.withName("member"); | |
}); | |
}; | |
var serializeAws_restXmlAllowedOrigins = (input, context) => { | |
return input.filter((e) => e != null).map((entry) => { | |
const node = xml_builder_1.XmlNode.of("AllowedOrigin", entry); | |
return node.withName("member"); | |
}); | |
}; | |
var serializeAws_restXmlAnalyticsAndOperator = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("AnalyticsAndOperator"); | |
if (input.Prefix != null) { | |
const node = xml_builder_1.XmlNode.of("Prefix", input.Prefix).withName("Prefix"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Tags != null) { | |
const nodes = serializeAws_restXmlTagSet(input.Tags, context); | |
nodes.map((node) => { | |
node = node.withName("Tag"); | |
bodyNode.addChildNode(node); | |
}); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlAnalyticsConfiguration = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("AnalyticsConfiguration"); | |
if (input.Id != null) { | |
const node = xml_builder_1.XmlNode.of("AnalyticsId", input.Id).withName("Id"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Filter != null) { | |
const node = serializeAws_restXmlAnalyticsFilter(input.Filter, context).withName("Filter"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.StorageClassAnalysis != null) { | |
const node = serializeAws_restXmlStorageClassAnalysis(input.StorageClassAnalysis, context).withName("StorageClassAnalysis"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlAnalyticsExportDestination = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("AnalyticsExportDestination"); | |
if (input.S3BucketDestination != null) { | |
const node = serializeAws_restXmlAnalyticsS3BucketDestination(input.S3BucketDestination, context).withName("S3BucketDestination"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlAnalyticsFilter = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("AnalyticsFilter"); | |
models_0_1.AnalyticsFilter.visit(input, { | |
Prefix: (value) => { | |
const node = xml_builder_1.XmlNode.of("Prefix", value).withName("Prefix"); | |
bodyNode.addChildNode(node); | |
}, | |
Tag: (value) => { | |
const node = serializeAws_restXmlTag(value, context).withName("Tag"); | |
bodyNode.addChildNode(node); | |
}, | |
And: (value) => { | |
const node = serializeAws_restXmlAnalyticsAndOperator(value, context).withName("And"); | |
bodyNode.addChildNode(node); | |
}, | |
_: (name, value) => { | |
if (!(value instanceof xml_builder_1.XmlNode || value instanceof xml_builder_1.XmlText)) { | |
throw new Error("Unable to serialize unknown union members in XML."); | |
} | |
bodyNode.addChildNode(new xml_builder_1.XmlNode(name).addChildNode(value)); | |
} | |
}); | |
return bodyNode; | |
}; | |
var serializeAws_restXmlAnalyticsS3BucketDestination = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("AnalyticsS3BucketDestination"); | |
if (input.Format != null) { | |
const node = xml_builder_1.XmlNode.of("AnalyticsS3ExportFileFormat", input.Format).withName("Format"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.BucketAccountId != null) { | |
const node = xml_builder_1.XmlNode.of("AccountId", input.BucketAccountId).withName("BucketAccountId"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Bucket != null) { | |
const node = xml_builder_1.XmlNode.of("BucketName", input.Bucket).withName("Bucket"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Prefix != null) { | |
const node = xml_builder_1.XmlNode.of("Prefix", input.Prefix).withName("Prefix"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlBucketLifecycleConfiguration = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("BucketLifecycleConfiguration"); | |
if (input.Rules != null) { | |
const nodes = serializeAws_restXmlLifecycleRules(input.Rules, context); | |
nodes.map((node) => { | |
node = node.withName("Rule"); | |
bodyNode.addChildNode(node); | |
}); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlBucketLoggingStatus = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("BucketLoggingStatus"); | |
if (input.LoggingEnabled != null) { | |
const node = serializeAws_restXmlLoggingEnabled(input.LoggingEnabled, context).withName("LoggingEnabled"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlCompletedMultipartUpload = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("CompletedMultipartUpload"); | |
if (input.Parts != null) { | |
const nodes = serializeAws_restXmlCompletedPartList(input.Parts, context); | |
nodes.map((node) => { | |
node = node.withName("Part"); | |
bodyNode.addChildNode(node); | |
}); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlCompletedPart = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("CompletedPart"); | |
if (input.ETag != null) { | |
const node = xml_builder_1.XmlNode.of("ETag", input.ETag).withName("ETag"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.ChecksumCRC32 != null) { | |
const node = xml_builder_1.XmlNode.of("ChecksumCRC32", input.ChecksumCRC32).withName("ChecksumCRC32"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.ChecksumCRC32C != null) { | |
const node = xml_builder_1.XmlNode.of("ChecksumCRC32C", input.ChecksumCRC32C).withName("ChecksumCRC32C"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.ChecksumSHA1 != null) { | |
const node = xml_builder_1.XmlNode.of("ChecksumSHA1", input.ChecksumSHA1).withName("ChecksumSHA1"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.ChecksumSHA256 != null) { | |
const node = xml_builder_1.XmlNode.of("ChecksumSHA256", input.ChecksumSHA256).withName("ChecksumSHA256"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.PartNumber != null) { | |
const node = xml_builder_1.XmlNode.of("PartNumber", String(input.PartNumber)).withName("PartNumber"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlCompletedPartList = (input, context) => { | |
return input.filter((e) => e != null).map((entry) => { | |
const node = serializeAws_restXmlCompletedPart(entry, context); | |
return node.withName("member"); | |
}); | |
}; | |
var serializeAws_restXmlCondition = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("Condition"); | |
if (input.HttpErrorCodeReturnedEquals != null) { | |
const node = xml_builder_1.XmlNode.of("HttpErrorCodeReturnedEquals", input.HttpErrorCodeReturnedEquals).withName("HttpErrorCodeReturnedEquals"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.KeyPrefixEquals != null) { | |
const node = xml_builder_1.XmlNode.of("KeyPrefixEquals", input.KeyPrefixEquals).withName("KeyPrefixEquals"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlCORSConfiguration = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("CORSConfiguration"); | |
if (input.CORSRules != null) { | |
const nodes = serializeAws_restXmlCORSRules(input.CORSRules, context); | |
nodes.map((node) => { | |
node = node.withName("CORSRule"); | |
bodyNode.addChildNode(node); | |
}); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlCORSRule = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("CORSRule"); | |
if (input.ID != null) { | |
const node = xml_builder_1.XmlNode.of("ID", input.ID).withName("ID"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.AllowedHeaders != null) { | |
const nodes = serializeAws_restXmlAllowedHeaders(input.AllowedHeaders, context); | |
nodes.map((node) => { | |
node = node.withName("AllowedHeader"); | |
bodyNode.addChildNode(node); | |
}); | |
} | |
if (input.AllowedMethods != null) { | |
const nodes = serializeAws_restXmlAllowedMethods(input.AllowedMethods, context); | |
nodes.map((node) => { | |
node = node.withName("AllowedMethod"); | |
bodyNode.addChildNode(node); | |
}); | |
} | |
if (input.AllowedOrigins != null) { | |
const nodes = serializeAws_restXmlAllowedOrigins(input.AllowedOrigins, context); | |
nodes.map((node) => { | |
node = node.withName("AllowedOrigin"); | |
bodyNode.addChildNode(node); | |
}); | |
} | |
if (input.ExposeHeaders != null) { | |
const nodes = serializeAws_restXmlExposeHeaders(input.ExposeHeaders, context); | |
nodes.map((node) => { | |
node = node.withName("ExposeHeader"); | |
bodyNode.addChildNode(node); | |
}); | |
} | |
if (input.MaxAgeSeconds != null) { | |
const node = xml_builder_1.XmlNode.of("MaxAgeSeconds", String(input.MaxAgeSeconds)).withName("MaxAgeSeconds"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlCORSRules = (input, context) => { | |
return input.filter((e) => e != null).map((entry) => { | |
const node = serializeAws_restXmlCORSRule(entry, context); | |
return node.withName("member"); | |
}); | |
}; | |
var serializeAws_restXmlCreateBucketConfiguration = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("CreateBucketConfiguration"); | |
if (input.LocationConstraint != null) { | |
const node = xml_builder_1.XmlNode.of("BucketLocationConstraint", input.LocationConstraint).withName("LocationConstraint"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlCSVInput = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("CSVInput"); | |
if (input.FileHeaderInfo != null) { | |
const node = xml_builder_1.XmlNode.of("FileHeaderInfo", input.FileHeaderInfo).withName("FileHeaderInfo"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Comments != null) { | |
const node = xml_builder_1.XmlNode.of("Comments", input.Comments).withName("Comments"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.QuoteEscapeCharacter != null) { | |
const node = xml_builder_1.XmlNode.of("QuoteEscapeCharacter", input.QuoteEscapeCharacter).withName("QuoteEscapeCharacter"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.RecordDelimiter != null) { | |
const node = xml_builder_1.XmlNode.of("RecordDelimiter", input.RecordDelimiter).withName("RecordDelimiter"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.FieldDelimiter != null) { | |
const node = xml_builder_1.XmlNode.of("FieldDelimiter", input.FieldDelimiter).withName("FieldDelimiter"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.QuoteCharacter != null) { | |
const node = xml_builder_1.XmlNode.of("QuoteCharacter", input.QuoteCharacter).withName("QuoteCharacter"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.AllowQuotedRecordDelimiter != null) { | |
const node = xml_builder_1.XmlNode.of("AllowQuotedRecordDelimiter", String(input.AllowQuotedRecordDelimiter)).withName("AllowQuotedRecordDelimiter"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlCSVOutput = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("CSVOutput"); | |
if (input.QuoteFields != null) { | |
const node = xml_builder_1.XmlNode.of("QuoteFields", input.QuoteFields).withName("QuoteFields"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.QuoteEscapeCharacter != null) { | |
const node = xml_builder_1.XmlNode.of("QuoteEscapeCharacter", input.QuoteEscapeCharacter).withName("QuoteEscapeCharacter"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.RecordDelimiter != null) { | |
const node = xml_builder_1.XmlNode.of("RecordDelimiter", input.RecordDelimiter).withName("RecordDelimiter"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.FieldDelimiter != null) { | |
const node = xml_builder_1.XmlNode.of("FieldDelimiter", input.FieldDelimiter).withName("FieldDelimiter"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.QuoteCharacter != null) { | |
const node = xml_builder_1.XmlNode.of("QuoteCharacter", input.QuoteCharacter).withName("QuoteCharacter"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlDefaultRetention = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("DefaultRetention"); | |
if (input.Mode != null) { | |
const node = xml_builder_1.XmlNode.of("ObjectLockRetentionMode", input.Mode).withName("Mode"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Days != null) { | |
const node = xml_builder_1.XmlNode.of("Days", String(input.Days)).withName("Days"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Years != null) { | |
const node = xml_builder_1.XmlNode.of("Years", String(input.Years)).withName("Years"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlDelete = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("Delete"); | |
if (input.Objects != null) { | |
const nodes = serializeAws_restXmlObjectIdentifierList(input.Objects, context); | |
nodes.map((node) => { | |
node = node.withName("Object"); | |
bodyNode.addChildNode(node); | |
}); | |
} | |
if (input.Quiet != null) { | |
const node = xml_builder_1.XmlNode.of("Quiet", String(input.Quiet)).withName("Quiet"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlDeleteMarkerReplication = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("DeleteMarkerReplication"); | |
if (input.Status != null) { | |
const node = xml_builder_1.XmlNode.of("DeleteMarkerReplicationStatus", input.Status).withName("Status"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlDestination = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("Destination"); | |
if (input.Bucket != null) { | |
const node = xml_builder_1.XmlNode.of("BucketName", input.Bucket).withName("Bucket"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Account != null) { | |
const node = xml_builder_1.XmlNode.of("AccountId", input.Account).withName("Account"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.StorageClass != null) { | |
const node = xml_builder_1.XmlNode.of("StorageClass", input.StorageClass).withName("StorageClass"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.AccessControlTranslation != null) { | |
const node = serializeAws_restXmlAccessControlTranslation(input.AccessControlTranslation, context).withName("AccessControlTranslation"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.EncryptionConfiguration != null) { | |
const node = serializeAws_restXmlEncryptionConfiguration(input.EncryptionConfiguration, context).withName("EncryptionConfiguration"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.ReplicationTime != null) { | |
const node = serializeAws_restXmlReplicationTime(input.ReplicationTime, context).withName("ReplicationTime"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Metrics != null) { | |
const node = serializeAws_restXmlMetrics(input.Metrics, context).withName("Metrics"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlEncryption = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("Encryption"); | |
if (input.EncryptionType != null) { | |
const node = xml_builder_1.XmlNode.of("ServerSideEncryption", input.EncryptionType).withName("EncryptionType"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.KMSKeyId != null) { | |
const node = xml_builder_1.XmlNode.of("SSEKMSKeyId", input.KMSKeyId).withName("KMSKeyId"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.KMSContext != null) { | |
const node = xml_builder_1.XmlNode.of("KMSContext", input.KMSContext).withName("KMSContext"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlEncryptionConfiguration = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("EncryptionConfiguration"); | |
if (input.ReplicaKmsKeyID != null) { | |
const node = xml_builder_1.XmlNode.of("ReplicaKmsKeyID", input.ReplicaKmsKeyID).withName("ReplicaKmsKeyID"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlErrorDocument = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("ErrorDocument"); | |
if (input.Key != null) { | |
const node = xml_builder_1.XmlNode.of("ObjectKey", input.Key).withName("Key"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlEventBridgeConfiguration = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("EventBridgeConfiguration"); | |
return bodyNode; | |
}; | |
var serializeAws_restXmlEventList = (input, context) => { | |
return input.filter((e) => e != null).map((entry) => { | |
const node = xml_builder_1.XmlNode.of("Event", entry); | |
return node.withName("member"); | |
}); | |
}; | |
var serializeAws_restXmlExistingObjectReplication = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("ExistingObjectReplication"); | |
if (input.Status != null) { | |
const node = xml_builder_1.XmlNode.of("ExistingObjectReplicationStatus", input.Status).withName("Status"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlExposeHeaders = (input, context) => { | |
return input.filter((e) => e != null).map((entry) => { | |
const node = xml_builder_1.XmlNode.of("ExposeHeader", entry); | |
return node.withName("member"); | |
}); | |
}; | |
var serializeAws_restXmlFilterRule = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("FilterRule"); | |
if (input.Name != null) { | |
const node = xml_builder_1.XmlNode.of("FilterRuleName", input.Name).withName("Name"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Value != null) { | |
const node = xml_builder_1.XmlNode.of("FilterRuleValue", input.Value).withName("Value"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlFilterRuleList = (input, context) => { | |
return input.filter((e) => e != null).map((entry) => { | |
const node = serializeAws_restXmlFilterRule(entry, context); | |
return node.withName("member"); | |
}); | |
}; | |
var serializeAws_restXmlGlacierJobParameters = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("GlacierJobParameters"); | |
if (input.Tier != null) { | |
const node = xml_builder_1.XmlNode.of("Tier", input.Tier).withName("Tier"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlGrant = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("Grant"); | |
if (input.Grantee != null) { | |
const node = serializeAws_restXmlGrantee(input.Grantee, context).withName("Grantee"); | |
node.addAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Permission != null) { | |
const node = xml_builder_1.XmlNode.of("Permission", input.Permission).withName("Permission"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlGrantee = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("Grantee"); | |
if (input.DisplayName != null) { | |
const node = xml_builder_1.XmlNode.of("DisplayName", input.DisplayName).withName("DisplayName"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.EmailAddress != null) { | |
const node = xml_builder_1.XmlNode.of("EmailAddress", input.EmailAddress).withName("EmailAddress"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.ID != null) { | |
const node = xml_builder_1.XmlNode.of("ID", input.ID).withName("ID"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.URI != null) { | |
const node = xml_builder_1.XmlNode.of("URI", input.URI).withName("URI"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Type != null) { | |
bodyNode.addAttribute("xsi:type", input.Type); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlGrants = (input, context) => { | |
return input.filter((e) => e != null).map((entry) => { | |
const node = serializeAws_restXmlGrant(entry, context); | |
return node.withName("Grant"); | |
}); | |
}; | |
var serializeAws_restXmlIndexDocument = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("IndexDocument"); | |
if (input.Suffix != null) { | |
const node = xml_builder_1.XmlNode.of("Suffix", input.Suffix).withName("Suffix"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlInputSerialization = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("InputSerialization"); | |
if (input.CSV != null) { | |
const node = serializeAws_restXmlCSVInput(input.CSV, context).withName("CSV"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.CompressionType != null) { | |
const node = xml_builder_1.XmlNode.of("CompressionType", input.CompressionType).withName("CompressionType"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.JSON != null) { | |
const node = serializeAws_restXmlJSONInput(input.JSON, context).withName("JSON"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Parquet != null) { | |
const node = serializeAws_restXmlParquetInput(input.Parquet, context).withName("Parquet"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlIntelligentTieringAndOperator = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("IntelligentTieringAndOperator"); | |
if (input.Prefix != null) { | |
const node = xml_builder_1.XmlNode.of("Prefix", input.Prefix).withName("Prefix"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Tags != null) { | |
const nodes = serializeAws_restXmlTagSet(input.Tags, context); | |
nodes.map((node) => { | |
node = node.withName("Tag"); | |
bodyNode.addChildNode(node); | |
}); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlIntelligentTieringConfiguration = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("IntelligentTieringConfiguration"); | |
if (input.Id != null) { | |
const node = xml_builder_1.XmlNode.of("IntelligentTieringId", input.Id).withName("Id"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Filter != null) { | |
const node = serializeAws_restXmlIntelligentTieringFilter(input.Filter, context).withName("Filter"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Status != null) { | |
const node = xml_builder_1.XmlNode.of("IntelligentTieringStatus", input.Status).withName("Status"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Tierings != null) { | |
const nodes = serializeAws_restXmlTieringList(input.Tierings, context); | |
nodes.map((node) => { | |
node = node.withName("Tiering"); | |
bodyNode.addChildNode(node); | |
}); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlIntelligentTieringFilter = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("IntelligentTieringFilter"); | |
if (input.Prefix != null) { | |
const node = xml_builder_1.XmlNode.of("Prefix", input.Prefix).withName("Prefix"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Tag != null) { | |
const node = serializeAws_restXmlTag(input.Tag, context).withName("Tag"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.And != null) { | |
const node = serializeAws_restXmlIntelligentTieringAndOperator(input.And, context).withName("And"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlInventoryConfiguration = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("InventoryConfiguration"); | |
if (input.Destination != null) { | |
const node = serializeAws_restXmlInventoryDestination(input.Destination, context).withName("Destination"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.IsEnabled != null) { | |
const node = xml_builder_1.XmlNode.of("IsEnabled", String(input.IsEnabled)).withName("IsEnabled"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Filter != null) { | |
const node = serializeAws_restXmlInventoryFilter(input.Filter, context).withName("Filter"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Id != null) { | |
const node = xml_builder_1.XmlNode.of("InventoryId", input.Id).withName("Id"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.IncludedObjectVersions != null) { | |
const node = xml_builder_1.XmlNode.of("InventoryIncludedObjectVersions", input.IncludedObjectVersions).withName("IncludedObjectVersions"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.OptionalFields != null) { | |
const nodes = serializeAws_restXmlInventoryOptionalFields(input.OptionalFields, context); | |
const containerNode = new xml_builder_1.XmlNode("OptionalFields"); | |
nodes.map((node) => { | |
containerNode.addChildNode(node); | |
}); | |
bodyNode.addChildNode(containerNode); | |
} | |
if (input.Schedule != null) { | |
const node = serializeAws_restXmlInventorySchedule(input.Schedule, context).withName("Schedule"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlInventoryDestination = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("InventoryDestination"); | |
if (input.S3BucketDestination != null) { | |
const node = serializeAws_restXmlInventoryS3BucketDestination(input.S3BucketDestination, context).withName("S3BucketDestination"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlInventoryEncryption = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("InventoryEncryption"); | |
if (input.SSES3 != null) { | |
const node = serializeAws_restXmlSSES3(input.SSES3, context).withName("SSE-S3"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.SSEKMS != null) { | |
const node = serializeAws_restXmlSSEKMS(input.SSEKMS, context).withName("SSE-KMS"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlInventoryFilter = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("InventoryFilter"); | |
if (input.Prefix != null) { | |
const node = xml_builder_1.XmlNode.of("Prefix", input.Prefix).withName("Prefix"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlInventoryOptionalFields = (input, context) => { | |
return input.filter((e) => e != null).map((entry) => { | |
const node = xml_builder_1.XmlNode.of("InventoryOptionalField", entry); | |
return node.withName("Field"); | |
}); | |
}; | |
var serializeAws_restXmlInventoryS3BucketDestination = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("InventoryS3BucketDestination"); | |
if (input.AccountId != null) { | |
const node = xml_builder_1.XmlNode.of("AccountId", input.AccountId).withName("AccountId"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Bucket != null) { | |
const node = xml_builder_1.XmlNode.of("BucketName", input.Bucket).withName("Bucket"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Format != null) { | |
const node = xml_builder_1.XmlNode.of("InventoryFormat", input.Format).withName("Format"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Prefix != null) { | |
const node = xml_builder_1.XmlNode.of("Prefix", input.Prefix).withName("Prefix"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Encryption != null) { | |
const node = serializeAws_restXmlInventoryEncryption(input.Encryption, context).withName("Encryption"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlInventorySchedule = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("InventorySchedule"); | |
if (input.Frequency != null) { | |
const node = xml_builder_1.XmlNode.of("InventoryFrequency", input.Frequency).withName("Frequency"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlJSONInput = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("JSONInput"); | |
if (input.Type != null) { | |
const node = xml_builder_1.XmlNode.of("JSONType", input.Type).withName("Type"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlJSONOutput = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("JSONOutput"); | |
if (input.RecordDelimiter != null) { | |
const node = xml_builder_1.XmlNode.of("RecordDelimiter", input.RecordDelimiter).withName("RecordDelimiter"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlLambdaFunctionConfiguration = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("LambdaFunctionConfiguration"); | |
if (input.Id != null) { | |
const node = xml_builder_1.XmlNode.of("NotificationId", input.Id).withName("Id"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.LambdaFunctionArn != null) { | |
const node = xml_builder_1.XmlNode.of("LambdaFunctionArn", input.LambdaFunctionArn).withName("CloudFunction"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Events != null) { | |
const nodes = serializeAws_restXmlEventList(input.Events, context); | |
nodes.map((node) => { | |
node = node.withName("Event"); | |
bodyNode.addChildNode(node); | |
}); | |
} | |
if (input.Filter != null) { | |
const node = serializeAws_restXmlNotificationConfigurationFilter(input.Filter, context).withName("Filter"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlLambdaFunctionConfigurationList = (input, context) => { | |
return input.filter((e) => e != null).map((entry) => { | |
const node = serializeAws_restXmlLambdaFunctionConfiguration(entry, context); | |
return node.withName("member"); | |
}); | |
}; | |
var serializeAws_restXmlLifecycleExpiration = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("LifecycleExpiration"); | |
if (input.Date != null) { | |
const node = xml_builder_1.XmlNode.of("Date", (input.Date.toISOString().split(".")[0] + "Z").toString()).withName("Date"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Days != null) { | |
const node = xml_builder_1.XmlNode.of("Days", String(input.Days)).withName("Days"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.ExpiredObjectDeleteMarker != null) { | |
const node = xml_builder_1.XmlNode.of("ExpiredObjectDeleteMarker", String(input.ExpiredObjectDeleteMarker)).withName("ExpiredObjectDeleteMarker"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlLifecycleRule = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("LifecycleRule"); | |
if (input.Expiration != null) { | |
const node = serializeAws_restXmlLifecycleExpiration(input.Expiration, context).withName("Expiration"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.ID != null) { | |
const node = xml_builder_1.XmlNode.of("ID", input.ID).withName("ID"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Prefix != null) { | |
const node = xml_builder_1.XmlNode.of("Prefix", input.Prefix).withName("Prefix"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Filter != null) { | |
const node = serializeAws_restXmlLifecycleRuleFilter(input.Filter, context).withName("Filter"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Status != null) { | |
const node = xml_builder_1.XmlNode.of("ExpirationStatus", input.Status).withName("Status"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Transitions != null) { | |
const nodes = serializeAws_restXmlTransitionList(input.Transitions, context); | |
nodes.map((node) => { | |
node = node.withName("Transition"); | |
bodyNode.addChildNode(node); | |
}); | |
} | |
if (input.NoncurrentVersionTransitions != null) { | |
const nodes = serializeAws_restXmlNoncurrentVersionTransitionList(input.NoncurrentVersionTransitions, context); | |
nodes.map((node) => { | |
node = node.withName("NoncurrentVersionTransition"); | |
bodyNode.addChildNode(node); | |
}); | |
} | |
if (input.NoncurrentVersionExpiration != null) { | |
const node = serializeAws_restXmlNoncurrentVersionExpiration(input.NoncurrentVersionExpiration, context).withName("NoncurrentVersionExpiration"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.AbortIncompleteMultipartUpload != null) { | |
const node = serializeAws_restXmlAbortIncompleteMultipartUpload(input.AbortIncompleteMultipartUpload, context).withName("AbortIncompleteMultipartUpload"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlLifecycleRuleAndOperator = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("LifecycleRuleAndOperator"); | |
if (input.Prefix != null) { | |
const node = xml_builder_1.XmlNode.of("Prefix", input.Prefix).withName("Prefix"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Tags != null) { | |
const nodes = serializeAws_restXmlTagSet(input.Tags, context); | |
nodes.map((node) => { | |
node = node.withName("Tag"); | |
bodyNode.addChildNode(node); | |
}); | |
} | |
if (input.ObjectSizeGreaterThan != null) { | |
const node = xml_builder_1.XmlNode.of("ObjectSizeGreaterThanBytes", String(input.ObjectSizeGreaterThan)).withName("ObjectSizeGreaterThan"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.ObjectSizeLessThan != null) { | |
const node = xml_builder_1.XmlNode.of("ObjectSizeLessThanBytes", String(input.ObjectSizeLessThan)).withName("ObjectSizeLessThan"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlLifecycleRuleFilter = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("LifecycleRuleFilter"); | |
models_0_1.LifecycleRuleFilter.visit(input, { | |
Prefix: (value) => { | |
const node = xml_builder_1.XmlNode.of("Prefix", value).withName("Prefix"); | |
bodyNode.addChildNode(node); | |
}, | |
Tag: (value) => { | |
const node = serializeAws_restXmlTag(value, context).withName("Tag"); | |
bodyNode.addChildNode(node); | |
}, | |
ObjectSizeGreaterThan: (value) => { | |
const node = xml_builder_1.XmlNode.of("ObjectSizeGreaterThanBytes", String(value)).withName("ObjectSizeGreaterThan"); | |
bodyNode.addChildNode(node); | |
}, | |
ObjectSizeLessThan: (value) => { | |
const node = xml_builder_1.XmlNode.of("ObjectSizeLessThanBytes", String(value)).withName("ObjectSizeLessThan"); | |
bodyNode.addChildNode(node); | |
}, | |
And: (value) => { | |
const node = serializeAws_restXmlLifecycleRuleAndOperator(value, context).withName("And"); | |
bodyNode.addChildNode(node); | |
}, | |
_: (name, value) => { | |
if (!(value instanceof xml_builder_1.XmlNode || value instanceof xml_builder_1.XmlText)) { | |
throw new Error("Unable to serialize unknown union members in XML."); | |
} | |
bodyNode.addChildNode(new xml_builder_1.XmlNode(name).addChildNode(value)); | |
} | |
}); | |
return bodyNode; | |
}; | |
var serializeAws_restXmlLifecycleRules = (input, context) => { | |
return input.filter((e) => e != null).map((entry) => { | |
const node = serializeAws_restXmlLifecycleRule(entry, context); | |
return node.withName("member"); | |
}); | |
}; | |
var serializeAws_restXmlLoggingEnabled = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("LoggingEnabled"); | |
if (input.TargetBucket != null) { | |
const node = xml_builder_1.XmlNode.of("TargetBucket", input.TargetBucket).withName("TargetBucket"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.TargetGrants != null) { | |
const nodes = serializeAws_restXmlTargetGrants(input.TargetGrants, context); | |
const containerNode = new xml_builder_1.XmlNode("TargetGrants"); | |
nodes.map((node) => { | |
containerNode.addChildNode(node); | |
}); | |
bodyNode.addChildNode(containerNode); | |
} | |
if (input.TargetPrefix != null) { | |
const node = xml_builder_1.XmlNode.of("TargetPrefix", input.TargetPrefix).withName("TargetPrefix"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlMetadataEntry = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("MetadataEntry"); | |
if (input.Name != null) { | |
const node = xml_builder_1.XmlNode.of("MetadataKey", input.Name).withName("Name"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Value != null) { | |
const node = xml_builder_1.XmlNode.of("MetadataValue", input.Value).withName("Value"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlMetrics = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("Metrics"); | |
if (input.Status != null) { | |
const node = xml_builder_1.XmlNode.of("MetricsStatus", input.Status).withName("Status"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.EventThreshold != null) { | |
const node = serializeAws_restXmlReplicationTimeValue(input.EventThreshold, context).withName("EventThreshold"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlMetricsAndOperator = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("MetricsAndOperator"); | |
if (input.Prefix != null) { | |
const node = xml_builder_1.XmlNode.of("Prefix", input.Prefix).withName("Prefix"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Tags != null) { | |
const nodes = serializeAws_restXmlTagSet(input.Tags, context); | |
nodes.map((node) => { | |
node = node.withName("Tag"); | |
bodyNode.addChildNode(node); | |
}); | |
} | |
if (input.AccessPointArn != null) { | |
const node = xml_builder_1.XmlNode.of("AccessPointArn", input.AccessPointArn).withName("AccessPointArn"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlMetricsConfiguration = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("MetricsConfiguration"); | |
if (input.Id != null) { | |
const node = xml_builder_1.XmlNode.of("MetricsId", input.Id).withName("Id"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Filter != null) { | |
const node = serializeAws_restXmlMetricsFilter(input.Filter, context).withName("Filter"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlMetricsFilter = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("MetricsFilter"); | |
models_0_1.MetricsFilter.visit(input, { | |
Prefix: (value) => { | |
const node = xml_builder_1.XmlNode.of("Prefix", value).withName("Prefix"); | |
bodyNode.addChildNode(node); | |
}, | |
Tag: (value) => { | |
const node = serializeAws_restXmlTag(value, context).withName("Tag"); | |
bodyNode.addChildNode(node); | |
}, | |
AccessPointArn: (value) => { | |
const node = xml_builder_1.XmlNode.of("AccessPointArn", value).withName("AccessPointArn"); | |
bodyNode.addChildNode(node); | |
}, | |
And: (value) => { | |
const node = serializeAws_restXmlMetricsAndOperator(value, context).withName("And"); | |
bodyNode.addChildNode(node); | |
}, | |
_: (name, value) => { | |
if (!(value instanceof xml_builder_1.XmlNode || value instanceof xml_builder_1.XmlText)) { | |
throw new Error("Unable to serialize unknown union members in XML."); | |
} | |
bodyNode.addChildNode(new xml_builder_1.XmlNode(name).addChildNode(value)); | |
} | |
}); | |
return bodyNode; | |
}; | |
var serializeAws_restXmlNoncurrentVersionExpiration = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("NoncurrentVersionExpiration"); | |
if (input.NoncurrentDays != null) { | |
const node = xml_builder_1.XmlNode.of("Days", String(input.NoncurrentDays)).withName("NoncurrentDays"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.NewerNoncurrentVersions != null) { | |
const node = xml_builder_1.XmlNode.of("VersionCount", String(input.NewerNoncurrentVersions)).withName("NewerNoncurrentVersions"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlNoncurrentVersionTransition = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("NoncurrentVersionTransition"); | |
if (input.NoncurrentDays != null) { | |
const node = xml_builder_1.XmlNode.of("Days", String(input.NoncurrentDays)).withName("NoncurrentDays"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.StorageClass != null) { | |
const node = xml_builder_1.XmlNode.of("TransitionStorageClass", input.StorageClass).withName("StorageClass"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.NewerNoncurrentVersions != null) { | |
const node = xml_builder_1.XmlNode.of("VersionCount", String(input.NewerNoncurrentVersions)).withName("NewerNoncurrentVersions"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlNoncurrentVersionTransitionList = (input, context) => { | |
return input.filter((e) => e != null).map((entry) => { | |
const node = serializeAws_restXmlNoncurrentVersionTransition(entry, context); | |
return node.withName("member"); | |
}); | |
}; | |
var serializeAws_restXmlNotificationConfiguration = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("NotificationConfiguration"); | |
if (input.TopicConfigurations != null) { | |
const nodes = serializeAws_restXmlTopicConfigurationList(input.TopicConfigurations, context); | |
nodes.map((node) => { | |
node = node.withName("TopicConfiguration"); | |
bodyNode.addChildNode(node); | |
}); | |
} | |
if (input.QueueConfigurations != null) { | |
const nodes = serializeAws_restXmlQueueConfigurationList(input.QueueConfigurations, context); | |
nodes.map((node) => { | |
node = node.withName("QueueConfiguration"); | |
bodyNode.addChildNode(node); | |
}); | |
} | |
if (input.LambdaFunctionConfigurations != null) { | |
const nodes = serializeAws_restXmlLambdaFunctionConfigurationList(input.LambdaFunctionConfigurations, context); | |
nodes.map((node) => { | |
node = node.withName("CloudFunctionConfiguration"); | |
bodyNode.addChildNode(node); | |
}); | |
} | |
if (input.EventBridgeConfiguration != null) { | |
const node = serializeAws_restXmlEventBridgeConfiguration(input.EventBridgeConfiguration, context).withName("EventBridgeConfiguration"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlNotificationConfigurationFilter = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("NotificationConfigurationFilter"); | |
if (input.Key != null) { | |
const node = serializeAws_restXmlS3KeyFilter(input.Key, context).withName("S3Key"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlObjectIdentifier = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("ObjectIdentifier"); | |
if (input.Key != null) { | |
const node = xml_builder_1.XmlNode.of("ObjectKey", input.Key).withName("Key"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.VersionId != null) { | |
const node = xml_builder_1.XmlNode.of("ObjectVersionId", input.VersionId).withName("VersionId"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlObjectIdentifierList = (input, context) => { | |
return input.filter((e) => e != null).map((entry) => { | |
const node = serializeAws_restXmlObjectIdentifier(entry, context); | |
return node.withName("member"); | |
}); | |
}; | |
var serializeAws_restXmlObjectLockConfiguration = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("ObjectLockConfiguration"); | |
if (input.ObjectLockEnabled != null) { | |
const node = xml_builder_1.XmlNode.of("ObjectLockEnabled", input.ObjectLockEnabled).withName("ObjectLockEnabled"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Rule != null) { | |
const node = serializeAws_restXmlObjectLockRule(input.Rule, context).withName("Rule"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlObjectLockLegalHold = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("ObjectLockLegalHold"); | |
if (input.Status != null) { | |
const node = xml_builder_1.XmlNode.of("ObjectLockLegalHoldStatus", input.Status).withName("Status"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlObjectLockRetention = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("ObjectLockRetention"); | |
if (input.Mode != null) { | |
const node = xml_builder_1.XmlNode.of("ObjectLockRetentionMode", input.Mode).withName("Mode"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.RetainUntilDate != null) { | |
const node = xml_builder_1.XmlNode.of("Date", (input.RetainUntilDate.toISOString().split(".")[0] + "Z").toString()).withName("RetainUntilDate"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlObjectLockRule = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("ObjectLockRule"); | |
if (input.DefaultRetention != null) { | |
const node = serializeAws_restXmlDefaultRetention(input.DefaultRetention, context).withName("DefaultRetention"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlOutputLocation = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("OutputLocation"); | |
if (input.S3 != null) { | |
const node = serializeAws_restXmlS3Location(input.S3, context).withName("S3"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlOutputSerialization = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("OutputSerialization"); | |
if (input.CSV != null) { | |
const node = serializeAws_restXmlCSVOutput(input.CSV, context).withName("CSV"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.JSON != null) { | |
const node = serializeAws_restXmlJSONOutput(input.JSON, context).withName("JSON"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlOwner = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("Owner"); | |
if (input.DisplayName != null) { | |
const node = xml_builder_1.XmlNode.of("DisplayName", input.DisplayName).withName("DisplayName"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.ID != null) { | |
const node = xml_builder_1.XmlNode.of("ID", input.ID).withName("ID"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlOwnershipControls = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("OwnershipControls"); | |
if (input.Rules != null) { | |
const nodes = serializeAws_restXmlOwnershipControlsRules(input.Rules, context); | |
nodes.map((node) => { | |
node = node.withName("Rule"); | |
bodyNode.addChildNode(node); | |
}); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlOwnershipControlsRule = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("OwnershipControlsRule"); | |
if (input.ObjectOwnership != null) { | |
const node = xml_builder_1.XmlNode.of("ObjectOwnership", input.ObjectOwnership).withName("ObjectOwnership"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlOwnershipControlsRules = (input, context) => { | |
return input.filter((e) => e != null).map((entry) => { | |
const node = serializeAws_restXmlOwnershipControlsRule(entry, context); | |
return node.withName("member"); | |
}); | |
}; | |
var serializeAws_restXmlParquetInput = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("ParquetInput"); | |
return bodyNode; | |
}; | |
var serializeAws_restXmlPublicAccessBlockConfiguration = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("PublicAccessBlockConfiguration"); | |
if (input.BlockPublicAcls != null) { | |
const node = xml_builder_1.XmlNode.of("Setting", String(input.BlockPublicAcls)).withName("BlockPublicAcls"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.IgnorePublicAcls != null) { | |
const node = xml_builder_1.XmlNode.of("Setting", String(input.IgnorePublicAcls)).withName("IgnorePublicAcls"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.BlockPublicPolicy != null) { | |
const node = xml_builder_1.XmlNode.of("Setting", String(input.BlockPublicPolicy)).withName("BlockPublicPolicy"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.RestrictPublicBuckets != null) { | |
const node = xml_builder_1.XmlNode.of("Setting", String(input.RestrictPublicBuckets)).withName("RestrictPublicBuckets"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlQueueConfiguration = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("QueueConfiguration"); | |
if (input.Id != null) { | |
const node = xml_builder_1.XmlNode.of("NotificationId", input.Id).withName("Id"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.QueueArn != null) { | |
const node = xml_builder_1.XmlNode.of("QueueArn", input.QueueArn).withName("Queue"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Events != null) { | |
const nodes = serializeAws_restXmlEventList(input.Events, context); | |
nodes.map((node) => { | |
node = node.withName("Event"); | |
bodyNode.addChildNode(node); | |
}); | |
} | |
if (input.Filter != null) { | |
const node = serializeAws_restXmlNotificationConfigurationFilter(input.Filter, context).withName("Filter"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlQueueConfigurationList = (input, context) => { | |
return input.filter((e) => e != null).map((entry) => { | |
const node = serializeAws_restXmlQueueConfiguration(entry, context); | |
return node.withName("member"); | |
}); | |
}; | |
var serializeAws_restXmlRedirect = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("Redirect"); | |
if (input.HostName != null) { | |
const node = xml_builder_1.XmlNode.of("HostName", input.HostName).withName("HostName"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.HttpRedirectCode != null) { | |
const node = xml_builder_1.XmlNode.of("HttpRedirectCode", input.HttpRedirectCode).withName("HttpRedirectCode"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Protocol != null) { | |
const node = xml_builder_1.XmlNode.of("Protocol", input.Protocol).withName("Protocol"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.ReplaceKeyPrefixWith != null) { | |
const node = xml_builder_1.XmlNode.of("ReplaceKeyPrefixWith", input.ReplaceKeyPrefixWith).withName("ReplaceKeyPrefixWith"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.ReplaceKeyWith != null) { | |
const node = xml_builder_1.XmlNode.of("ReplaceKeyWith", input.ReplaceKeyWith).withName("ReplaceKeyWith"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlRedirectAllRequestsTo = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("RedirectAllRequestsTo"); | |
if (input.HostName != null) { | |
const node = xml_builder_1.XmlNode.of("HostName", input.HostName).withName("HostName"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Protocol != null) { | |
const node = xml_builder_1.XmlNode.of("Protocol", input.Protocol).withName("Protocol"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlReplicaModifications = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("ReplicaModifications"); | |
if (input.Status != null) { | |
const node = xml_builder_1.XmlNode.of("ReplicaModificationsStatus", input.Status).withName("Status"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlReplicationConfiguration = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("ReplicationConfiguration"); | |
if (input.Role != null) { | |
const node = xml_builder_1.XmlNode.of("Role", input.Role).withName("Role"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Rules != null) { | |
const nodes = serializeAws_restXmlReplicationRules(input.Rules, context); | |
nodes.map((node) => { | |
node = node.withName("Rule"); | |
bodyNode.addChildNode(node); | |
}); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlReplicationRule = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("ReplicationRule"); | |
if (input.ID != null) { | |
const node = xml_builder_1.XmlNode.of("ID", input.ID).withName("ID"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Priority != null) { | |
const node = xml_builder_1.XmlNode.of("Priority", String(input.Priority)).withName("Priority"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Prefix != null) { | |
const node = xml_builder_1.XmlNode.of("Prefix", input.Prefix).withName("Prefix"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Filter != null) { | |
const node = serializeAws_restXmlReplicationRuleFilter(input.Filter, context).withName("Filter"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Status != null) { | |
const node = xml_builder_1.XmlNode.of("ReplicationRuleStatus", input.Status).withName("Status"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.SourceSelectionCriteria != null) { | |
const node = serializeAws_restXmlSourceSelectionCriteria(input.SourceSelectionCriteria, context).withName("SourceSelectionCriteria"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.ExistingObjectReplication != null) { | |
const node = serializeAws_restXmlExistingObjectReplication(input.ExistingObjectReplication, context).withName("ExistingObjectReplication"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Destination != null) { | |
const node = serializeAws_restXmlDestination(input.Destination, context).withName("Destination"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.DeleteMarkerReplication != null) { | |
const node = serializeAws_restXmlDeleteMarkerReplication(input.DeleteMarkerReplication, context).withName("DeleteMarkerReplication"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlReplicationRuleAndOperator = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("ReplicationRuleAndOperator"); | |
if (input.Prefix != null) { | |
const node = xml_builder_1.XmlNode.of("Prefix", input.Prefix).withName("Prefix"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Tags != null) { | |
const nodes = serializeAws_restXmlTagSet(input.Tags, context); | |
nodes.map((node) => { | |
node = node.withName("Tag"); | |
bodyNode.addChildNode(node); | |
}); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlReplicationRuleFilter = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("ReplicationRuleFilter"); | |
models_0_1.ReplicationRuleFilter.visit(input, { | |
Prefix: (value) => { | |
const node = xml_builder_1.XmlNode.of("Prefix", value).withName("Prefix"); | |
bodyNode.addChildNode(node); | |
}, | |
Tag: (value) => { | |
const node = serializeAws_restXmlTag(value, context).withName("Tag"); | |
bodyNode.addChildNode(node); | |
}, | |
And: (value) => { | |
const node = serializeAws_restXmlReplicationRuleAndOperator(value, context).withName("And"); | |
bodyNode.addChildNode(node); | |
}, | |
_: (name, value) => { | |
if (!(value instanceof xml_builder_1.XmlNode || value instanceof xml_builder_1.XmlText)) { | |
throw new Error("Unable to serialize unknown union members in XML."); | |
} | |
bodyNode.addChildNode(new xml_builder_1.XmlNode(name).addChildNode(value)); | |
} | |
}); | |
return bodyNode; | |
}; | |
var serializeAws_restXmlReplicationRules = (input, context) => { | |
return input.filter((e) => e != null).map((entry) => { | |
const node = serializeAws_restXmlReplicationRule(entry, context); | |
return node.withName("member"); | |
}); | |
}; | |
var serializeAws_restXmlReplicationTime = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("ReplicationTime"); | |
if (input.Status != null) { | |
const node = xml_builder_1.XmlNode.of("ReplicationTimeStatus", input.Status).withName("Status"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Time != null) { | |
const node = serializeAws_restXmlReplicationTimeValue(input.Time, context).withName("Time"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlReplicationTimeValue = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("ReplicationTimeValue"); | |
if (input.Minutes != null) { | |
const node = xml_builder_1.XmlNode.of("Minutes", String(input.Minutes)).withName("Minutes"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlRequestPaymentConfiguration = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("RequestPaymentConfiguration"); | |
if (input.Payer != null) { | |
const node = xml_builder_1.XmlNode.of("Payer", input.Payer).withName("Payer"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlRequestProgress = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("RequestProgress"); | |
if (input.Enabled != null) { | |
const node = xml_builder_1.XmlNode.of("EnableRequestProgress", String(input.Enabled)).withName("Enabled"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlRestoreRequest = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("RestoreRequest"); | |
if (input.Days != null) { | |
const node = xml_builder_1.XmlNode.of("Days", String(input.Days)).withName("Days"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.GlacierJobParameters != null) { | |
const node = serializeAws_restXmlGlacierJobParameters(input.GlacierJobParameters, context).withName("GlacierJobParameters"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Type != null) { | |
const node = xml_builder_1.XmlNode.of("RestoreRequestType", input.Type).withName("Type"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Tier != null) { | |
const node = xml_builder_1.XmlNode.of("Tier", input.Tier).withName("Tier"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Description != null) { | |
const node = xml_builder_1.XmlNode.of("Description", input.Description).withName("Description"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.SelectParameters != null) { | |
const node = serializeAws_restXmlSelectParameters(input.SelectParameters, context).withName("SelectParameters"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.OutputLocation != null) { | |
const node = serializeAws_restXmlOutputLocation(input.OutputLocation, context).withName("OutputLocation"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlRoutingRule = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("RoutingRule"); | |
if (input.Condition != null) { | |
const node = serializeAws_restXmlCondition(input.Condition, context).withName("Condition"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Redirect != null) { | |
const node = serializeAws_restXmlRedirect(input.Redirect, context).withName("Redirect"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlRoutingRules = (input, context) => { | |
return input.filter((e) => e != null).map((entry) => { | |
const node = serializeAws_restXmlRoutingRule(entry, context); | |
return node.withName("RoutingRule"); | |
}); | |
}; | |
var serializeAws_restXmlS3KeyFilter = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("S3KeyFilter"); | |
if (input.FilterRules != null) { | |
const nodes = serializeAws_restXmlFilterRuleList(input.FilterRules, context); | |
nodes.map((node) => { | |
node = node.withName("FilterRule"); | |
bodyNode.addChildNode(node); | |
}); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlS3Location = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("S3Location"); | |
if (input.BucketName != null) { | |
const node = xml_builder_1.XmlNode.of("BucketName", input.BucketName).withName("BucketName"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Prefix != null) { | |
const node = xml_builder_1.XmlNode.of("LocationPrefix", input.Prefix).withName("Prefix"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Encryption != null) { | |
const node = serializeAws_restXmlEncryption(input.Encryption, context).withName("Encryption"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.CannedACL != null) { | |
const node = xml_builder_1.XmlNode.of("ObjectCannedACL", input.CannedACL).withName("CannedACL"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.AccessControlList != null) { | |
const nodes = serializeAws_restXmlGrants(input.AccessControlList, context); | |
const containerNode = new xml_builder_1.XmlNode("AccessControlList"); | |
nodes.map((node) => { | |
containerNode.addChildNode(node); | |
}); | |
bodyNode.addChildNode(containerNode); | |
} | |
if (input.Tagging != null) { | |
const node = serializeAws_restXmlTagging(input.Tagging, context).withName("Tagging"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.UserMetadata != null) { | |
const nodes = serializeAws_restXmlUserMetadata(input.UserMetadata, context); | |
const containerNode = new xml_builder_1.XmlNode("UserMetadata"); | |
nodes.map((node) => { | |
containerNode.addChildNode(node); | |
}); | |
bodyNode.addChildNode(containerNode); | |
} | |
if (input.StorageClass != null) { | |
const node = xml_builder_1.XmlNode.of("StorageClass", input.StorageClass).withName("StorageClass"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlScanRange = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("ScanRange"); | |
if (input.Start != null) { | |
const node = xml_builder_1.XmlNode.of("Start", String(input.Start)).withName("Start"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.End != null) { | |
const node = xml_builder_1.XmlNode.of("End", String(input.End)).withName("End"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlSelectParameters = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("SelectParameters"); | |
if (input.InputSerialization != null) { | |
const node = serializeAws_restXmlInputSerialization(input.InputSerialization, context).withName("InputSerialization"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.ExpressionType != null) { | |
const node = xml_builder_1.XmlNode.of("ExpressionType", input.ExpressionType).withName("ExpressionType"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Expression != null) { | |
const node = xml_builder_1.XmlNode.of("Expression", input.Expression).withName("Expression"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.OutputSerialization != null) { | |
const node = serializeAws_restXmlOutputSerialization(input.OutputSerialization, context).withName("OutputSerialization"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlServerSideEncryptionByDefault = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("ServerSideEncryptionByDefault"); | |
if (input.SSEAlgorithm != null) { | |
const node = xml_builder_1.XmlNode.of("ServerSideEncryption", input.SSEAlgorithm).withName("SSEAlgorithm"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.KMSMasterKeyID != null) { | |
const node = xml_builder_1.XmlNode.of("SSEKMSKeyId", input.KMSMasterKeyID).withName("KMSMasterKeyID"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlServerSideEncryptionConfiguration = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("ServerSideEncryptionConfiguration"); | |
if (input.Rules != null) { | |
const nodes = serializeAws_restXmlServerSideEncryptionRules(input.Rules, context); | |
nodes.map((node) => { | |
node = node.withName("Rule"); | |
bodyNode.addChildNode(node); | |
}); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlServerSideEncryptionRule = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("ServerSideEncryptionRule"); | |
if (input.ApplyServerSideEncryptionByDefault != null) { | |
const node = serializeAws_restXmlServerSideEncryptionByDefault(input.ApplyServerSideEncryptionByDefault, context).withName("ApplyServerSideEncryptionByDefault"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.BucketKeyEnabled != null) { | |
const node = xml_builder_1.XmlNode.of("BucketKeyEnabled", String(input.BucketKeyEnabled)).withName("BucketKeyEnabled"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlServerSideEncryptionRules = (input, context) => { | |
return input.filter((e) => e != null).map((entry) => { | |
const node = serializeAws_restXmlServerSideEncryptionRule(entry, context); | |
return node.withName("member"); | |
}); | |
}; | |
var serializeAws_restXmlSourceSelectionCriteria = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("SourceSelectionCriteria"); | |
if (input.SseKmsEncryptedObjects != null) { | |
const node = serializeAws_restXmlSseKmsEncryptedObjects(input.SseKmsEncryptedObjects, context).withName("SseKmsEncryptedObjects"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.ReplicaModifications != null) { | |
const node = serializeAws_restXmlReplicaModifications(input.ReplicaModifications, context).withName("ReplicaModifications"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlSSEKMS = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("SSE-KMS"); | |
if (input.KeyId != null) { | |
const node = xml_builder_1.XmlNode.of("SSEKMSKeyId", input.KeyId).withName("KeyId"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlSseKmsEncryptedObjects = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("SseKmsEncryptedObjects"); | |
if (input.Status != null) { | |
const node = xml_builder_1.XmlNode.of("SseKmsEncryptedObjectsStatus", input.Status).withName("Status"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlSSES3 = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("SSE-S3"); | |
return bodyNode; | |
}; | |
var serializeAws_restXmlStorageClassAnalysis = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("StorageClassAnalysis"); | |
if (input.DataExport != null) { | |
const node = serializeAws_restXmlStorageClassAnalysisDataExport(input.DataExport, context).withName("DataExport"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlStorageClassAnalysisDataExport = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("StorageClassAnalysisDataExport"); | |
if (input.OutputSchemaVersion != null) { | |
const node = xml_builder_1.XmlNode.of("StorageClassAnalysisSchemaVersion", input.OutputSchemaVersion).withName("OutputSchemaVersion"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Destination != null) { | |
const node = serializeAws_restXmlAnalyticsExportDestination(input.Destination, context).withName("Destination"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlTag = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("Tag"); | |
if (input.Key != null) { | |
const node = xml_builder_1.XmlNode.of("ObjectKey", input.Key).withName("Key"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Value != null) { | |
const node = xml_builder_1.XmlNode.of("Value", input.Value).withName("Value"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlTagging = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("Tagging"); | |
if (input.TagSet != null) { | |
const nodes = serializeAws_restXmlTagSet(input.TagSet, context); | |
const containerNode = new xml_builder_1.XmlNode("TagSet"); | |
nodes.map((node) => { | |
containerNode.addChildNode(node); | |
}); | |
bodyNode.addChildNode(containerNode); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlTagSet = (input, context) => { | |
return input.filter((e) => e != null).map((entry) => { | |
const node = serializeAws_restXmlTag(entry, context); | |
return node.withName("Tag"); | |
}); | |
}; | |
var serializeAws_restXmlTargetGrant = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("TargetGrant"); | |
if (input.Grantee != null) { | |
const node = serializeAws_restXmlGrantee(input.Grantee, context).withName("Grantee"); | |
node.addAttribute("xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Permission != null) { | |
const node = xml_builder_1.XmlNode.of("BucketLogsPermission", input.Permission).withName("Permission"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlTargetGrants = (input, context) => { | |
return input.filter((e) => e != null).map((entry) => { | |
const node = serializeAws_restXmlTargetGrant(entry, context); | |
return node.withName("Grant"); | |
}); | |
}; | |
var serializeAws_restXmlTiering = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("Tiering"); | |
if (input.Days != null) { | |
const node = xml_builder_1.XmlNode.of("IntelligentTieringDays", String(input.Days)).withName("Days"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.AccessTier != null) { | |
const node = xml_builder_1.XmlNode.of("IntelligentTieringAccessTier", input.AccessTier).withName("AccessTier"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlTieringList = (input, context) => { | |
return input.filter((e) => e != null).map((entry) => { | |
const node = serializeAws_restXmlTiering(entry, context); | |
return node.withName("member"); | |
}); | |
}; | |
var serializeAws_restXmlTopicConfiguration = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("TopicConfiguration"); | |
if (input.Id != null) { | |
const node = xml_builder_1.XmlNode.of("NotificationId", input.Id).withName("Id"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.TopicArn != null) { | |
const node = xml_builder_1.XmlNode.of("TopicArn", input.TopicArn).withName("Topic"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Events != null) { | |
const nodes = serializeAws_restXmlEventList(input.Events, context); | |
nodes.map((node) => { | |
node = node.withName("Event"); | |
bodyNode.addChildNode(node); | |
}); | |
} | |
if (input.Filter != null) { | |
const node = serializeAws_restXmlNotificationConfigurationFilter(input.Filter, context).withName("Filter"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlTopicConfigurationList = (input, context) => { | |
return input.filter((e) => e != null).map((entry) => { | |
const node = serializeAws_restXmlTopicConfiguration(entry, context); | |
return node.withName("member"); | |
}); | |
}; | |
var serializeAws_restXmlTransition = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("Transition"); | |
if (input.Date != null) { | |
const node = xml_builder_1.XmlNode.of("Date", (input.Date.toISOString().split(".")[0] + "Z").toString()).withName("Date"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Days != null) { | |
const node = xml_builder_1.XmlNode.of("Days", String(input.Days)).withName("Days"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.StorageClass != null) { | |
const node = xml_builder_1.XmlNode.of("TransitionStorageClass", input.StorageClass).withName("StorageClass"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlTransitionList = (input, context) => { | |
return input.filter((e) => e != null).map((entry) => { | |
const node = serializeAws_restXmlTransition(entry, context); | |
return node.withName("member"); | |
}); | |
}; | |
var serializeAws_restXmlUserMetadata = (input, context) => { | |
return input.filter((e) => e != null).map((entry) => { | |
const node = serializeAws_restXmlMetadataEntry(entry, context); | |
return node.withName("MetadataEntry"); | |
}); | |
}; | |
var serializeAws_restXmlVersioningConfiguration = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("VersioningConfiguration"); | |
if (input.MFADelete != null) { | |
const node = xml_builder_1.XmlNode.of("MFADelete", input.MFADelete).withName("MfaDelete"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.Status != null) { | |
const node = xml_builder_1.XmlNode.of("BucketVersioningStatus", input.Status).withName("Status"); | |
bodyNode.addChildNode(node); | |
} | |
return bodyNode; | |
}; | |
var serializeAws_restXmlWebsiteConfiguration = (input, context) => { | |
const bodyNode = new xml_builder_1.XmlNode("WebsiteConfiguration"); | |
if (input.ErrorDocument != null) { | |
const node = serializeAws_restXmlErrorDocument(input.ErrorDocument, context).withName("ErrorDocument"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.IndexDocument != null) { | |
const node = serializeAws_restXmlIndexDocument(input.IndexDocument, context).withName("IndexDocument"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.RedirectAllRequestsTo != null) { | |
const node = serializeAws_restXmlRedirectAllRequestsTo(input.RedirectAllRequestsTo, context).withName("RedirectAllRequestsTo"); | |
bodyNode.addChildNode(node); | |
} | |
if (input.RoutingRules != null) { | |
const nodes = serializeAws_restXmlRoutingRules(input.RoutingRules, context); | |
const containerNode = new xml_builder_1.XmlNode("RoutingRules"); | |
nodes.map((node) => { | |
containerNode.addChildNode(node); | |
}); | |
bodyNode.addChildNode(containerNode); | |
} | |
return bodyNode; | |
}; | |
var deserializeAws_restXmlAbortIncompleteMultipartUpload = (output, context) => { | |
const contents = { | |
DaysAfterInitiation: void 0 | |
}; | |
if (output["DaysAfterInitiation"] !== void 0) { | |
contents.DaysAfterInitiation = (0, smithy_client_1.strictParseInt32)(output["DaysAfterInitiation"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlAccessControlTranslation = (output, context) => { | |
const contents = { | |
Owner: void 0 | |
}; | |
if (output["Owner"] !== void 0) { | |
contents.Owner = (0, smithy_client_1.expectString)(output["Owner"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlAllowedHeaders = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return (0, smithy_client_1.expectString)(entry); | |
}); | |
}; | |
var deserializeAws_restXmlAllowedMethods = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return (0, smithy_client_1.expectString)(entry); | |
}); | |
}; | |
var deserializeAws_restXmlAllowedOrigins = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return (0, smithy_client_1.expectString)(entry); | |
}); | |
}; | |
var deserializeAws_restXmlAnalyticsAndOperator = (output, context) => { | |
const contents = { | |
Prefix: void 0, | |
Tags: void 0 | |
}; | |
if (output["Prefix"] !== void 0) { | |
contents.Prefix = (0, smithy_client_1.expectString)(output["Prefix"]); | |
} | |
if (output.Tag === "") { | |
contents.Tags = []; | |
} else if (output["Tag"] !== void 0) { | |
contents.Tags = deserializeAws_restXmlTagSet((0, smithy_client_1.getArrayIfSingleItem)(output["Tag"]), context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlAnalyticsConfiguration = (output, context) => { | |
const contents = { | |
Id: void 0, | |
Filter: void 0, | |
StorageClassAnalysis: void 0 | |
}; | |
if (output["Id"] !== void 0) { | |
contents.Id = (0, smithy_client_1.expectString)(output["Id"]); | |
} | |
if (output.Filter === "") { | |
} else if (output["Filter"] !== void 0) { | |
contents.Filter = deserializeAws_restXmlAnalyticsFilter((0, smithy_client_1.expectUnion)(output["Filter"]), context); | |
} | |
if (output["StorageClassAnalysis"] !== void 0) { | |
contents.StorageClassAnalysis = deserializeAws_restXmlStorageClassAnalysis(output["StorageClassAnalysis"], context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlAnalyticsConfigurationList = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlAnalyticsConfiguration(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlAnalyticsExportDestination = (output, context) => { | |
const contents = { | |
S3BucketDestination: void 0 | |
}; | |
if (output["S3BucketDestination"] !== void 0) { | |
contents.S3BucketDestination = deserializeAws_restXmlAnalyticsS3BucketDestination(output["S3BucketDestination"], context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlAnalyticsFilter = (output, context) => { | |
if (output["Prefix"] !== void 0) { | |
return { | |
Prefix: (0, smithy_client_1.expectString)(output["Prefix"]) | |
}; | |
} | |
if (output["Tag"] !== void 0) { | |
return { | |
Tag: deserializeAws_restXmlTag(output["Tag"], context) | |
}; | |
} | |
if (output["And"] !== void 0) { | |
return { | |
And: deserializeAws_restXmlAnalyticsAndOperator(output["And"], context) | |
}; | |
} | |
return { $unknown: Object.entries(output)[0] }; | |
}; | |
var deserializeAws_restXmlAnalyticsS3BucketDestination = (output, context) => { | |
const contents = { | |
Format: void 0, | |
BucketAccountId: void 0, | |
Bucket: void 0, | |
Prefix: void 0 | |
}; | |
if (output["Format"] !== void 0) { | |
contents.Format = (0, smithy_client_1.expectString)(output["Format"]); | |
} | |
if (output["BucketAccountId"] !== void 0) { | |
contents.BucketAccountId = (0, smithy_client_1.expectString)(output["BucketAccountId"]); | |
} | |
if (output["Bucket"] !== void 0) { | |
contents.Bucket = (0, smithy_client_1.expectString)(output["Bucket"]); | |
} | |
if (output["Prefix"] !== void 0) { | |
contents.Prefix = (0, smithy_client_1.expectString)(output["Prefix"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlBucket = (output, context) => { | |
const contents = { | |
Name: void 0, | |
CreationDate: void 0 | |
}; | |
if (output["Name"] !== void 0) { | |
contents.Name = (0, smithy_client_1.expectString)(output["Name"]); | |
} | |
if (output["CreationDate"] !== void 0) { | |
contents.CreationDate = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output["CreationDate"])); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlBuckets = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlBucket(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlChecksum = (output, context) => { | |
const contents = { | |
ChecksumCRC32: void 0, | |
ChecksumCRC32C: void 0, | |
ChecksumSHA1: void 0, | |
ChecksumSHA256: void 0 | |
}; | |
if (output["ChecksumCRC32"] !== void 0) { | |
contents.ChecksumCRC32 = (0, smithy_client_1.expectString)(output["ChecksumCRC32"]); | |
} | |
if (output["ChecksumCRC32C"] !== void 0) { | |
contents.ChecksumCRC32C = (0, smithy_client_1.expectString)(output["ChecksumCRC32C"]); | |
} | |
if (output["ChecksumSHA1"] !== void 0) { | |
contents.ChecksumSHA1 = (0, smithy_client_1.expectString)(output["ChecksumSHA1"]); | |
} | |
if (output["ChecksumSHA256"] !== void 0) { | |
contents.ChecksumSHA256 = (0, smithy_client_1.expectString)(output["ChecksumSHA256"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlChecksumAlgorithmList = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return (0, smithy_client_1.expectString)(entry); | |
}); | |
}; | |
var deserializeAws_restXmlCommonPrefix = (output, context) => { | |
const contents = { | |
Prefix: void 0 | |
}; | |
if (output["Prefix"] !== void 0) { | |
contents.Prefix = (0, smithy_client_1.expectString)(output["Prefix"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlCommonPrefixList = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlCommonPrefix(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlCondition = (output, context) => { | |
const contents = { | |
HttpErrorCodeReturnedEquals: void 0, | |
KeyPrefixEquals: void 0 | |
}; | |
if (output["HttpErrorCodeReturnedEquals"] !== void 0) { | |
contents.HttpErrorCodeReturnedEquals = (0, smithy_client_1.expectString)(output["HttpErrorCodeReturnedEquals"]); | |
} | |
if (output["KeyPrefixEquals"] !== void 0) { | |
contents.KeyPrefixEquals = (0, smithy_client_1.expectString)(output["KeyPrefixEquals"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlContinuationEvent = (output, context) => { | |
const contents = {}; | |
return contents; | |
}; | |
var deserializeAws_restXmlCopyObjectResult = (output, context) => { | |
const contents = { | |
ETag: void 0, | |
LastModified: void 0, | |
ChecksumCRC32: void 0, | |
ChecksumCRC32C: void 0, | |
ChecksumSHA1: void 0, | |
ChecksumSHA256: void 0 | |
}; | |
if (output["ETag"] !== void 0) { | |
contents.ETag = (0, smithy_client_1.expectString)(output["ETag"]); | |
} | |
if (output["LastModified"] !== void 0) { | |
contents.LastModified = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output["LastModified"])); | |
} | |
if (output["ChecksumCRC32"] !== void 0) { | |
contents.ChecksumCRC32 = (0, smithy_client_1.expectString)(output["ChecksumCRC32"]); | |
} | |
if (output["ChecksumCRC32C"] !== void 0) { | |
contents.ChecksumCRC32C = (0, smithy_client_1.expectString)(output["ChecksumCRC32C"]); | |
} | |
if (output["ChecksumSHA1"] !== void 0) { | |
contents.ChecksumSHA1 = (0, smithy_client_1.expectString)(output["ChecksumSHA1"]); | |
} | |
if (output["ChecksumSHA256"] !== void 0) { | |
contents.ChecksumSHA256 = (0, smithy_client_1.expectString)(output["ChecksumSHA256"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlCopyPartResult = (output, context) => { | |
const contents = { | |
ETag: void 0, | |
LastModified: void 0, | |
ChecksumCRC32: void 0, | |
ChecksumCRC32C: void 0, | |
ChecksumSHA1: void 0, | |
ChecksumSHA256: void 0 | |
}; | |
if (output["ETag"] !== void 0) { | |
contents.ETag = (0, smithy_client_1.expectString)(output["ETag"]); | |
} | |
if (output["LastModified"] !== void 0) { | |
contents.LastModified = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output["LastModified"])); | |
} | |
if (output["ChecksumCRC32"] !== void 0) { | |
contents.ChecksumCRC32 = (0, smithy_client_1.expectString)(output["ChecksumCRC32"]); | |
} | |
if (output["ChecksumCRC32C"] !== void 0) { | |
contents.ChecksumCRC32C = (0, smithy_client_1.expectString)(output["ChecksumCRC32C"]); | |
} | |
if (output["ChecksumSHA1"] !== void 0) { | |
contents.ChecksumSHA1 = (0, smithy_client_1.expectString)(output["ChecksumSHA1"]); | |
} | |
if (output["ChecksumSHA256"] !== void 0) { | |
contents.ChecksumSHA256 = (0, smithy_client_1.expectString)(output["ChecksumSHA256"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlCORSRule = (output, context) => { | |
const contents = { | |
ID: void 0, | |
AllowedHeaders: void 0, | |
AllowedMethods: void 0, | |
AllowedOrigins: void 0, | |
ExposeHeaders: void 0, | |
MaxAgeSeconds: void 0 | |
}; | |
if (output["ID"] !== void 0) { | |
contents.ID = (0, smithy_client_1.expectString)(output["ID"]); | |
} | |
if (output.AllowedHeader === "") { | |
contents.AllowedHeaders = []; | |
} else if (output["AllowedHeader"] !== void 0) { | |
contents.AllowedHeaders = deserializeAws_restXmlAllowedHeaders((0, smithy_client_1.getArrayIfSingleItem)(output["AllowedHeader"]), context); | |
} | |
if (output.AllowedMethod === "") { | |
contents.AllowedMethods = []; | |
} else if (output["AllowedMethod"] !== void 0) { | |
contents.AllowedMethods = deserializeAws_restXmlAllowedMethods((0, smithy_client_1.getArrayIfSingleItem)(output["AllowedMethod"]), context); | |
} | |
if (output.AllowedOrigin === "") { | |
contents.AllowedOrigins = []; | |
} else if (output["AllowedOrigin"] !== void 0) { | |
contents.AllowedOrigins = deserializeAws_restXmlAllowedOrigins((0, smithy_client_1.getArrayIfSingleItem)(output["AllowedOrigin"]), context); | |
} | |
if (output.ExposeHeader === "") { | |
contents.ExposeHeaders = []; | |
} else if (output["ExposeHeader"] !== void 0) { | |
contents.ExposeHeaders = deserializeAws_restXmlExposeHeaders((0, smithy_client_1.getArrayIfSingleItem)(output["ExposeHeader"]), context); | |
} | |
if (output["MaxAgeSeconds"] !== void 0) { | |
contents.MaxAgeSeconds = (0, smithy_client_1.strictParseInt32)(output["MaxAgeSeconds"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlCORSRules = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlCORSRule(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlDefaultRetention = (output, context) => { | |
const contents = { | |
Mode: void 0, | |
Days: void 0, | |
Years: void 0 | |
}; | |
if (output["Mode"] !== void 0) { | |
contents.Mode = (0, smithy_client_1.expectString)(output["Mode"]); | |
} | |
if (output["Days"] !== void 0) { | |
contents.Days = (0, smithy_client_1.strictParseInt32)(output["Days"]); | |
} | |
if (output["Years"] !== void 0) { | |
contents.Years = (0, smithy_client_1.strictParseInt32)(output["Years"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlDeletedObject = (output, context) => { | |
const contents = { | |
Key: void 0, | |
VersionId: void 0, | |
DeleteMarker: void 0, | |
DeleteMarkerVersionId: void 0 | |
}; | |
if (output["Key"] !== void 0) { | |
contents.Key = (0, smithy_client_1.expectString)(output["Key"]); | |
} | |
if (output["VersionId"] !== void 0) { | |
contents.VersionId = (0, smithy_client_1.expectString)(output["VersionId"]); | |
} | |
if (output["DeleteMarker"] !== void 0) { | |
contents.DeleteMarker = (0, smithy_client_1.parseBoolean)(output["DeleteMarker"]); | |
} | |
if (output["DeleteMarkerVersionId"] !== void 0) { | |
contents.DeleteMarkerVersionId = (0, smithy_client_1.expectString)(output["DeleteMarkerVersionId"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlDeletedObjects = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlDeletedObject(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlDeleteMarkerEntry = (output, context) => { | |
const contents = { | |
Owner: void 0, | |
Key: void 0, | |
VersionId: void 0, | |
IsLatest: void 0, | |
LastModified: void 0 | |
}; | |
if (output["Owner"] !== void 0) { | |
contents.Owner = deserializeAws_restXmlOwner(output["Owner"], context); | |
} | |
if (output["Key"] !== void 0) { | |
contents.Key = (0, smithy_client_1.expectString)(output["Key"]); | |
} | |
if (output["VersionId"] !== void 0) { | |
contents.VersionId = (0, smithy_client_1.expectString)(output["VersionId"]); | |
} | |
if (output["IsLatest"] !== void 0) { | |
contents.IsLatest = (0, smithy_client_1.parseBoolean)(output["IsLatest"]); | |
} | |
if (output["LastModified"] !== void 0) { | |
contents.LastModified = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output["LastModified"])); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlDeleteMarkerReplication = (output, context) => { | |
const contents = { | |
Status: void 0 | |
}; | |
if (output["Status"] !== void 0) { | |
contents.Status = (0, smithy_client_1.expectString)(output["Status"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlDeleteMarkers = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlDeleteMarkerEntry(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlDestination = (output, context) => { | |
const contents = { | |
Bucket: void 0, | |
Account: void 0, | |
StorageClass: void 0, | |
AccessControlTranslation: void 0, | |
EncryptionConfiguration: void 0, | |
ReplicationTime: void 0, | |
Metrics: void 0 | |
}; | |
if (output["Bucket"] !== void 0) { | |
contents.Bucket = (0, smithy_client_1.expectString)(output["Bucket"]); | |
} | |
if (output["Account"] !== void 0) { | |
contents.Account = (0, smithy_client_1.expectString)(output["Account"]); | |
} | |
if (output["StorageClass"] !== void 0) { | |
contents.StorageClass = (0, smithy_client_1.expectString)(output["StorageClass"]); | |
} | |
if (output["AccessControlTranslation"] !== void 0) { | |
contents.AccessControlTranslation = deserializeAws_restXmlAccessControlTranslation(output["AccessControlTranslation"], context); | |
} | |
if (output["EncryptionConfiguration"] !== void 0) { | |
contents.EncryptionConfiguration = deserializeAws_restXmlEncryptionConfiguration(output["EncryptionConfiguration"], context); | |
} | |
if (output["ReplicationTime"] !== void 0) { | |
contents.ReplicationTime = deserializeAws_restXmlReplicationTime(output["ReplicationTime"], context); | |
} | |
if (output["Metrics"] !== void 0) { | |
contents.Metrics = deserializeAws_restXmlMetrics(output["Metrics"], context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlEncryptionConfiguration = (output, context) => { | |
const contents = { | |
ReplicaKmsKeyID: void 0 | |
}; | |
if (output["ReplicaKmsKeyID"] !== void 0) { | |
contents.ReplicaKmsKeyID = (0, smithy_client_1.expectString)(output["ReplicaKmsKeyID"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlEndEvent = (output, context) => { | |
const contents = {}; | |
return contents; | |
}; | |
var deserializeAws_restXml_Error = (output, context) => { | |
const contents = { | |
Key: void 0, | |
VersionId: void 0, | |
Code: void 0, | |
Message: void 0 | |
}; | |
if (output["Key"] !== void 0) { | |
contents.Key = (0, smithy_client_1.expectString)(output["Key"]); | |
} | |
if (output["VersionId"] !== void 0) { | |
contents.VersionId = (0, smithy_client_1.expectString)(output["VersionId"]); | |
} | |
if (output["Code"] !== void 0) { | |
contents.Code = (0, smithy_client_1.expectString)(output["Code"]); | |
} | |
if (output["Message"] !== void 0) { | |
contents.Message = (0, smithy_client_1.expectString)(output["Message"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlErrorDocument = (output, context) => { | |
const contents = { | |
Key: void 0 | |
}; | |
if (output["Key"] !== void 0) { | |
contents.Key = (0, smithy_client_1.expectString)(output["Key"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlErrors = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXml_Error(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlEventBridgeConfiguration = (output, context) => { | |
const contents = {}; | |
return contents; | |
}; | |
var deserializeAws_restXmlEventList = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return (0, smithy_client_1.expectString)(entry); | |
}); | |
}; | |
var deserializeAws_restXmlExistingObjectReplication = (output, context) => { | |
const contents = { | |
Status: void 0 | |
}; | |
if (output["Status"] !== void 0) { | |
contents.Status = (0, smithy_client_1.expectString)(output["Status"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlExposeHeaders = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return (0, smithy_client_1.expectString)(entry); | |
}); | |
}; | |
var deserializeAws_restXmlFilterRule = (output, context) => { | |
const contents = { | |
Name: void 0, | |
Value: void 0 | |
}; | |
if (output["Name"] !== void 0) { | |
contents.Name = (0, smithy_client_1.expectString)(output["Name"]); | |
} | |
if (output["Value"] !== void 0) { | |
contents.Value = (0, smithy_client_1.expectString)(output["Value"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlFilterRuleList = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlFilterRule(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlGetObjectAttributesParts = (output, context) => { | |
const contents = { | |
TotalPartsCount: void 0, | |
PartNumberMarker: void 0, | |
NextPartNumberMarker: void 0, | |
MaxParts: void 0, | |
IsTruncated: void 0, | |
Parts: void 0 | |
}; | |
if (output["PartsCount"] !== void 0) { | |
contents.TotalPartsCount = (0, smithy_client_1.strictParseInt32)(output["PartsCount"]); | |
} | |
if (output["PartNumberMarker"] !== void 0) { | |
contents.PartNumberMarker = (0, smithy_client_1.expectString)(output["PartNumberMarker"]); | |
} | |
if (output["NextPartNumberMarker"] !== void 0) { | |
contents.NextPartNumberMarker = (0, smithy_client_1.expectString)(output["NextPartNumberMarker"]); | |
} | |
if (output["MaxParts"] !== void 0) { | |
contents.MaxParts = (0, smithy_client_1.strictParseInt32)(output["MaxParts"]); | |
} | |
if (output["IsTruncated"] !== void 0) { | |
contents.IsTruncated = (0, smithy_client_1.parseBoolean)(output["IsTruncated"]); | |
} | |
if (output.Part === "") { | |
contents.Parts = []; | |
} else if (output["Part"] !== void 0) { | |
contents.Parts = deserializeAws_restXmlPartsList((0, smithy_client_1.getArrayIfSingleItem)(output["Part"]), context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlGrant = (output, context) => { | |
const contents = { | |
Grantee: void 0, | |
Permission: void 0 | |
}; | |
if (output["Grantee"] !== void 0) { | |
contents.Grantee = deserializeAws_restXmlGrantee(output["Grantee"], context); | |
} | |
if (output["Permission"] !== void 0) { | |
contents.Permission = (0, smithy_client_1.expectString)(output["Permission"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlGrantee = (output, context) => { | |
const contents = { | |
DisplayName: void 0, | |
EmailAddress: void 0, | |
ID: void 0, | |
URI: void 0, | |
Type: void 0 | |
}; | |
if (output["DisplayName"] !== void 0) { | |
contents.DisplayName = (0, smithy_client_1.expectString)(output["DisplayName"]); | |
} | |
if (output["EmailAddress"] !== void 0) { | |
contents.EmailAddress = (0, smithy_client_1.expectString)(output["EmailAddress"]); | |
} | |
if (output["ID"] !== void 0) { | |
contents.ID = (0, smithy_client_1.expectString)(output["ID"]); | |
} | |
if (output["URI"] !== void 0) { | |
contents.URI = (0, smithy_client_1.expectString)(output["URI"]); | |
} | |
if (output["xsi:type"] !== void 0) { | |
contents.Type = (0, smithy_client_1.expectString)(output["xsi:type"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlGrants = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlGrant(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlIndexDocument = (output, context) => { | |
const contents = { | |
Suffix: void 0 | |
}; | |
if (output["Suffix"] !== void 0) { | |
contents.Suffix = (0, smithy_client_1.expectString)(output["Suffix"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlInitiator = (output, context) => { | |
const contents = { | |
ID: void 0, | |
DisplayName: void 0 | |
}; | |
if (output["ID"] !== void 0) { | |
contents.ID = (0, smithy_client_1.expectString)(output["ID"]); | |
} | |
if (output["DisplayName"] !== void 0) { | |
contents.DisplayName = (0, smithy_client_1.expectString)(output["DisplayName"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlIntelligentTieringAndOperator = (output, context) => { | |
const contents = { | |
Prefix: void 0, | |
Tags: void 0 | |
}; | |
if (output["Prefix"] !== void 0) { | |
contents.Prefix = (0, smithy_client_1.expectString)(output["Prefix"]); | |
} | |
if (output.Tag === "") { | |
contents.Tags = []; | |
} else if (output["Tag"] !== void 0) { | |
contents.Tags = deserializeAws_restXmlTagSet((0, smithy_client_1.getArrayIfSingleItem)(output["Tag"]), context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlIntelligentTieringConfiguration = (output, context) => { | |
const contents = { | |
Id: void 0, | |
Filter: void 0, | |
Status: void 0, | |
Tierings: void 0 | |
}; | |
if (output["Id"] !== void 0) { | |
contents.Id = (0, smithy_client_1.expectString)(output["Id"]); | |
} | |
if (output["Filter"] !== void 0) { | |
contents.Filter = deserializeAws_restXmlIntelligentTieringFilter(output["Filter"], context); | |
} | |
if (output["Status"] !== void 0) { | |
contents.Status = (0, smithy_client_1.expectString)(output["Status"]); | |
} | |
if (output.Tiering === "") { | |
contents.Tierings = []; | |
} else if (output["Tiering"] !== void 0) { | |
contents.Tierings = deserializeAws_restXmlTieringList((0, smithy_client_1.getArrayIfSingleItem)(output["Tiering"]), context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlIntelligentTieringConfigurationList = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlIntelligentTieringConfiguration(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlIntelligentTieringFilter = (output, context) => { | |
const contents = { | |
Prefix: void 0, | |
Tag: void 0, | |
And: void 0 | |
}; | |
if (output["Prefix"] !== void 0) { | |
contents.Prefix = (0, smithy_client_1.expectString)(output["Prefix"]); | |
} | |
if (output["Tag"] !== void 0) { | |
contents.Tag = deserializeAws_restXmlTag(output["Tag"], context); | |
} | |
if (output["And"] !== void 0) { | |
contents.And = deserializeAws_restXmlIntelligentTieringAndOperator(output["And"], context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlInventoryConfiguration = (output, context) => { | |
const contents = { | |
Destination: void 0, | |
IsEnabled: void 0, | |
Filter: void 0, | |
Id: void 0, | |
IncludedObjectVersions: void 0, | |
OptionalFields: void 0, | |
Schedule: void 0 | |
}; | |
if (output["Destination"] !== void 0) { | |
contents.Destination = deserializeAws_restXmlInventoryDestination(output["Destination"], context); | |
} | |
if (output["IsEnabled"] !== void 0) { | |
contents.IsEnabled = (0, smithy_client_1.parseBoolean)(output["IsEnabled"]); | |
} | |
if (output["Filter"] !== void 0) { | |
contents.Filter = deserializeAws_restXmlInventoryFilter(output["Filter"], context); | |
} | |
if (output["Id"] !== void 0) { | |
contents.Id = (0, smithy_client_1.expectString)(output["Id"]); | |
} | |
if (output["IncludedObjectVersions"] !== void 0) { | |
contents.IncludedObjectVersions = (0, smithy_client_1.expectString)(output["IncludedObjectVersions"]); | |
} | |
if (output.OptionalFields === "") { | |
contents.OptionalFields = []; | |
} else if (output["OptionalFields"] !== void 0 && output["OptionalFields"]["Field"] !== void 0) { | |
contents.OptionalFields = deserializeAws_restXmlInventoryOptionalFields((0, smithy_client_1.getArrayIfSingleItem)(output["OptionalFields"]["Field"]), context); | |
} | |
if (output["Schedule"] !== void 0) { | |
contents.Schedule = deserializeAws_restXmlInventorySchedule(output["Schedule"], context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlInventoryConfigurationList = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlInventoryConfiguration(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlInventoryDestination = (output, context) => { | |
const contents = { | |
S3BucketDestination: void 0 | |
}; | |
if (output["S3BucketDestination"] !== void 0) { | |
contents.S3BucketDestination = deserializeAws_restXmlInventoryS3BucketDestination(output["S3BucketDestination"], context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlInventoryEncryption = (output, context) => { | |
const contents = { | |
SSES3: void 0, | |
SSEKMS: void 0 | |
}; | |
if (output["SSE-S3"] !== void 0) { | |
contents.SSES3 = deserializeAws_restXmlSSES3(output["SSE-S3"], context); | |
} | |
if (output["SSE-KMS"] !== void 0) { | |
contents.SSEKMS = deserializeAws_restXmlSSEKMS(output["SSE-KMS"], context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlInventoryFilter = (output, context) => { | |
const contents = { | |
Prefix: void 0 | |
}; | |
if (output["Prefix"] !== void 0) { | |
contents.Prefix = (0, smithy_client_1.expectString)(output["Prefix"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlInventoryOptionalFields = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return (0, smithy_client_1.expectString)(entry); | |
}); | |
}; | |
var deserializeAws_restXmlInventoryS3BucketDestination = (output, context) => { | |
const contents = { | |
AccountId: void 0, | |
Bucket: void 0, | |
Format: void 0, | |
Prefix: void 0, | |
Encryption: void 0 | |
}; | |
if (output["AccountId"] !== void 0) { | |
contents.AccountId = (0, smithy_client_1.expectString)(output["AccountId"]); | |
} | |
if (output["Bucket"] !== void 0) { | |
contents.Bucket = (0, smithy_client_1.expectString)(output["Bucket"]); | |
} | |
if (output["Format"] !== void 0) { | |
contents.Format = (0, smithy_client_1.expectString)(output["Format"]); | |
} | |
if (output["Prefix"] !== void 0) { | |
contents.Prefix = (0, smithy_client_1.expectString)(output["Prefix"]); | |
} | |
if (output["Encryption"] !== void 0) { | |
contents.Encryption = deserializeAws_restXmlInventoryEncryption(output["Encryption"], context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlInventorySchedule = (output, context) => { | |
const contents = { | |
Frequency: void 0 | |
}; | |
if (output["Frequency"] !== void 0) { | |
contents.Frequency = (0, smithy_client_1.expectString)(output["Frequency"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlLambdaFunctionConfiguration = (output, context) => { | |
const contents = { | |
Id: void 0, | |
LambdaFunctionArn: void 0, | |
Events: void 0, | |
Filter: void 0 | |
}; | |
if (output["Id"] !== void 0) { | |
contents.Id = (0, smithy_client_1.expectString)(output["Id"]); | |
} | |
if (output["CloudFunction"] !== void 0) { | |
contents.LambdaFunctionArn = (0, smithy_client_1.expectString)(output["CloudFunction"]); | |
} | |
if (output.Event === "") { | |
contents.Events = []; | |
} else if (output["Event"] !== void 0) { | |
contents.Events = deserializeAws_restXmlEventList((0, smithy_client_1.getArrayIfSingleItem)(output["Event"]), context); | |
} | |
if (output["Filter"] !== void 0) { | |
contents.Filter = deserializeAws_restXmlNotificationConfigurationFilter(output["Filter"], context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlLambdaFunctionConfigurationList = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlLambdaFunctionConfiguration(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlLifecycleExpiration = (output, context) => { | |
const contents = { | |
Date: void 0, | |
Days: void 0, | |
ExpiredObjectDeleteMarker: void 0 | |
}; | |
if (output["Date"] !== void 0) { | |
contents.Date = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output["Date"])); | |
} | |
if (output["Days"] !== void 0) { | |
contents.Days = (0, smithy_client_1.strictParseInt32)(output["Days"]); | |
} | |
if (output["ExpiredObjectDeleteMarker"] !== void 0) { | |
contents.ExpiredObjectDeleteMarker = (0, smithy_client_1.parseBoolean)(output["ExpiredObjectDeleteMarker"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlLifecycleRule = (output, context) => { | |
const contents = { | |
Expiration: void 0, | |
ID: void 0, | |
Prefix: void 0, | |
Filter: void 0, | |
Status: void 0, | |
Transitions: void 0, | |
NoncurrentVersionTransitions: void 0, | |
NoncurrentVersionExpiration: void 0, | |
AbortIncompleteMultipartUpload: void 0 | |
}; | |
if (output["Expiration"] !== void 0) { | |
contents.Expiration = deserializeAws_restXmlLifecycleExpiration(output["Expiration"], context); | |
} | |
if (output["ID"] !== void 0) { | |
contents.ID = (0, smithy_client_1.expectString)(output["ID"]); | |
} | |
if (output["Prefix"] !== void 0) { | |
contents.Prefix = (0, smithy_client_1.expectString)(output["Prefix"]); | |
} | |
if (output.Filter === "") { | |
} else if (output["Filter"] !== void 0) { | |
contents.Filter = deserializeAws_restXmlLifecycleRuleFilter((0, smithy_client_1.expectUnion)(output["Filter"]), context); | |
} | |
if (output["Status"] !== void 0) { | |
contents.Status = (0, smithy_client_1.expectString)(output["Status"]); | |
} | |
if (output.Transition === "") { | |
contents.Transitions = []; | |
} else if (output["Transition"] !== void 0) { | |
contents.Transitions = deserializeAws_restXmlTransitionList((0, smithy_client_1.getArrayIfSingleItem)(output["Transition"]), context); | |
} | |
if (output.NoncurrentVersionTransition === "") { | |
contents.NoncurrentVersionTransitions = []; | |
} else if (output["NoncurrentVersionTransition"] !== void 0) { | |
contents.NoncurrentVersionTransitions = deserializeAws_restXmlNoncurrentVersionTransitionList((0, smithy_client_1.getArrayIfSingleItem)(output["NoncurrentVersionTransition"]), context); | |
} | |
if (output["NoncurrentVersionExpiration"] !== void 0) { | |
contents.NoncurrentVersionExpiration = deserializeAws_restXmlNoncurrentVersionExpiration(output["NoncurrentVersionExpiration"], context); | |
} | |
if (output["AbortIncompleteMultipartUpload"] !== void 0) { | |
contents.AbortIncompleteMultipartUpload = deserializeAws_restXmlAbortIncompleteMultipartUpload(output["AbortIncompleteMultipartUpload"], context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlLifecycleRuleAndOperator = (output, context) => { | |
const contents = { | |
Prefix: void 0, | |
Tags: void 0, | |
ObjectSizeGreaterThan: void 0, | |
ObjectSizeLessThan: void 0 | |
}; | |
if (output["Prefix"] !== void 0) { | |
contents.Prefix = (0, smithy_client_1.expectString)(output["Prefix"]); | |
} | |
if (output.Tag === "") { | |
contents.Tags = []; | |
} else if (output["Tag"] !== void 0) { | |
contents.Tags = deserializeAws_restXmlTagSet((0, smithy_client_1.getArrayIfSingleItem)(output["Tag"]), context); | |
} | |
if (output["ObjectSizeGreaterThan"] !== void 0) { | |
contents.ObjectSizeGreaterThan = (0, smithy_client_1.strictParseLong)(output["ObjectSizeGreaterThan"]); | |
} | |
if (output["ObjectSizeLessThan"] !== void 0) { | |
contents.ObjectSizeLessThan = (0, smithy_client_1.strictParseLong)(output["ObjectSizeLessThan"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlLifecycleRuleFilter = (output, context) => { | |
if (output["Prefix"] !== void 0) { | |
return { | |
Prefix: (0, smithy_client_1.expectString)(output["Prefix"]) | |
}; | |
} | |
if (output["Tag"] !== void 0) { | |
return { | |
Tag: deserializeAws_restXmlTag(output["Tag"], context) | |
}; | |
} | |
if (output["ObjectSizeGreaterThan"] !== void 0) { | |
return { | |
ObjectSizeGreaterThan: (0, smithy_client_1.strictParseLong)(output["ObjectSizeGreaterThan"]) | |
}; | |
} | |
if (output["ObjectSizeLessThan"] !== void 0) { | |
return { | |
ObjectSizeLessThan: (0, smithy_client_1.strictParseLong)(output["ObjectSizeLessThan"]) | |
}; | |
} | |
if (output["And"] !== void 0) { | |
return { | |
And: deserializeAws_restXmlLifecycleRuleAndOperator(output["And"], context) | |
}; | |
} | |
return { $unknown: Object.entries(output)[0] }; | |
}; | |
var deserializeAws_restXmlLifecycleRules = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlLifecycleRule(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlLoggingEnabled = (output, context) => { | |
const contents = { | |
TargetBucket: void 0, | |
TargetGrants: void 0, | |
TargetPrefix: void 0 | |
}; | |
if (output["TargetBucket"] !== void 0) { | |
contents.TargetBucket = (0, smithy_client_1.expectString)(output["TargetBucket"]); | |
} | |
if (output.TargetGrants === "") { | |
contents.TargetGrants = []; | |
} else if (output["TargetGrants"] !== void 0 && output["TargetGrants"]["Grant"] !== void 0) { | |
contents.TargetGrants = deserializeAws_restXmlTargetGrants((0, smithy_client_1.getArrayIfSingleItem)(output["TargetGrants"]["Grant"]), context); | |
} | |
if (output["TargetPrefix"] !== void 0) { | |
contents.TargetPrefix = (0, smithy_client_1.expectString)(output["TargetPrefix"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlMetrics = (output, context) => { | |
const contents = { | |
Status: void 0, | |
EventThreshold: void 0 | |
}; | |
if (output["Status"] !== void 0) { | |
contents.Status = (0, smithy_client_1.expectString)(output["Status"]); | |
} | |
if (output["EventThreshold"] !== void 0) { | |
contents.EventThreshold = deserializeAws_restXmlReplicationTimeValue(output["EventThreshold"], context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlMetricsAndOperator = (output, context) => { | |
const contents = { | |
Prefix: void 0, | |
Tags: void 0, | |
AccessPointArn: void 0 | |
}; | |
if (output["Prefix"] !== void 0) { | |
contents.Prefix = (0, smithy_client_1.expectString)(output["Prefix"]); | |
} | |
if (output.Tag === "") { | |
contents.Tags = []; | |
} else if (output["Tag"] !== void 0) { | |
contents.Tags = deserializeAws_restXmlTagSet((0, smithy_client_1.getArrayIfSingleItem)(output["Tag"]), context); | |
} | |
if (output["AccessPointArn"] !== void 0) { | |
contents.AccessPointArn = (0, smithy_client_1.expectString)(output["AccessPointArn"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlMetricsConfiguration = (output, context) => { | |
const contents = { | |
Id: void 0, | |
Filter: void 0 | |
}; | |
if (output["Id"] !== void 0) { | |
contents.Id = (0, smithy_client_1.expectString)(output["Id"]); | |
} | |
if (output.Filter === "") { | |
} else if (output["Filter"] !== void 0) { | |
contents.Filter = deserializeAws_restXmlMetricsFilter((0, smithy_client_1.expectUnion)(output["Filter"]), context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlMetricsConfigurationList = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlMetricsConfiguration(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlMetricsFilter = (output, context) => { | |
if (output["Prefix"] !== void 0) { | |
return { | |
Prefix: (0, smithy_client_1.expectString)(output["Prefix"]) | |
}; | |
} | |
if (output["Tag"] !== void 0) { | |
return { | |
Tag: deserializeAws_restXmlTag(output["Tag"], context) | |
}; | |
} | |
if (output["AccessPointArn"] !== void 0) { | |
return { | |
AccessPointArn: (0, smithy_client_1.expectString)(output["AccessPointArn"]) | |
}; | |
} | |
if (output["And"] !== void 0) { | |
return { | |
And: deserializeAws_restXmlMetricsAndOperator(output["And"], context) | |
}; | |
} | |
return { $unknown: Object.entries(output)[0] }; | |
}; | |
var deserializeAws_restXmlMultipartUpload = (output, context) => { | |
const contents = { | |
UploadId: void 0, | |
Key: void 0, | |
Initiated: void 0, | |
StorageClass: void 0, | |
Owner: void 0, | |
Initiator: void 0, | |
ChecksumAlgorithm: void 0 | |
}; | |
if (output["UploadId"] !== void 0) { | |
contents.UploadId = (0, smithy_client_1.expectString)(output["UploadId"]); | |
} | |
if (output["Key"] !== void 0) { | |
contents.Key = (0, smithy_client_1.expectString)(output["Key"]); | |
} | |
if (output["Initiated"] !== void 0) { | |
contents.Initiated = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output["Initiated"])); | |
} | |
if (output["StorageClass"] !== void 0) { | |
contents.StorageClass = (0, smithy_client_1.expectString)(output["StorageClass"]); | |
} | |
if (output["Owner"] !== void 0) { | |
contents.Owner = deserializeAws_restXmlOwner(output["Owner"], context); | |
} | |
if (output["Initiator"] !== void 0) { | |
contents.Initiator = deserializeAws_restXmlInitiator(output["Initiator"], context); | |
} | |
if (output["ChecksumAlgorithm"] !== void 0) { | |
contents.ChecksumAlgorithm = (0, smithy_client_1.expectString)(output["ChecksumAlgorithm"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlMultipartUploadList = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlMultipartUpload(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlNoncurrentVersionExpiration = (output, context) => { | |
const contents = { | |
NoncurrentDays: void 0, | |
NewerNoncurrentVersions: void 0 | |
}; | |
if (output["NoncurrentDays"] !== void 0) { | |
contents.NoncurrentDays = (0, smithy_client_1.strictParseInt32)(output["NoncurrentDays"]); | |
} | |
if (output["NewerNoncurrentVersions"] !== void 0) { | |
contents.NewerNoncurrentVersions = (0, smithy_client_1.strictParseInt32)(output["NewerNoncurrentVersions"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlNoncurrentVersionTransition = (output, context) => { | |
const contents = { | |
NoncurrentDays: void 0, | |
StorageClass: void 0, | |
NewerNoncurrentVersions: void 0 | |
}; | |
if (output["NoncurrentDays"] !== void 0) { | |
contents.NoncurrentDays = (0, smithy_client_1.strictParseInt32)(output["NoncurrentDays"]); | |
} | |
if (output["StorageClass"] !== void 0) { | |
contents.StorageClass = (0, smithy_client_1.expectString)(output["StorageClass"]); | |
} | |
if (output["NewerNoncurrentVersions"] !== void 0) { | |
contents.NewerNoncurrentVersions = (0, smithy_client_1.strictParseInt32)(output["NewerNoncurrentVersions"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlNoncurrentVersionTransitionList = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlNoncurrentVersionTransition(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlNotificationConfigurationFilter = (output, context) => { | |
const contents = { | |
Key: void 0 | |
}; | |
if (output["S3Key"] !== void 0) { | |
contents.Key = deserializeAws_restXmlS3KeyFilter(output["S3Key"], context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXml_Object = (output, context) => { | |
const contents = { | |
Key: void 0, | |
LastModified: void 0, | |
ETag: void 0, | |
ChecksumAlgorithm: void 0, | |
Size: void 0, | |
StorageClass: void 0, | |
Owner: void 0 | |
}; | |
if (output["Key"] !== void 0) { | |
contents.Key = (0, smithy_client_1.expectString)(output["Key"]); | |
} | |
if (output["LastModified"] !== void 0) { | |
contents.LastModified = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output["LastModified"])); | |
} | |
if (output["ETag"] !== void 0) { | |
contents.ETag = (0, smithy_client_1.expectString)(output["ETag"]); | |
} | |
if (output.ChecksumAlgorithm === "") { | |
contents.ChecksumAlgorithm = []; | |
} else if (output["ChecksumAlgorithm"] !== void 0) { | |
contents.ChecksumAlgorithm = deserializeAws_restXmlChecksumAlgorithmList((0, smithy_client_1.getArrayIfSingleItem)(output["ChecksumAlgorithm"]), context); | |
} | |
if (output["Size"] !== void 0) { | |
contents.Size = (0, smithy_client_1.strictParseLong)(output["Size"]); | |
} | |
if (output["StorageClass"] !== void 0) { | |
contents.StorageClass = (0, smithy_client_1.expectString)(output["StorageClass"]); | |
} | |
if (output["Owner"] !== void 0) { | |
contents.Owner = deserializeAws_restXmlOwner(output["Owner"], context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlObjectList = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXml_Object(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlObjectLockConfiguration = (output, context) => { | |
const contents = { | |
ObjectLockEnabled: void 0, | |
Rule: void 0 | |
}; | |
if (output["ObjectLockEnabled"] !== void 0) { | |
contents.ObjectLockEnabled = (0, smithy_client_1.expectString)(output["ObjectLockEnabled"]); | |
} | |
if (output["Rule"] !== void 0) { | |
contents.Rule = deserializeAws_restXmlObjectLockRule(output["Rule"], context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlObjectLockLegalHold = (output, context) => { | |
const contents = { | |
Status: void 0 | |
}; | |
if (output["Status"] !== void 0) { | |
contents.Status = (0, smithy_client_1.expectString)(output["Status"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlObjectLockRetention = (output, context) => { | |
const contents = { | |
Mode: void 0, | |
RetainUntilDate: void 0 | |
}; | |
if (output["Mode"] !== void 0) { | |
contents.Mode = (0, smithy_client_1.expectString)(output["Mode"]); | |
} | |
if (output["RetainUntilDate"] !== void 0) { | |
contents.RetainUntilDate = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output["RetainUntilDate"])); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlObjectLockRule = (output, context) => { | |
const contents = { | |
DefaultRetention: void 0 | |
}; | |
if (output["DefaultRetention"] !== void 0) { | |
contents.DefaultRetention = deserializeAws_restXmlDefaultRetention(output["DefaultRetention"], context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlObjectPart = (output, context) => { | |
const contents = { | |
PartNumber: void 0, | |
Size: void 0, | |
ChecksumCRC32: void 0, | |
ChecksumCRC32C: void 0, | |
ChecksumSHA1: void 0, | |
ChecksumSHA256: void 0 | |
}; | |
if (output["PartNumber"] !== void 0) { | |
contents.PartNumber = (0, smithy_client_1.strictParseInt32)(output["PartNumber"]); | |
} | |
if (output["Size"] !== void 0) { | |
contents.Size = (0, smithy_client_1.strictParseLong)(output["Size"]); | |
} | |
if (output["ChecksumCRC32"] !== void 0) { | |
contents.ChecksumCRC32 = (0, smithy_client_1.expectString)(output["ChecksumCRC32"]); | |
} | |
if (output["ChecksumCRC32C"] !== void 0) { | |
contents.ChecksumCRC32C = (0, smithy_client_1.expectString)(output["ChecksumCRC32C"]); | |
} | |
if (output["ChecksumSHA1"] !== void 0) { | |
contents.ChecksumSHA1 = (0, smithy_client_1.expectString)(output["ChecksumSHA1"]); | |
} | |
if (output["ChecksumSHA256"] !== void 0) { | |
contents.ChecksumSHA256 = (0, smithy_client_1.expectString)(output["ChecksumSHA256"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlObjectVersion = (output, context) => { | |
const contents = { | |
ETag: void 0, | |
ChecksumAlgorithm: void 0, | |
Size: void 0, | |
StorageClass: void 0, | |
Key: void 0, | |
VersionId: void 0, | |
IsLatest: void 0, | |
LastModified: void 0, | |
Owner: void 0 | |
}; | |
if (output["ETag"] !== void 0) { | |
contents.ETag = (0, smithy_client_1.expectString)(output["ETag"]); | |
} | |
if (output.ChecksumAlgorithm === "") { | |
contents.ChecksumAlgorithm = []; | |
} else if (output["ChecksumAlgorithm"] !== void 0) { | |
contents.ChecksumAlgorithm = deserializeAws_restXmlChecksumAlgorithmList((0, smithy_client_1.getArrayIfSingleItem)(output["ChecksumAlgorithm"]), context); | |
} | |
if (output["Size"] !== void 0) { | |
contents.Size = (0, smithy_client_1.strictParseLong)(output["Size"]); | |
} | |
if (output["StorageClass"] !== void 0) { | |
contents.StorageClass = (0, smithy_client_1.expectString)(output["StorageClass"]); | |
} | |
if (output["Key"] !== void 0) { | |
contents.Key = (0, smithy_client_1.expectString)(output["Key"]); | |
} | |
if (output["VersionId"] !== void 0) { | |
contents.VersionId = (0, smithy_client_1.expectString)(output["VersionId"]); | |
} | |
if (output["IsLatest"] !== void 0) { | |
contents.IsLatest = (0, smithy_client_1.parseBoolean)(output["IsLatest"]); | |
} | |
if (output["LastModified"] !== void 0) { | |
contents.LastModified = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output["LastModified"])); | |
} | |
if (output["Owner"] !== void 0) { | |
contents.Owner = deserializeAws_restXmlOwner(output["Owner"], context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlObjectVersionList = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlObjectVersion(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlOwner = (output, context) => { | |
const contents = { | |
DisplayName: void 0, | |
ID: void 0 | |
}; | |
if (output["DisplayName"] !== void 0) { | |
contents.DisplayName = (0, smithy_client_1.expectString)(output["DisplayName"]); | |
} | |
if (output["ID"] !== void 0) { | |
contents.ID = (0, smithy_client_1.expectString)(output["ID"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlOwnershipControls = (output, context) => { | |
const contents = { | |
Rules: void 0 | |
}; | |
if (output.Rule === "") { | |
contents.Rules = []; | |
} else if (output["Rule"] !== void 0) { | |
contents.Rules = deserializeAws_restXmlOwnershipControlsRules((0, smithy_client_1.getArrayIfSingleItem)(output["Rule"]), context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlOwnershipControlsRule = (output, context) => { | |
const contents = { | |
ObjectOwnership: void 0 | |
}; | |
if (output["ObjectOwnership"] !== void 0) { | |
contents.ObjectOwnership = (0, smithy_client_1.expectString)(output["ObjectOwnership"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlOwnershipControlsRules = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlOwnershipControlsRule(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlPart = (output, context) => { | |
const contents = { | |
PartNumber: void 0, | |
LastModified: void 0, | |
ETag: void 0, | |
Size: void 0, | |
ChecksumCRC32: void 0, | |
ChecksumCRC32C: void 0, | |
ChecksumSHA1: void 0, | |
ChecksumSHA256: void 0 | |
}; | |
if (output["PartNumber"] !== void 0) { | |
contents.PartNumber = (0, smithy_client_1.strictParseInt32)(output["PartNumber"]); | |
} | |
if (output["LastModified"] !== void 0) { | |
contents.LastModified = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output["LastModified"])); | |
} | |
if (output["ETag"] !== void 0) { | |
contents.ETag = (0, smithy_client_1.expectString)(output["ETag"]); | |
} | |
if (output["Size"] !== void 0) { | |
contents.Size = (0, smithy_client_1.strictParseLong)(output["Size"]); | |
} | |
if (output["ChecksumCRC32"] !== void 0) { | |
contents.ChecksumCRC32 = (0, smithy_client_1.expectString)(output["ChecksumCRC32"]); | |
} | |
if (output["ChecksumCRC32C"] !== void 0) { | |
contents.ChecksumCRC32C = (0, smithy_client_1.expectString)(output["ChecksumCRC32C"]); | |
} | |
if (output["ChecksumSHA1"] !== void 0) { | |
contents.ChecksumSHA1 = (0, smithy_client_1.expectString)(output["ChecksumSHA1"]); | |
} | |
if (output["ChecksumSHA256"] !== void 0) { | |
contents.ChecksumSHA256 = (0, smithy_client_1.expectString)(output["ChecksumSHA256"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlParts = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlPart(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlPartsList = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlObjectPart(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlPolicyStatus = (output, context) => { | |
const contents = { | |
IsPublic: void 0 | |
}; | |
if (output["IsPublic"] !== void 0) { | |
contents.IsPublic = (0, smithy_client_1.parseBoolean)(output["IsPublic"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlProgress = (output, context) => { | |
const contents = { | |
BytesScanned: void 0, | |
BytesProcessed: void 0, | |
BytesReturned: void 0 | |
}; | |
if (output["BytesScanned"] !== void 0) { | |
contents.BytesScanned = (0, smithy_client_1.strictParseLong)(output["BytesScanned"]); | |
} | |
if (output["BytesProcessed"] !== void 0) { | |
contents.BytesProcessed = (0, smithy_client_1.strictParseLong)(output["BytesProcessed"]); | |
} | |
if (output["BytesReturned"] !== void 0) { | |
contents.BytesReturned = (0, smithy_client_1.strictParseLong)(output["BytesReturned"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlPublicAccessBlockConfiguration = (output, context) => { | |
const contents = { | |
BlockPublicAcls: void 0, | |
IgnorePublicAcls: void 0, | |
BlockPublicPolicy: void 0, | |
RestrictPublicBuckets: void 0 | |
}; | |
if (output["BlockPublicAcls"] !== void 0) { | |
contents.BlockPublicAcls = (0, smithy_client_1.parseBoolean)(output["BlockPublicAcls"]); | |
} | |
if (output["IgnorePublicAcls"] !== void 0) { | |
contents.IgnorePublicAcls = (0, smithy_client_1.parseBoolean)(output["IgnorePublicAcls"]); | |
} | |
if (output["BlockPublicPolicy"] !== void 0) { | |
contents.BlockPublicPolicy = (0, smithy_client_1.parseBoolean)(output["BlockPublicPolicy"]); | |
} | |
if (output["RestrictPublicBuckets"] !== void 0) { | |
contents.RestrictPublicBuckets = (0, smithy_client_1.parseBoolean)(output["RestrictPublicBuckets"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlQueueConfiguration = (output, context) => { | |
const contents = { | |
Id: void 0, | |
QueueArn: void 0, | |
Events: void 0, | |
Filter: void 0 | |
}; | |
if (output["Id"] !== void 0) { | |
contents.Id = (0, smithy_client_1.expectString)(output["Id"]); | |
} | |
if (output["Queue"] !== void 0) { | |
contents.QueueArn = (0, smithy_client_1.expectString)(output["Queue"]); | |
} | |
if (output.Event === "") { | |
contents.Events = []; | |
} else if (output["Event"] !== void 0) { | |
contents.Events = deserializeAws_restXmlEventList((0, smithy_client_1.getArrayIfSingleItem)(output["Event"]), context); | |
} | |
if (output["Filter"] !== void 0) { | |
contents.Filter = deserializeAws_restXmlNotificationConfigurationFilter(output["Filter"], context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlQueueConfigurationList = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlQueueConfiguration(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlRedirect = (output, context) => { | |
const contents = { | |
HostName: void 0, | |
HttpRedirectCode: void 0, | |
Protocol: void 0, | |
ReplaceKeyPrefixWith: void 0, | |
ReplaceKeyWith: void 0 | |
}; | |
if (output["HostName"] !== void 0) { | |
contents.HostName = (0, smithy_client_1.expectString)(output["HostName"]); | |
} | |
if (output["HttpRedirectCode"] !== void 0) { | |
contents.HttpRedirectCode = (0, smithy_client_1.expectString)(output["HttpRedirectCode"]); | |
} | |
if (output["Protocol"] !== void 0) { | |
contents.Protocol = (0, smithy_client_1.expectString)(output["Protocol"]); | |
} | |
if (output["ReplaceKeyPrefixWith"] !== void 0) { | |
contents.ReplaceKeyPrefixWith = (0, smithy_client_1.expectString)(output["ReplaceKeyPrefixWith"]); | |
} | |
if (output["ReplaceKeyWith"] !== void 0) { | |
contents.ReplaceKeyWith = (0, smithy_client_1.expectString)(output["ReplaceKeyWith"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlRedirectAllRequestsTo = (output, context) => { | |
const contents = { | |
HostName: void 0, | |
Protocol: void 0 | |
}; | |
if (output["HostName"] !== void 0) { | |
contents.HostName = (0, smithy_client_1.expectString)(output["HostName"]); | |
} | |
if (output["Protocol"] !== void 0) { | |
contents.Protocol = (0, smithy_client_1.expectString)(output["Protocol"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlReplicaModifications = (output, context) => { | |
const contents = { | |
Status: void 0 | |
}; | |
if (output["Status"] !== void 0) { | |
contents.Status = (0, smithy_client_1.expectString)(output["Status"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlReplicationConfiguration = (output, context) => { | |
const contents = { | |
Role: void 0, | |
Rules: void 0 | |
}; | |
if (output["Role"] !== void 0) { | |
contents.Role = (0, smithy_client_1.expectString)(output["Role"]); | |
} | |
if (output.Rule === "") { | |
contents.Rules = []; | |
} else if (output["Rule"] !== void 0) { | |
contents.Rules = deserializeAws_restXmlReplicationRules((0, smithy_client_1.getArrayIfSingleItem)(output["Rule"]), context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlReplicationRule = (output, context) => { | |
const contents = { | |
ID: void 0, | |
Priority: void 0, | |
Prefix: void 0, | |
Filter: void 0, | |
Status: void 0, | |
SourceSelectionCriteria: void 0, | |
ExistingObjectReplication: void 0, | |
Destination: void 0, | |
DeleteMarkerReplication: void 0 | |
}; | |
if (output["ID"] !== void 0) { | |
contents.ID = (0, smithy_client_1.expectString)(output["ID"]); | |
} | |
if (output["Priority"] !== void 0) { | |
contents.Priority = (0, smithy_client_1.strictParseInt32)(output["Priority"]); | |
} | |
if (output["Prefix"] !== void 0) { | |
contents.Prefix = (0, smithy_client_1.expectString)(output["Prefix"]); | |
} | |
if (output.Filter === "") { | |
} else if (output["Filter"] !== void 0) { | |
contents.Filter = deserializeAws_restXmlReplicationRuleFilter((0, smithy_client_1.expectUnion)(output["Filter"]), context); | |
} | |
if (output["Status"] !== void 0) { | |
contents.Status = (0, smithy_client_1.expectString)(output["Status"]); | |
} | |
if (output["SourceSelectionCriteria"] !== void 0) { | |
contents.SourceSelectionCriteria = deserializeAws_restXmlSourceSelectionCriteria(output["SourceSelectionCriteria"], context); | |
} | |
if (output["ExistingObjectReplication"] !== void 0) { | |
contents.ExistingObjectReplication = deserializeAws_restXmlExistingObjectReplication(output["ExistingObjectReplication"], context); | |
} | |
if (output["Destination"] !== void 0) { | |
contents.Destination = deserializeAws_restXmlDestination(output["Destination"], context); | |
} | |
if (output["DeleteMarkerReplication"] !== void 0) { | |
contents.DeleteMarkerReplication = deserializeAws_restXmlDeleteMarkerReplication(output["DeleteMarkerReplication"], context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlReplicationRuleAndOperator = (output, context) => { | |
const contents = { | |
Prefix: void 0, | |
Tags: void 0 | |
}; | |
if (output["Prefix"] !== void 0) { | |
contents.Prefix = (0, smithy_client_1.expectString)(output["Prefix"]); | |
} | |
if (output.Tag === "") { | |
contents.Tags = []; | |
} else if (output["Tag"] !== void 0) { | |
contents.Tags = deserializeAws_restXmlTagSet((0, smithy_client_1.getArrayIfSingleItem)(output["Tag"]), context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlReplicationRuleFilter = (output, context) => { | |
if (output["Prefix"] !== void 0) { | |
return { | |
Prefix: (0, smithy_client_1.expectString)(output["Prefix"]) | |
}; | |
} | |
if (output["Tag"] !== void 0) { | |
return { | |
Tag: deserializeAws_restXmlTag(output["Tag"], context) | |
}; | |
} | |
if (output["And"] !== void 0) { | |
return { | |
And: deserializeAws_restXmlReplicationRuleAndOperator(output["And"], context) | |
}; | |
} | |
return { $unknown: Object.entries(output)[0] }; | |
}; | |
var deserializeAws_restXmlReplicationRules = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlReplicationRule(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlReplicationTime = (output, context) => { | |
const contents = { | |
Status: void 0, | |
Time: void 0 | |
}; | |
if (output["Status"] !== void 0) { | |
contents.Status = (0, smithy_client_1.expectString)(output["Status"]); | |
} | |
if (output["Time"] !== void 0) { | |
contents.Time = deserializeAws_restXmlReplicationTimeValue(output["Time"], context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlReplicationTimeValue = (output, context) => { | |
const contents = { | |
Minutes: void 0 | |
}; | |
if (output["Minutes"] !== void 0) { | |
contents.Minutes = (0, smithy_client_1.strictParseInt32)(output["Minutes"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlRoutingRule = (output, context) => { | |
const contents = { | |
Condition: void 0, | |
Redirect: void 0 | |
}; | |
if (output["Condition"] !== void 0) { | |
contents.Condition = deserializeAws_restXmlCondition(output["Condition"], context); | |
} | |
if (output["Redirect"] !== void 0) { | |
contents.Redirect = deserializeAws_restXmlRedirect(output["Redirect"], context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlRoutingRules = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlRoutingRule(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlS3KeyFilter = (output, context) => { | |
const contents = { | |
FilterRules: void 0 | |
}; | |
if (output.FilterRule === "") { | |
contents.FilterRules = []; | |
} else if (output["FilterRule"] !== void 0) { | |
contents.FilterRules = deserializeAws_restXmlFilterRuleList((0, smithy_client_1.getArrayIfSingleItem)(output["FilterRule"]), context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlServerSideEncryptionByDefault = (output, context) => { | |
const contents = { | |
SSEAlgorithm: void 0, | |
KMSMasterKeyID: void 0 | |
}; | |
if (output["SSEAlgorithm"] !== void 0) { | |
contents.SSEAlgorithm = (0, smithy_client_1.expectString)(output["SSEAlgorithm"]); | |
} | |
if (output["KMSMasterKeyID"] !== void 0) { | |
contents.KMSMasterKeyID = (0, smithy_client_1.expectString)(output["KMSMasterKeyID"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlServerSideEncryptionConfiguration = (output, context) => { | |
const contents = { | |
Rules: void 0 | |
}; | |
if (output.Rule === "") { | |
contents.Rules = []; | |
} else if (output["Rule"] !== void 0) { | |
contents.Rules = deserializeAws_restXmlServerSideEncryptionRules((0, smithy_client_1.getArrayIfSingleItem)(output["Rule"]), context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlServerSideEncryptionRule = (output, context) => { | |
const contents = { | |
ApplyServerSideEncryptionByDefault: void 0, | |
BucketKeyEnabled: void 0 | |
}; | |
if (output["ApplyServerSideEncryptionByDefault"] !== void 0) { | |
contents.ApplyServerSideEncryptionByDefault = deserializeAws_restXmlServerSideEncryptionByDefault(output["ApplyServerSideEncryptionByDefault"], context); | |
} | |
if (output["BucketKeyEnabled"] !== void 0) { | |
contents.BucketKeyEnabled = (0, smithy_client_1.parseBoolean)(output["BucketKeyEnabled"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlServerSideEncryptionRules = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlServerSideEncryptionRule(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlSourceSelectionCriteria = (output, context) => { | |
const contents = { | |
SseKmsEncryptedObjects: void 0, | |
ReplicaModifications: void 0 | |
}; | |
if (output["SseKmsEncryptedObjects"] !== void 0) { | |
contents.SseKmsEncryptedObjects = deserializeAws_restXmlSseKmsEncryptedObjects(output["SseKmsEncryptedObjects"], context); | |
} | |
if (output["ReplicaModifications"] !== void 0) { | |
contents.ReplicaModifications = deserializeAws_restXmlReplicaModifications(output["ReplicaModifications"], context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlSSEKMS = (output, context) => { | |
const contents = { | |
KeyId: void 0 | |
}; | |
if (output["KeyId"] !== void 0) { | |
contents.KeyId = (0, smithy_client_1.expectString)(output["KeyId"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlSseKmsEncryptedObjects = (output, context) => { | |
const contents = { | |
Status: void 0 | |
}; | |
if (output["Status"] !== void 0) { | |
contents.Status = (0, smithy_client_1.expectString)(output["Status"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlSSES3 = (output, context) => { | |
const contents = {}; | |
return contents; | |
}; | |
var deserializeAws_restXmlStats = (output, context) => { | |
const contents = { | |
BytesScanned: void 0, | |
BytesProcessed: void 0, | |
BytesReturned: void 0 | |
}; | |
if (output["BytesScanned"] !== void 0) { | |
contents.BytesScanned = (0, smithy_client_1.strictParseLong)(output["BytesScanned"]); | |
} | |
if (output["BytesProcessed"] !== void 0) { | |
contents.BytesProcessed = (0, smithy_client_1.strictParseLong)(output["BytesProcessed"]); | |
} | |
if (output["BytesReturned"] !== void 0) { | |
contents.BytesReturned = (0, smithy_client_1.strictParseLong)(output["BytesReturned"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlStorageClassAnalysis = (output, context) => { | |
const contents = { | |
DataExport: void 0 | |
}; | |
if (output["DataExport"] !== void 0) { | |
contents.DataExport = deserializeAws_restXmlStorageClassAnalysisDataExport(output["DataExport"], context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlStorageClassAnalysisDataExport = (output, context) => { | |
const contents = { | |
OutputSchemaVersion: void 0, | |
Destination: void 0 | |
}; | |
if (output["OutputSchemaVersion"] !== void 0) { | |
contents.OutputSchemaVersion = (0, smithy_client_1.expectString)(output["OutputSchemaVersion"]); | |
} | |
if (output["Destination"] !== void 0) { | |
contents.Destination = deserializeAws_restXmlAnalyticsExportDestination(output["Destination"], context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlTag = (output, context) => { | |
const contents = { | |
Key: void 0, | |
Value: void 0 | |
}; | |
if (output["Key"] !== void 0) { | |
contents.Key = (0, smithy_client_1.expectString)(output["Key"]); | |
} | |
if (output["Value"] !== void 0) { | |
contents.Value = (0, smithy_client_1.expectString)(output["Value"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlTagSet = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlTag(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlTargetGrant = (output, context) => { | |
const contents = { | |
Grantee: void 0, | |
Permission: void 0 | |
}; | |
if (output["Grantee"] !== void 0) { | |
contents.Grantee = deserializeAws_restXmlGrantee(output["Grantee"], context); | |
} | |
if (output["Permission"] !== void 0) { | |
contents.Permission = (0, smithy_client_1.expectString)(output["Permission"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlTargetGrants = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlTargetGrant(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlTiering = (output, context) => { | |
const contents = { | |
Days: void 0, | |
AccessTier: void 0 | |
}; | |
if (output["Days"] !== void 0) { | |
contents.Days = (0, smithy_client_1.strictParseInt32)(output["Days"]); | |
} | |
if (output["AccessTier"] !== void 0) { | |
contents.AccessTier = (0, smithy_client_1.expectString)(output["AccessTier"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlTieringList = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlTiering(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlTopicConfiguration = (output, context) => { | |
const contents = { | |
Id: void 0, | |
TopicArn: void 0, | |
Events: void 0, | |
Filter: void 0 | |
}; | |
if (output["Id"] !== void 0) { | |
contents.Id = (0, smithy_client_1.expectString)(output["Id"]); | |
} | |
if (output["Topic"] !== void 0) { | |
contents.TopicArn = (0, smithy_client_1.expectString)(output["Topic"]); | |
} | |
if (output.Event === "") { | |
contents.Events = []; | |
} else if (output["Event"] !== void 0) { | |
contents.Events = deserializeAws_restXmlEventList((0, smithy_client_1.getArrayIfSingleItem)(output["Event"]), context); | |
} | |
if (output["Filter"] !== void 0) { | |
contents.Filter = deserializeAws_restXmlNotificationConfigurationFilter(output["Filter"], context); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlTopicConfigurationList = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlTopicConfiguration(entry, context); | |
}); | |
}; | |
var deserializeAws_restXmlTransition = (output, context) => { | |
const contents = { | |
Date: void 0, | |
Days: void 0, | |
StorageClass: void 0 | |
}; | |
if (output["Date"] !== void 0) { | |
contents.Date = (0, smithy_client_1.expectNonNull)((0, smithy_client_1.parseRfc3339DateTimeWithOffset)(output["Date"])); | |
} | |
if (output["Days"] !== void 0) { | |
contents.Days = (0, smithy_client_1.strictParseInt32)(output["Days"]); | |
} | |
if (output["StorageClass"] !== void 0) { | |
contents.StorageClass = (0, smithy_client_1.expectString)(output["StorageClass"]); | |
} | |
return contents; | |
}; | |
var deserializeAws_restXmlTransitionList = (output, context) => { | |
return (output || []).filter((e) => e != null).map((entry) => { | |
return deserializeAws_restXmlTransition(entry, context); | |
}); | |
}; | |
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 collectBody = (streamBody = new Uint8Array(), context) => { | |
if (streamBody instanceof Uint8Array) { | |
return Promise.resolve(streamBody); | |
} | |
return context.streamCollector(streamBody) || Promise.resolve(new Uint8Array()); | |
}; | |
var collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body)); | |
var isSerializableHeaderValue = (value) => value !== void 0 && value !== null && value !== "" && (!Object.getOwnPropertyNames(value).includes("length") || value.length != 0) && (!Object.getOwnPropertyNames(value).includes("size") || value.size != 0); | |
var parseBody = (streamBody, context) => collectBodyString(streamBody, context).then((encoded) => { | |
if (encoded.length) { | |
const parser = new fast_xml_parser_1.XMLParser({ | |
attributeNamePrefix: "", | |
htmlEntities: true, | |
ignoreAttributes: false, | |
ignoreDeclaration: true, | |
parseTagValue: false, | |
trimValues: false, | |
tagValueProcessor: (_, val) => val.trim() === "" && val.includes("\n") ? "" : void 0 | |
}); | |
parser.addEntity("#xD", "\r"); | |
parser.addEntity("#10", "\n"); | |
const parsedObj = parser.parse(encoded); | |
const textNodeName = "#text"; | |
const key = Object.keys(parsedObj)[0]; | |
const parsedObjToReturn = parsedObj[key]; | |
if (parsedObjToReturn[textNodeName]) { | |
parsedObjToReturn[key] = parsedObjToReturn[textNodeName]; | |
delete parsedObjToReturn[textNodeName]; | |
} | |
return (0, smithy_client_1.getValueFromTextNode)(parsedObjToReturn); | |
} | |
return {}; | |
}); | |
var parseErrorBody = async (errorBody, context) => { | |
const value = await parseBody(errorBody, context); | |
if (value.Error) { | |
value.Error.message = value.Error.message ?? value.Error.Message; | |
} | |
return value; | |
}; | |
var loadRestXmlErrorCode = (output, data) => { | |
if ((data == null ? void 0 : data.Code) !== void 0) { | |
return data.Code; | |
} | |
if (output.statusCode == 404) { | |
return "NotFound"; | |
} | |
}; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/AbortMultipartUploadCommand.js | |
var require_AbortMultipartUploadCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/AbortMultipartUploadCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.AbortMultipartUploadCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var AbortMultipartUploadCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, AbortMultipartUploadCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "AbortMultipartUploadCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.AbortMultipartUploadRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.AbortMultipartUploadOutputFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlAbortMultipartUploadCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlAbortMultipartUploadCommand)(output, context); | |
} | |
}; | |
exports.AbortMultipartUploadCommand = AbortMultipartUploadCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-sdk-s3@3.272.0/node_modules/@aws-sdk/middleware-sdk-s3/dist-cjs/check-content-length-header.js | |
var require_check_content_length_header = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-sdk-s3@3.272.0/node_modules/@aws-sdk/middleware-sdk-s3/dist-cjs/check-content-length-header.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.getCheckContentLengthHeaderPlugin = exports.checkContentLengthHeaderMiddlewareOptions = exports.checkContentLengthHeader = void 0; | |
var protocol_http_1 = require_dist_cjs8(); | |
var CONTENT_LENGTH_HEADER = "content-length"; | |
function checkContentLengthHeader() { | |
return (next, context) => async (args) => { | |
var _a; | |
const { request } = args; | |
if (protocol_http_1.HttpRequest.isInstance(request)) { | |
if (!request.headers[CONTENT_LENGTH_HEADER]) { | |
const message = `Are you using a Stream of unknown length as the Body of a PutObject request? Consider using Upload instead from @aws-sdk/lib-storage.`; | |
if (typeof ((_a = context === null || context === void 0 ? void 0 : context.logger) === null || _a === void 0 ? void 0 : _a.warn) === "function") { | |
context.logger.warn(message); | |
} else { | |
console.warn(message); | |
} | |
} | |
} | |
return next({ ...args }); | |
}; | |
} | |
exports.checkContentLengthHeader = checkContentLengthHeader; | |
exports.checkContentLengthHeaderMiddlewareOptions = { | |
step: "finalizeRequest", | |
tags: ["CHECK_CONTENT_LENGTH_HEADER"], | |
name: "getCheckContentLengthHeaderPlugin", | |
override: true | |
}; | |
var getCheckContentLengthHeaderPlugin = (unused) => ({ | |
applyToStack: (clientStack) => { | |
clientStack.add(checkContentLengthHeader(), exports.checkContentLengthHeaderMiddlewareOptions); | |
} | |
}); | |
exports.getCheckContentLengthHeaderPlugin = getCheckContentLengthHeaderPlugin; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-sdk-s3@3.272.0/node_modules/@aws-sdk/middleware-sdk-s3/dist-cjs/configuration.js | |
var require_configuration = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-sdk-s3@3.272.0/node_modules/@aws-sdk/middleware-sdk-s3/dist-cjs/configuration.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.resolveS3Config = void 0; | |
var resolveS3Config = (input) => { | |
var _a, _b, _c; | |
return { | |
...input, | |
forcePathStyle: (_a = input.forcePathStyle) !== null && _a !== void 0 ? _a : false, | |
useAccelerateEndpoint: (_b = input.useAccelerateEndpoint) !== null && _b !== void 0 ? _b : false, | |
disableMultiregionAccessPoints: (_c = input.disableMultiregionAccessPoints) !== null && _c !== void 0 ? _c : false | |
}; | |
}; | |
exports.resolveS3Config = resolveS3Config; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-sdk-s3@3.272.0/node_modules/@aws-sdk/middleware-sdk-s3/dist-cjs/throw-200-exceptions.js | |
var require_throw_200_exceptions = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-sdk-s3@3.272.0/node_modules/@aws-sdk/middleware-sdk-s3/dist-cjs/throw-200-exceptions.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.getThrow200ExceptionsPlugin = exports.throw200ExceptionsMiddlewareOptions = exports.throw200ExceptionsMiddleware = void 0; | |
var protocol_http_1 = require_dist_cjs8(); | |
var throw200ExceptionsMiddleware = (config) => (next) => async (args) => { | |
const result = await next(args); | |
const { response } = result; | |
if (!protocol_http_1.HttpResponse.isInstance(response)) | |
return result; | |
const { statusCode, body } = response; | |
if (statusCode < 200 || statusCode >= 300) | |
return result; | |
const bodyBytes = await collectBody(body, config); | |
const bodyString = await collectBodyString(bodyBytes, config); | |
if (bodyBytes.length === 0) { | |
const err = new Error("S3 aborted request"); | |
err.name = "InternalError"; | |
throw err; | |
} | |
if (bodyString && bodyString.match("<Error>")) { | |
response.statusCode = 400; | |
} | |
response.body = bodyBytes; | |
return result; | |
}; | |
exports.throw200ExceptionsMiddleware = throw200ExceptionsMiddleware; | |
var collectBody = (streamBody = new Uint8Array(), context) => { | |
if (streamBody instanceof Uint8Array) { | |
return Promise.resolve(streamBody); | |
} | |
return context.streamCollector(streamBody) || Promise.resolve(new Uint8Array()); | |
}; | |
var collectBodyString = (streamBody, context) => collectBody(streamBody, context).then((body) => context.utf8Encoder(body)); | |
exports.throw200ExceptionsMiddlewareOptions = { | |
relation: "after", | |
toMiddleware: "deserializerMiddleware", | |
tags: ["THROW_200_EXCEPTIONS", "S3"], | |
name: "throw200ExceptionsMiddleware", | |
override: true | |
}; | |
var getThrow200ExceptionsPlugin = (config) => ({ | |
applyToStack: (clientStack) => { | |
clientStack.addRelativeTo((0, exports.throw200ExceptionsMiddleware)(config), exports.throw200ExceptionsMiddlewareOptions); | |
} | |
}); | |
exports.getThrow200ExceptionsPlugin = getThrow200ExceptionsPlugin; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+util-arn-parser@3.208.0/node_modules/@aws-sdk/util-arn-parser/dist-cjs/index.js | |
var require_dist_cjs10 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+util-arn-parser@3.208.0/node_modules/@aws-sdk/util-arn-parser/dist-cjs/index.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.build = exports.parse = exports.validate = void 0; | |
var validate2 = (str) => typeof str === "string" && str.indexOf("arn:") === 0 && str.split(":").length >= 6; | |
exports.validate = validate2; | |
var parse2 = (arn) => { | |
const segments = arn.split(":"); | |
if (segments.length < 6 || segments[0] !== "arn") | |
throw new Error("Malformed ARN"); | |
const [, partition, service, region, accountId, ...resource] = segments; | |
return { | |
partition, | |
service, | |
region, | |
accountId, | |
resource: resource.join(":") | |
}; | |
}; | |
exports.parse = parse2; | |
var build = (arnObject) => { | |
const { partition = "aws", service, region, accountId, resource } = arnObject; | |
if ([service, region, accountId, resource].some((segment) => typeof segment !== "string")) { | |
throw new Error("Input ARN object is invalid"); | |
} | |
return `arn:${partition}:${service}:${region}:${accountId}:${resource}`; | |
}; | |
exports.build = build; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-sdk-s3@3.272.0/node_modules/@aws-sdk/middleware-sdk-s3/dist-cjs/validate-bucket-name.js | |
var require_validate_bucket_name = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-sdk-s3@3.272.0/node_modules/@aws-sdk/middleware-sdk-s3/dist-cjs/validate-bucket-name.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.getValidateBucketNamePlugin = exports.validateBucketNameMiddlewareOptions = exports.validateBucketNameMiddleware = void 0; | |
var util_arn_parser_1 = require_dist_cjs10(); | |
function validateBucketNameMiddleware() { | |
return (next) => async (args) => { | |
const { input: { Bucket } } = args; | |
if (typeof Bucket === "string" && !(0, util_arn_parser_1.validate)(Bucket) && Bucket.indexOf("/") >= 0) { | |
const err = new Error(`Bucket name shouldn't contain '/', received '${Bucket}'`); | |
err.name = "InvalidBucketName"; | |
throw err; | |
} | |
return next({ ...args }); | |
}; | |
} | |
exports.validateBucketNameMiddleware = validateBucketNameMiddleware; | |
exports.validateBucketNameMiddlewareOptions = { | |
step: "initialize", | |
tags: ["VALIDATE_BUCKET_NAME"], | |
name: "validateBucketNameMiddleware", | |
override: true | |
}; | |
var getValidateBucketNamePlugin = (unused) => ({ | |
applyToStack: (clientStack) => { | |
clientStack.add(validateBucketNameMiddleware(), exports.validateBucketNameMiddlewareOptions); | |
} | |
}); | |
exports.getValidateBucketNamePlugin = getValidateBucketNamePlugin; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-sdk-s3@3.272.0/node_modules/@aws-sdk/middleware-sdk-s3/dist-cjs/index.js | |
var require_dist_cjs11 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-sdk-s3@3.272.0/node_modules/@aws-sdk/middleware-sdk-s3/dist-cjs/index.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); | |
tslib_1.__exportStar(require_check_content_length_header(), exports); | |
tslib_1.__exportStar(require_configuration(), exports); | |
tslib_1.__exportStar(require_throw_200_exceptions(), exports); | |
tslib_1.__exportStar(require_validate_bucket_name(), exports); | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-ssec@3.272.0/node_modules/@aws-sdk/middleware-ssec/dist-cjs/index.js | |
var require_dist_cjs12 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-ssec@3.272.0/node_modules/@aws-sdk/middleware-ssec/dist-cjs/index.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.getSsecPlugin = exports.ssecMiddlewareOptions = exports.ssecMiddleware = void 0; | |
function ssecMiddleware(options) { | |
return (next) => async (args) => { | |
let input = { ...args.input }; | |
const properties = [ | |
{ | |
target: "SSECustomerKey", | |
hash: "SSECustomerKeyMD5" | |
}, | |
{ | |
target: "CopySourceSSECustomerKey", | |
hash: "CopySourceSSECustomerKeyMD5" | |
} | |
]; | |
for (const prop of properties) { | |
const value = input[prop.target]; | |
if (value) { | |
const valueView = ArrayBuffer.isView(value) ? new Uint8Array(value.buffer, value.byteOffset, value.byteLength) : typeof value === "string" ? options.utf8Decoder(value) : new Uint8Array(value); | |
const encoded = options.base64Encoder(valueView); | |
const hash = new options.md5(); | |
hash.update(valueView); | |
input = { | |
...input, | |
[prop.target]: encoded, | |
[prop.hash]: options.base64Encoder(await hash.digest()) | |
}; | |
} | |
} | |
return next({ | |
...args, | |
input | |
}); | |
}; | |
} | |
exports.ssecMiddleware = ssecMiddleware; | |
exports.ssecMiddlewareOptions = { | |
name: "ssecMiddleware", | |
step: "initialize", | |
tags: ["SSE"], | |
override: true | |
}; | |
var getSsecPlugin = (config) => ({ | |
applyToStack: (clientStack) => { | |
clientStack.add(ssecMiddleware(config), exports.ssecMiddlewareOptions); | |
} | |
}); | |
exports.getSsecPlugin = getSsecPlugin; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/CompleteMultipartUploadCommand.js | |
var require_CompleteMultipartUploadCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/CompleteMultipartUploadCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.CompleteMultipartUploadCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_sdk_s3_1 = require_dist_cjs11(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var middleware_ssec_1 = require_dist_cjs12(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var CompleteMultipartUploadCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, CompleteMultipartUploadCommand.getEndpointParameterInstructions())); | |
this.middlewareStack.use((0, middleware_sdk_s3_1.getThrow200ExceptionsPlugin)(configuration)); | |
this.middlewareStack.use((0, middleware_ssec_1.getSsecPlugin)(configuration)); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "CompleteMultipartUploadCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.CompleteMultipartUploadRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.CompleteMultipartUploadOutputFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlCompleteMultipartUploadCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlCompleteMultipartUploadCommand)(output, context); | |
} | |
}; | |
exports.CompleteMultipartUploadCommand = CompleteMultipartUploadCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/CopyObjectCommand.js | |
var require_CopyObjectCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/CopyObjectCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.CopyObjectCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_sdk_s3_1 = require_dist_cjs11(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var middleware_ssec_1 = require_dist_cjs12(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var CopyObjectCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, CopyObjectCommand.getEndpointParameterInstructions())); | |
this.middlewareStack.use((0, middleware_sdk_s3_1.getThrow200ExceptionsPlugin)(configuration)); | |
this.middlewareStack.use((0, middleware_ssec_1.getSsecPlugin)(configuration)); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "CopyObjectCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.CopyObjectRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.CopyObjectOutputFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlCopyObjectCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlCopyObjectCommand)(output, context); | |
} | |
}; | |
exports.CopyObjectCommand = CopyObjectCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-location-constraint@3.272.0/node_modules/@aws-sdk/middleware-location-constraint/dist-cjs/index.js | |
var require_dist_cjs13 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-location-constraint@3.272.0/node_modules/@aws-sdk/middleware-location-constraint/dist-cjs/index.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.getLocationConstraintPlugin = exports.locationConstraintMiddlewareOptions = exports.locationConstraintMiddleware = void 0; | |
function locationConstraintMiddleware(options) { | |
return (next) => async (args) => { | |
const { CreateBucketConfiguration } = args.input; | |
const region = await options.region(); | |
if (!CreateBucketConfiguration || !CreateBucketConfiguration.LocationConstraint) { | |
args = { | |
...args, | |
input: { | |
...args.input, | |
CreateBucketConfiguration: region === "us-east-1" ? void 0 : { LocationConstraint: region } | |
} | |
}; | |
} | |
return next(args); | |
}; | |
} | |
exports.locationConstraintMiddleware = locationConstraintMiddleware; | |
exports.locationConstraintMiddlewareOptions = { | |
step: "initialize", | |
tags: ["LOCATION_CONSTRAINT", "CREATE_BUCKET_CONFIGURATION"], | |
name: "locationConstraintMiddleware", | |
override: true | |
}; | |
var getLocationConstraintPlugin = (config) => ({ | |
applyToStack: (clientStack) => { | |
clientStack.add(locationConstraintMiddleware(config), exports.locationConstraintMiddlewareOptions); | |
} | |
}); | |
exports.getLocationConstraintPlugin = getLocationConstraintPlugin; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/CreateBucketCommand.js | |
var require_CreateBucketCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/CreateBucketCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.CreateBucketCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_location_constraint_1 = require_dist_cjs13(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var CreateBucketCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
DisableAccessPoints: { type: "staticContextParams", value: true }, | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, CreateBucketCommand.getEndpointParameterInstructions())); | |
this.middlewareStack.use((0, middleware_location_constraint_1.getLocationConstraintPlugin)(configuration)); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "CreateBucketCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.CreateBucketRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.CreateBucketOutputFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlCreateBucketCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlCreateBucketCommand)(output, context); | |
} | |
}; | |
exports.CreateBucketCommand = CreateBucketCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/CreateMultipartUploadCommand.js | |
var require_CreateMultipartUploadCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/CreateMultipartUploadCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.CreateMultipartUploadCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var middleware_ssec_1 = require_dist_cjs12(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var CreateMultipartUploadCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, CreateMultipartUploadCommand.getEndpointParameterInstructions())); | |
this.middlewareStack.use((0, middleware_ssec_1.getSsecPlugin)(configuration)); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "CreateMultipartUploadCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.CreateMultipartUploadRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.CreateMultipartUploadOutputFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlCreateMultipartUploadCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlCreateMultipartUploadCommand)(output, context); | |
} | |
}; | |
exports.CreateMultipartUploadCommand = CreateMultipartUploadCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketAnalyticsConfigurationCommand.js | |
var require_DeleteBucketAnalyticsConfigurationCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketAnalyticsConfigurationCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.DeleteBucketAnalyticsConfigurationCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var DeleteBucketAnalyticsConfigurationCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteBucketAnalyticsConfigurationCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "DeleteBucketAnalyticsConfigurationCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.DeleteBucketAnalyticsConfigurationRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: (output) => output | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlDeleteBucketAnalyticsConfigurationCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlDeleteBucketAnalyticsConfigurationCommand)(output, context); | |
} | |
}; | |
exports.DeleteBucketAnalyticsConfigurationCommand = DeleteBucketAnalyticsConfigurationCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketCommand.js | |
var require_DeleteBucketCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.DeleteBucketCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var DeleteBucketCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteBucketCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "DeleteBucketCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.DeleteBucketRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: (output) => output | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlDeleteBucketCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlDeleteBucketCommand)(output, context); | |
} | |
}; | |
exports.DeleteBucketCommand = DeleteBucketCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketCorsCommand.js | |
var require_DeleteBucketCorsCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketCorsCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.DeleteBucketCorsCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var DeleteBucketCorsCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteBucketCorsCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "DeleteBucketCorsCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.DeleteBucketCorsRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: (output) => output | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlDeleteBucketCorsCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlDeleteBucketCorsCommand)(output, context); | |
} | |
}; | |
exports.DeleteBucketCorsCommand = DeleteBucketCorsCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketEncryptionCommand.js | |
var require_DeleteBucketEncryptionCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketEncryptionCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.DeleteBucketEncryptionCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var DeleteBucketEncryptionCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteBucketEncryptionCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "DeleteBucketEncryptionCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.DeleteBucketEncryptionRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: (output) => output | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlDeleteBucketEncryptionCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlDeleteBucketEncryptionCommand)(output, context); | |
} | |
}; | |
exports.DeleteBucketEncryptionCommand = DeleteBucketEncryptionCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketIntelligentTieringConfigurationCommand.js | |
var require_DeleteBucketIntelligentTieringConfigurationCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketIntelligentTieringConfigurationCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.DeleteBucketIntelligentTieringConfigurationCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var DeleteBucketIntelligentTieringConfigurationCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteBucketIntelligentTieringConfigurationCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "DeleteBucketIntelligentTieringConfigurationCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.DeleteBucketIntelligentTieringConfigurationRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: (output) => output | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlDeleteBucketIntelligentTieringConfigurationCommand)(output, context); | |
} | |
}; | |
exports.DeleteBucketIntelligentTieringConfigurationCommand = DeleteBucketIntelligentTieringConfigurationCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketInventoryConfigurationCommand.js | |
var require_DeleteBucketInventoryConfigurationCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketInventoryConfigurationCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.DeleteBucketInventoryConfigurationCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var DeleteBucketInventoryConfigurationCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteBucketInventoryConfigurationCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "DeleteBucketInventoryConfigurationCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.DeleteBucketInventoryConfigurationRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: (output) => output | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlDeleteBucketInventoryConfigurationCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlDeleteBucketInventoryConfigurationCommand)(output, context); | |
} | |
}; | |
exports.DeleteBucketInventoryConfigurationCommand = DeleteBucketInventoryConfigurationCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketLifecycleCommand.js | |
var require_DeleteBucketLifecycleCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketLifecycleCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.DeleteBucketLifecycleCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var DeleteBucketLifecycleCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteBucketLifecycleCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "DeleteBucketLifecycleCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.DeleteBucketLifecycleRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: (output) => output | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlDeleteBucketLifecycleCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlDeleteBucketLifecycleCommand)(output, context); | |
} | |
}; | |
exports.DeleteBucketLifecycleCommand = DeleteBucketLifecycleCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketMetricsConfigurationCommand.js | |
var require_DeleteBucketMetricsConfigurationCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketMetricsConfigurationCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.DeleteBucketMetricsConfigurationCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var DeleteBucketMetricsConfigurationCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteBucketMetricsConfigurationCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "DeleteBucketMetricsConfigurationCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.DeleteBucketMetricsConfigurationRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: (output) => output | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlDeleteBucketMetricsConfigurationCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlDeleteBucketMetricsConfigurationCommand)(output, context); | |
} | |
}; | |
exports.DeleteBucketMetricsConfigurationCommand = DeleteBucketMetricsConfigurationCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketOwnershipControlsCommand.js | |
var require_DeleteBucketOwnershipControlsCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketOwnershipControlsCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.DeleteBucketOwnershipControlsCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var DeleteBucketOwnershipControlsCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteBucketOwnershipControlsCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "DeleteBucketOwnershipControlsCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.DeleteBucketOwnershipControlsRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: (output) => output | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlDeleteBucketOwnershipControlsCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlDeleteBucketOwnershipControlsCommand)(output, context); | |
} | |
}; | |
exports.DeleteBucketOwnershipControlsCommand = DeleteBucketOwnershipControlsCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketPolicyCommand.js | |
var require_DeleteBucketPolicyCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketPolicyCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.DeleteBucketPolicyCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var DeleteBucketPolicyCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteBucketPolicyCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "DeleteBucketPolicyCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.DeleteBucketPolicyRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: (output) => output | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlDeleteBucketPolicyCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlDeleteBucketPolicyCommand)(output, context); | |
} | |
}; | |
exports.DeleteBucketPolicyCommand = DeleteBucketPolicyCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketReplicationCommand.js | |
var require_DeleteBucketReplicationCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketReplicationCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.DeleteBucketReplicationCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var DeleteBucketReplicationCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteBucketReplicationCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "DeleteBucketReplicationCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.DeleteBucketReplicationRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: (output) => output | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlDeleteBucketReplicationCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlDeleteBucketReplicationCommand)(output, context); | |
} | |
}; | |
exports.DeleteBucketReplicationCommand = DeleteBucketReplicationCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketTaggingCommand.js | |
var require_DeleteBucketTaggingCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketTaggingCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.DeleteBucketTaggingCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var DeleteBucketTaggingCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteBucketTaggingCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "DeleteBucketTaggingCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.DeleteBucketTaggingRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: (output) => output | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlDeleteBucketTaggingCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlDeleteBucketTaggingCommand)(output, context); | |
} | |
}; | |
exports.DeleteBucketTaggingCommand = DeleteBucketTaggingCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketWebsiteCommand.js | |
var require_DeleteBucketWebsiteCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteBucketWebsiteCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.DeleteBucketWebsiteCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var DeleteBucketWebsiteCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteBucketWebsiteCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "DeleteBucketWebsiteCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.DeleteBucketWebsiteRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: (output) => output | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlDeleteBucketWebsiteCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlDeleteBucketWebsiteCommand)(output, context); | |
} | |
}; | |
exports.DeleteBucketWebsiteCommand = DeleteBucketWebsiteCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteObjectCommand.js | |
var require_DeleteObjectCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteObjectCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.DeleteObjectCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var DeleteObjectCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteObjectCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "DeleteObjectCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.DeleteObjectRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.DeleteObjectOutputFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlDeleteObjectCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlDeleteObjectCommand)(output, context); | |
} | |
}; | |
exports.DeleteObjectCommand = DeleteObjectCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/constants.js | |
var require_constants2 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/constants.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.ChecksumLocation = exports.ChecksumAlgorithm = void 0; | |
var ChecksumAlgorithm; | |
(function(ChecksumAlgorithm2) { | |
ChecksumAlgorithm2["MD5"] = "MD5"; | |
ChecksumAlgorithm2["CRC32"] = "CRC32"; | |
ChecksumAlgorithm2["CRC32C"] = "CRC32C"; | |
ChecksumAlgorithm2["SHA1"] = "SHA1"; | |
ChecksumAlgorithm2["SHA256"] = "SHA256"; | |
})(ChecksumAlgorithm = exports.ChecksumAlgorithm || (exports.ChecksumAlgorithm = {})); | |
var ChecksumLocation; | |
(function(ChecksumLocation2) { | |
ChecksumLocation2["HEADER"] = "header"; | |
ChecksumLocation2["TRAILER"] = "trailer"; | |
})(ChecksumLocation = exports.ChecksumLocation || (exports.ChecksumLocation = {})); | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/types.js | |
var require_types2 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/types.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.PRIORITY_ORDER_ALGORITHMS = exports.CLIENT_SUPPORTED_ALGORITHMS = void 0; | |
var constants_1 = require_constants2(); | |
exports.CLIENT_SUPPORTED_ALGORITHMS = [ | |
constants_1.ChecksumAlgorithm.CRC32, | |
constants_1.ChecksumAlgorithm.CRC32C, | |
constants_1.ChecksumAlgorithm.SHA1, | |
constants_1.ChecksumAlgorithm.SHA256 | |
]; | |
exports.PRIORITY_ORDER_ALGORITHMS = [ | |
constants_1.ChecksumAlgorithm.CRC32, | |
constants_1.ChecksumAlgorithm.CRC32C, | |
constants_1.ChecksumAlgorithm.SHA1, | |
constants_1.ChecksumAlgorithm.SHA256 | |
]; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/getChecksumAlgorithmForRequest.js | |
var require_getChecksumAlgorithmForRequest = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/getChecksumAlgorithmForRequest.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.getChecksumAlgorithmForRequest = void 0; | |
var constants_1 = require_constants2(); | |
var types_1 = require_types2(); | |
var getChecksumAlgorithmForRequest = (input, { requestChecksumRequired, requestAlgorithmMember }) => { | |
if (!requestAlgorithmMember || !input[requestAlgorithmMember]) { | |
return requestChecksumRequired ? constants_1.ChecksumAlgorithm.MD5 : void 0; | |
} | |
const checksumAlgorithm = input[requestAlgorithmMember]; | |
if (!types_1.CLIENT_SUPPORTED_ALGORITHMS.includes(checksumAlgorithm)) { | |
throw new Error(`The checksum algorithm "${checksumAlgorithm}" is not supported by the client. Select one of ${types_1.CLIENT_SUPPORTED_ALGORITHMS}.`); | |
} | |
return checksumAlgorithm; | |
}; | |
exports.getChecksumAlgorithmForRequest = getChecksumAlgorithmForRequest; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/getChecksumLocationName.js | |
var require_getChecksumLocationName = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/getChecksumLocationName.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.getChecksumLocationName = void 0; | |
var constants_1 = require_constants2(); | |
var getChecksumLocationName = (algorithm) => algorithm === constants_1.ChecksumAlgorithm.MD5 ? "content-md5" : `x-amz-checksum-${algorithm.toLowerCase()}`; | |
exports.getChecksumLocationName = getChecksumLocationName; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/hasHeader.js | |
var require_hasHeader = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/hasHeader.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.hasHeader = void 0; | |
var hasHeader = (header, headers) => { | |
const soughtHeader = header.toLowerCase(); | |
for (const headerName of Object.keys(headers)) { | |
if (soughtHeader === headerName.toLowerCase()) { | |
return true; | |
} | |
} | |
return false; | |
}; | |
exports.hasHeader = hasHeader; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+is-array-buffer@3.201.0/node_modules/@aws-sdk/is-array-buffer/dist-cjs/index.js | |
var require_dist_cjs14 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+is-array-buffer@3.201.0/node_modules/@aws-sdk/is-array-buffer/dist-cjs/index.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.isArrayBuffer = void 0; | |
var isArrayBuffer2 = (arg) => typeof ArrayBuffer === "function" && arg instanceof ArrayBuffer || Object.prototype.toString.call(arg) === "[object ArrayBuffer]"; | |
exports.isArrayBuffer = isArrayBuffer2; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/isStreaming.js | |
var require_isStreaming = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/isStreaming.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.isStreaming = void 0; | |
var is_array_buffer_1 = require_dist_cjs14(); | |
var isStreaming = (body) => body !== void 0 && typeof body !== "string" && !ArrayBuffer.isView(body) && !(0, is_array_buffer_1.isArrayBuffer)(body); | |
exports.isStreaming = isStreaming; | |
} | |
}); | |
// ../../node_modules/.pnpm/tslib@1.14.1/node_modules/tslib/tslib.es6.js | |
var tslib_es6_exports2 = {}; | |
__export(tslib_es6_exports2, { | |
__assign: () => __assign2, | |
__asyncDelegator: () => __asyncDelegator2, | |
__asyncGenerator: () => __asyncGenerator2, | |
__asyncValues: () => __asyncValues2, | |
__await: () => __await2, | |
__awaiter: () => __awaiter2, | |
__classPrivateFieldGet: () => __classPrivateFieldGet2, | |
__classPrivateFieldSet: () => __classPrivateFieldSet2, | |
__createBinding: () => __createBinding2, | |
__decorate: () => __decorate2, | |
__exportStar: () => __exportStar2, | |
__extends: () => __extends2, | |
__generator: () => __generator2, | |
__importDefault: () => __importDefault2, | |
__importStar: () => __importStar2, | |
__makeTemplateObject: () => __makeTemplateObject2, | |
__metadata: () => __metadata2, | |
__param: () => __param2, | |
__read: () => __read2, | |
__rest: () => __rest2, | |
__spread: () => __spread2, | |
__spreadArrays: () => __spreadArrays2, | |
__values: () => __values2 | |
}); | |
function __extends2(d, b) { | |
extendStatics2(d, b); | |
function __() { | |
this.constructor = d; | |
} | |
d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); | |
} | |
function __rest2(s, e) { | |
var t = {}; | |
for (var p in s) | |
if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0) | |
t[p] = s[p]; | |
if (s != null && typeof Object.getOwnPropertySymbols === "function") | |
for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) { | |
if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i])) | |
t[p[i]] = s[p[i]]; | |
} | |
return t; | |
} | |
function __decorate2(decorators, target, key, desc) { | |
var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d; | |
if (typeof Reflect === "object" && typeof Reflect.decorate === "function") | |
r = Reflect.decorate(decorators, target, key, desc); | |
else | |
for (var i = decorators.length - 1; i >= 0; i--) | |
if (d = decorators[i]) | |
r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r; | |
return c > 3 && r && Object.defineProperty(target, key, r), r; | |
} | |
function __param2(paramIndex, decorator) { | |
return function(target, key) { | |
decorator(target, key, paramIndex); | |
}; | |
} | |
function __metadata2(metadataKey, metadataValue) { | |
if (typeof Reflect === "object" && typeof Reflect.metadata === "function") | |
return Reflect.metadata(metadataKey, metadataValue); | |
} | |
function __awaiter2(thisArg, _arguments, P, generator) { | |
function adopt(value) { | |
return value instanceof P ? value : new P(function(resolve) { | |
resolve(value); | |
}); | |
} | |
return new (P || (P = Promise))(function(resolve, reject) { | |
function fulfilled(value) { | |
try { | |
step(generator.next(value)); | |
} catch (e) { | |
reject(e); | |
} | |
} | |
function rejected(value) { | |
try { | |
step(generator["throw"](value)); | |
} catch (e) { | |
reject(e); | |
} | |
} | |
function step(result) { | |
result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); | |
} | |
step((generator = generator.apply(thisArg, _arguments || [])).next()); | |
}); | |
} | |
function __generator2(thisArg, body) { | |
var _ = { label: 0, sent: function() { | |
if (t[0] & 1) | |
throw t[1]; | |
return t[1]; | |
}, trys: [], ops: [] }, f, y, t, g; | |
return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { | |
return this; | |
}), g; | |
function verb(n) { | |
return function(v) { | |
return step([n, v]); | |
}; | |
} | |
function step(op) { | |
if (f) | |
throw new TypeError("Generator is already executing."); | |
while (_) | |
try { | |
if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) | |
return t; | |
if (y = 0, t) | |
op = [op[0] & 2, t.value]; | |
switch (op[0]) { | |
case 0: | |
case 1: | |
t = op; | |
break; | |
case 4: | |
_.label++; | |
return { value: op[1], done: false }; | |
case 5: | |
_.label++; | |
y = op[1]; | |
op = [0]; | |
continue; | |
case 7: | |
op = _.ops.pop(); | |
_.trys.pop(); | |
continue; | |
default: | |
if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { | |
_ = 0; | |
continue; | |
} | |
if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) { | |
_.label = op[1]; | |
break; | |
} | |
if (op[0] === 6 && _.label < t[1]) { | |
_.label = t[1]; | |
t = op; | |
break; | |
} | |
if (t && _.label < t[2]) { | |
_.label = t[2]; | |
_.ops.push(op); | |
break; | |
} | |
if (t[2]) | |
_.ops.pop(); | |
_.trys.pop(); | |
continue; | |
} | |
op = body.call(thisArg, _); | |
} catch (e) { | |
op = [6, e]; | |
y = 0; | |
} finally { | |
f = t = 0; | |
} | |
if (op[0] & 5) | |
throw op[1]; | |
return { value: op[0] ? op[1] : void 0, done: true }; | |
} | |
} | |
function __createBinding2(o, m, k, k2) { | |
if (k2 === void 0) | |
k2 = k; | |
o[k2] = m[k]; | |
} | |
function __exportStar2(m, exports) { | |
for (var p in m) | |
if (p !== "default" && !exports.hasOwnProperty(p)) | |
exports[p] = m[p]; | |
} | |
function __values2(o) { | |
var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0; | |
if (m) | |
return m.call(o); | |
if (o && typeof o.length === "number") | |
return { | |
next: function() { | |
if (o && i >= o.length) | |
o = void 0; | |
return { value: o && o[i++], done: !o }; | |
} | |
}; | |
throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined."); | |
} | |
function __read2(o, n) { | |
var m = typeof Symbol === "function" && o[Symbol.iterator]; | |
if (!m) | |
return o; | |
var i = m.call(o), r, ar = [], e; | |
try { | |
while ((n === void 0 || n-- > 0) && !(r = i.next()).done) | |
ar.push(r.value); | |
} catch (error) { | |
e = { error }; | |
} finally { | |
try { | |
if (r && !r.done && (m = i["return"])) | |
m.call(i); | |
} finally { | |
if (e) | |
throw e.error; | |
} | |
} | |
return ar; | |
} | |
function __spread2() { | |
for (var ar = [], i = 0; i < arguments.length; i++) | |
ar = ar.concat(__read2(arguments[i])); | |
return ar; | |
} | |
function __spreadArrays2() { | |
for (var s = 0, i = 0, il = arguments.length; i < il; i++) | |
s += arguments[i].length; | |
for (var r = Array(s), k = 0, i = 0; i < il; i++) | |
for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++) | |
r[k] = a[j]; | |
return r; | |
} | |
function __await2(v) { | |
return this instanceof __await2 ? (this.v = v, this) : new __await2(v); | |
} | |
function __asyncGenerator2(thisArg, _arguments, generator) { | |
if (!Symbol.asyncIterator) | |
throw new TypeError("Symbol.asyncIterator is not defined."); | |
var g = generator.apply(thisArg, _arguments || []), i, q = []; | |
return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() { | |
return this; | |
}, i; | |
function verb(n) { | |
if (g[n]) | |
i[n] = function(v) { | |
return new Promise(function(a, b) { | |
q.push([n, v, a, b]) > 1 || resume(n, v); | |
}); | |
}; | |
} | |
function resume(n, v) { | |
try { | |
step(g[n](v)); | |
} catch (e) { | |
settle2(q[0][3], e); | |
} | |
} | |
function step(r) { | |
r.value instanceof __await2 ? Promise.resolve(r.value.v).then(fulfill, reject) : settle2(q[0][2], r); | |
} | |
function fulfill(value) { | |
resume("next", value); | |
} | |
function reject(value) { | |
resume("throw", value); | |
} | |
function settle2(f, v) { | |
if (f(v), q.shift(), q.length) | |
resume(q[0][0], q[0][1]); | |
} | |
} | |
function __asyncDelegator2(o) { | |
var i, p; | |
return i = {}, verb("next"), verb("throw", function(e) { | |
throw e; | |
}), verb("return"), i[Symbol.iterator] = function() { | |
return this; | |
}, i; | |
function verb(n, f) { | |
i[n] = o[n] ? function(v) { | |
return (p = !p) ? { value: __await2(o[n](v)), done: n === "return" } : f ? f(v) : v; | |
} : f; | |
} | |
} | |
function __asyncValues2(o) { | |
if (!Symbol.asyncIterator) | |
throw new TypeError("Symbol.asyncIterator is not defined."); | |
var m = o[Symbol.asyncIterator], i; | |
return m ? m.call(o) : (o = typeof __values2 === "function" ? __values2(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() { | |
return this; | |
}, i); | |
function verb(n) { | |
i[n] = o[n] && function(v) { | |
return new Promise(function(resolve, reject) { | |
v = o[n](v), settle2(resolve, reject, v.done, v.value); | |
}); | |
}; | |
} | |
function settle2(resolve, reject, d, v) { | |
Promise.resolve(v).then(function(v2) { | |
resolve({ value: v2, done: d }); | |
}, reject); | |
} | |
} | |
function __makeTemplateObject2(cooked, raw) { | |
if (Object.defineProperty) { | |
Object.defineProperty(cooked, "raw", { value: raw }); | |
} else { | |
cooked.raw = raw; | |
} | |
return cooked; | |
} | |
function __importStar2(mod) { | |
if (mod && mod.__esModule) | |
return mod; | |
var result = {}; | |
if (mod != null) { | |
for (var k in mod) | |
if (Object.hasOwnProperty.call(mod, k)) | |
result[k] = mod[k]; | |
} | |
result.default = mod; | |
return result; | |
} | |
function __importDefault2(mod) { | |
return mod && mod.__esModule ? mod : { default: mod }; | |
} | |
function __classPrivateFieldGet2(receiver, privateMap) { | |
if (!privateMap.has(receiver)) { | |
throw new TypeError("attempted to get private field on non-instance"); | |
} | |
return privateMap.get(receiver); | |
} | |
function __classPrivateFieldSet2(receiver, privateMap, value) { | |
if (!privateMap.has(receiver)) { | |
throw new TypeError("attempted to set private field on non-instance"); | |
} | |
privateMap.set(receiver, value); | |
return value; | |
} | |
var extendStatics2, __assign2; | |
var init_tslib_es62 = __esm({ | |
"../../node_modules/.pnpm/tslib@1.14.1/node_modules/tslib/tslib.es6.js"() { | |
extendStatics2 = function(d, b) { | |
extendStatics2 = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) { | |
d2.__proto__ = b2; | |
} || function(d2, b2) { | |
for (var p in b2) | |
if (b2.hasOwnProperty(p)) | |
d2[p] = b2[p]; | |
}; | |
return extendStatics2(d, b); | |
}; | |
__assign2 = function() { | |
__assign2 = Object.assign || function __assign3(t) { | |
for (var s, i = 1, n = arguments.length; i < n; i++) { | |
s = arguments[i]; | |
for (var p in s) | |
if (Object.prototype.hasOwnProperty.call(s, p)) | |
t[p] = s[p]; | |
} | |
return t; | |
}; | |
return __assign2.apply(this, arguments); | |
}; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+util-utf8-browser@3.188.0/node_modules/@aws-sdk/util-utf8-browser/dist-cjs/pureJs.js | |
var require_pureJs = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+util-utf8-browser@3.188.0/node_modules/@aws-sdk/util-utf8-browser/dist-cjs/pureJs.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.toUtf8 = exports.fromUtf8 = void 0; | |
var fromUtf8 = (input) => { | |
const bytes = []; | |
for (let i = 0, len = input.length; i < len; i++) { | |
const value = input.charCodeAt(i); | |
if (value < 128) { | |
bytes.push(value); | |
} else if (value < 2048) { | |
bytes.push(value >> 6 | 192, value & 63 | 128); | |
} else if (i + 1 < input.length && (value & 64512) === 55296 && (input.charCodeAt(i + 1) & 64512) === 56320) { | |
const surrogatePair = 65536 + ((value & 1023) << 10) + (input.charCodeAt(++i) & 1023); | |
bytes.push(surrogatePair >> 18 | 240, surrogatePair >> 12 & 63 | 128, surrogatePair >> 6 & 63 | 128, surrogatePair & 63 | 128); | |
} else { | |
bytes.push(value >> 12 | 224, value >> 6 & 63 | 128, value & 63 | 128); | |
} | |
} | |
return Uint8Array.from(bytes); | |
}; | |
exports.fromUtf8 = fromUtf8; | |
var toUtf8 = (input) => { | |
let decoded = ""; | |
for (let i = 0, len = input.length; i < len; i++) { | |
const byte = input[i]; | |
if (byte < 128) { | |
decoded += String.fromCharCode(byte); | |
} else if (192 <= byte && byte < 224) { | |
const nextByte = input[++i]; | |
decoded += String.fromCharCode((byte & 31) << 6 | nextByte & 63); | |
} else if (240 <= byte && byte < 365) { | |
const surrogatePair = [byte, input[++i], input[++i], input[++i]]; | |
const encoded = "%" + surrogatePair.map((byteValue) => byteValue.toString(16)).join("%"); | |
decoded += decodeURIComponent(encoded); | |
} else { | |
decoded += String.fromCharCode((byte & 15) << 12 | (input[++i] & 63) << 6 | input[++i] & 63); | |
} | |
} | |
return decoded; | |
}; | |
exports.toUtf8 = toUtf8; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+util-utf8-browser@3.188.0/node_modules/@aws-sdk/util-utf8-browser/dist-cjs/whatwgEncodingApi.js | |
var require_whatwgEncodingApi = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+util-utf8-browser@3.188.0/node_modules/@aws-sdk/util-utf8-browser/dist-cjs/whatwgEncodingApi.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.toUtf8 = exports.fromUtf8 = void 0; | |
function fromUtf8(input) { | |
return new TextEncoder().encode(input); | |
} | |
exports.fromUtf8 = fromUtf8; | |
function toUtf8(input) { | |
return new TextDecoder("utf-8").decode(input); | |
} | |
exports.toUtf8 = toUtf8; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+util-utf8-browser@3.188.0/node_modules/@aws-sdk/util-utf8-browser/dist-cjs/index.js | |
var require_dist_cjs15 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+util-utf8-browser@3.188.0/node_modules/@aws-sdk/util-utf8-browser/dist-cjs/index.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.toUtf8 = exports.fromUtf8 = void 0; | |
var pureJs_1 = require_pureJs(); | |
var whatwgEncodingApi_1 = require_whatwgEncodingApi(); | |
var fromUtf8 = (input) => typeof TextEncoder === "function" ? (0, whatwgEncodingApi_1.fromUtf8)(input) : (0, pureJs_1.fromUtf8)(input); | |
exports.fromUtf8 = fromUtf8; | |
var toUtf8 = (input) => typeof TextDecoder === "function" ? (0, whatwgEncodingApi_1.toUtf8)(input) : (0, pureJs_1.toUtf8)(input); | |
exports.toUtf8 = toUtf8; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-crypto+util@3.0.0/node_modules/@aws-crypto/util/build/convertToBuffer.js | |
var require_convertToBuffer = __commonJS({ | |
"../../node_modules/.pnpm/@aws-crypto+util@3.0.0/node_modules/@aws-crypto/util/build/convertToBuffer.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.convertToBuffer = void 0; | |
var util_utf8_browser_1 = require_dist_cjs15(); | |
var fromUtf8 = typeof Buffer !== "undefined" && Buffer.from ? function(input) { | |
return Buffer.from(input, "utf8"); | |
} : util_utf8_browser_1.fromUtf8; | |
function convertToBuffer(data) { | |
if (data instanceof Uint8Array) | |
return data; | |
if (typeof data === "string") { | |
return fromUtf8(data); | |
} | |
if (ArrayBuffer.isView(data)) { | |
return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT); | |
} | |
return new Uint8Array(data); | |
} | |
exports.convertToBuffer = convertToBuffer; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-crypto+util@3.0.0/node_modules/@aws-crypto/util/build/isEmptyData.js | |
var require_isEmptyData = __commonJS({ | |
"../../node_modules/.pnpm/@aws-crypto+util@3.0.0/node_modules/@aws-crypto/util/build/isEmptyData.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.isEmptyData = void 0; | |
function isEmptyData(data) { | |
if (typeof data === "string") { | |
return data.length === 0; | |
} | |
return data.byteLength === 0; | |
} | |
exports.isEmptyData = isEmptyData; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-crypto+util@3.0.0/node_modules/@aws-crypto/util/build/numToUint8.js | |
var require_numToUint8 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-crypto+util@3.0.0/node_modules/@aws-crypto/util/build/numToUint8.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.numToUint8 = void 0; | |
function numToUint8(num) { | |
return new Uint8Array([ | |
(num & 4278190080) >> 24, | |
(num & 16711680) >> 16, | |
(num & 65280) >> 8, | |
num & 255 | |
]); | |
} | |
exports.numToUint8 = numToUint8; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-crypto+util@3.0.0/node_modules/@aws-crypto/util/build/uint32ArrayFrom.js | |
var require_uint32ArrayFrom = __commonJS({ | |
"../../node_modules/.pnpm/@aws-crypto+util@3.0.0/node_modules/@aws-crypto/util/build/uint32ArrayFrom.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.uint32ArrayFrom = void 0; | |
function uint32ArrayFrom(a_lookUpTable) { | |
if (!Uint32Array.from) { | |
var return_array = new Uint32Array(a_lookUpTable.length); | |
var a_index = 0; | |
while (a_index < a_lookUpTable.length) { | |
return_array[a_index] = a_lookUpTable[a_index]; | |
a_index += 1; | |
} | |
return return_array; | |
} | |
return Uint32Array.from(a_lookUpTable); | |
} | |
exports.uint32ArrayFrom = uint32ArrayFrom; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-crypto+util@3.0.0/node_modules/@aws-crypto/util/build/index.js | |
var require_build = __commonJS({ | |
"../../node_modules/.pnpm/@aws-crypto+util@3.0.0/node_modules/@aws-crypto/util/build/index.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.uint32ArrayFrom = exports.numToUint8 = exports.isEmptyData = exports.convertToBuffer = void 0; | |
var convertToBuffer_1 = require_convertToBuffer(); | |
Object.defineProperty(exports, "convertToBuffer", { enumerable: true, get: function() { | |
return convertToBuffer_1.convertToBuffer; | |
} }); | |
var isEmptyData_1 = require_isEmptyData(); | |
Object.defineProperty(exports, "isEmptyData", { enumerable: true, get: function() { | |
return isEmptyData_1.isEmptyData; | |
} }); | |
var numToUint8_1 = require_numToUint8(); | |
Object.defineProperty(exports, "numToUint8", { enumerable: true, get: function() { | |
return numToUint8_1.numToUint8; | |
} }); | |
var uint32ArrayFrom_1 = require_uint32ArrayFrom(); | |
Object.defineProperty(exports, "uint32ArrayFrom", { enumerable: true, get: function() { | |
return uint32ArrayFrom_1.uint32ArrayFrom; | |
} }); | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-crypto+crc32@3.0.0/node_modules/@aws-crypto/crc32/build/aws_crc32.js | |
var require_aws_crc32 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-crypto+crc32@3.0.0/node_modules/@aws-crypto/crc32/build/aws_crc32.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.AwsCrc32 = void 0; | |
var tslib_1 = (init_tslib_es62(), __toCommonJS(tslib_es6_exports2)); | |
var util_1 = require_build(); | |
var index_1 = require_build2(); | |
var AwsCrc32 = ( | |
/** @class */ | |
function() { | |
function AwsCrc322() { | |
this.crc32 = new index_1.Crc32(); | |
} | |
AwsCrc322.prototype.update = function(toHash) { | |
if ((0, util_1.isEmptyData)(toHash)) | |
return; | |
this.crc32.update((0, util_1.convertToBuffer)(toHash)); | |
}; | |
AwsCrc322.prototype.digest = function() { | |
return tslib_1.__awaiter(this, void 0, void 0, function() { | |
return tslib_1.__generator(this, function(_a) { | |
return [2, (0, util_1.numToUint8)(this.crc32.digest())]; | |
}); | |
}); | |
}; | |
AwsCrc322.prototype.reset = function() { | |
this.crc32 = new index_1.Crc32(); | |
}; | |
return AwsCrc322; | |
}() | |
); | |
exports.AwsCrc32 = AwsCrc32; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-crypto+crc32@3.0.0/node_modules/@aws-crypto/crc32/build/index.js | |
var require_build2 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-crypto+crc32@3.0.0/node_modules/@aws-crypto/crc32/build/index.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.AwsCrc32 = exports.Crc32 = exports.crc32 = void 0; | |
var tslib_1 = (init_tslib_es62(), __toCommonJS(tslib_es6_exports2)); | |
var util_1 = require_build(); | |
function crc32(data) { | |
return new Crc32().update(data).digest(); | |
} | |
exports.crc32 = crc32; | |
var Crc32 = ( | |
/** @class */ | |
function() { | |
function Crc322() { | |
this.checksum = 4294967295; | |
} | |
Crc322.prototype.update = function(data) { | |
var e_1, _a; | |
try { | |
for (var data_1 = tslib_1.__values(data), data_1_1 = data_1.next(); !data_1_1.done; data_1_1 = data_1.next()) { | |
var byte = data_1_1.value; | |
this.checksum = this.checksum >>> 8 ^ lookupTable[(this.checksum ^ byte) & 255]; | |
} | |
} catch (e_1_1) { | |
e_1 = { error: e_1_1 }; | |
} finally { | |
try { | |
if (data_1_1 && !data_1_1.done && (_a = data_1.return)) | |
_a.call(data_1); | |
} finally { | |
if (e_1) | |
throw e_1.error; | |
} | |
} | |
return this; | |
}; | |
Crc322.prototype.digest = function() { | |
return (this.checksum ^ 4294967295) >>> 0; | |
}; | |
return Crc322; | |
}() | |
); | |
exports.Crc32 = Crc32; | |
var a_lookUpTable = [ | |
0, | |
1996959894, | |
3993919788, | |
2567524794, | |
124634137, | |
1886057615, | |
3915621685, | |
2657392035, | |
249268274, | |
2044508324, | |
3772115230, | |
2547177864, | |
162941995, | |
2125561021, | |
3887607047, | |
2428444049, | |
498536548, | |
1789927666, | |
4089016648, | |
2227061214, | |
450548861, | |
1843258603, | |
4107580753, | |
2211677639, | |
325883990, | |
1684777152, | |
4251122042, | |
2321926636, | |
335633487, | |
1661365465, | |
4195302755, | |
2366115317, | |
997073096, | |
1281953886, | |
3579855332, | |
2724688242, | |
1006888145, | |
1258607687, | |
3524101629, | |
2768942443, | |
901097722, | |
1119000684, | |
3686517206, | |
2898065728, | |
853044451, | |
1172266101, | |
3705015759, | |
2882616665, | |
651767980, | |
1373503546, | |
3369554304, | |
3218104598, | |
565507253, | |
1454621731, | |
3485111705, | |
3099436303, | |
671266974, | |
1594198024, | |
3322730930, | |
2970347812, | |
795835527, | |
1483230225, | |
3244367275, | |
3060149565, | |
1994146192, | |
31158534, | |
2563907772, | |
4023717930, | |
1907459465, | |
112637215, | |
2680153253, | |
3904427059, | |
2013776290, | |
251722036, | |
2517215374, | |
3775830040, | |
2137656763, | |
141376813, | |
2439277719, | |
3865271297, | |
1802195444, | |
476864866, | |
2238001368, | |
4066508878, | |
1812370925, | |
453092731, | |
2181625025, | |
4111451223, | |
1706088902, | |
314042704, | |
2344532202, | |
4240017532, | |
1658658271, | |
366619977, | |
2362670323, | |
4224994405, | |
1303535960, | |
984961486, | |
2747007092, | |
3569037538, | |
1256170817, | |
1037604311, | |
2765210733, | |
3554079995, | |
1131014506, | |
879679996, | |
2909243462, | |
3663771856, | |
1141124467, | |
855842277, | |
2852801631, | |
3708648649, | |
1342533948, | |
654459306, | |
3188396048, | |
3373015174, | |
1466479909, | |
544179635, | |
3110523913, | |
3462522015, | |
1591671054, | |
702138776, | |
2966460450, | |
3352799412, | |
1504918807, | |
783551873, | |
3082640443, | |
3233442989, | |
3988292384, | |
2596254646, | |
62317068, | |
1957810842, | |
3939845945, | |
2647816111, | |
81470997, | |
1943803523, | |
3814918930, | |
2489596804, | |
225274430, | |
2053790376, | |
3826175755, | |
2466906013, | |
167816743, | |
2097651377, | |
4027552580, | |
2265490386, | |
503444072, | |
1762050814, | |
4150417245, | |
2154129355, | |
426522225, | |
1852507879, | |
4275313526, | |
2312317920, | |
282753626, | |
1742555852, | |
4189708143, | |
2394877945, | |
397917763, | |
1622183637, | |
3604390888, | |
2714866558, | |
953729732, | |
1340076626, | |
3518719985, | |
2797360999, | |
1068828381, | |
1219638859, | |
3624741850, | |
2936675148, | |
906185462, | |
1090812512, | |
3747672003, | |
2825379669, | |
829329135, | |
1181335161, | |
3412177804, | |
3160834842, | |
628085408, | |
1382605366, | |
3423369109, | |
3138078467, | |
570562233, | |
1426400815, | |
3317316542, | |
2998733608, | |
733239954, | |
1555261956, | |
3268935591, | |
3050360625, | |
752459403, | |
1541320221, | |
2607071920, | |
3965973030, | |
1969922972, | |
40735498, | |
2617837225, | |
3943577151, | |
1913087877, | |
83908371, | |
2512341634, | |
3803740692, | |
2075208622, | |
213261112, | |
2463272603, | |
3855990285, | |
2094854071, | |
198958881, | |
2262029012, | |
4057260610, | |
1759359992, | |
534414190, | |
2176718541, | |
4139329115, | |
1873836001, | |
414664567, | |
2282248934, | |
4279200368, | |
1711684554, | |
285281116, | |
2405801727, | |
4167216745, | |
1634467795, | |
376229701, | |
2685067896, | |
3608007406, | |
1308918612, | |
956543938, | |
2808555105, | |
3495958263, | |
1231636301, | |
1047427035, | |
2932959818, | |
3654703836, | |
1088359270, | |
936918e3, | |
2847714899, | |
3736837829, | |
1202900863, | |
817233897, | |
3183342108, | |
3401237130, | |
1404277552, | |
615818150, | |
3134207493, | |
3453421203, | |
1423857449, | |
601450431, | |
3009837614, | |
3294710456, | |
1567103746, | |
711928724, | |
3020668471, | |
3272380065, | |
1510334235, | |
755167117 | |
]; | |
var lookupTable = (0, util_1.uint32ArrayFrom)(a_lookUpTable); | |
var aws_crc32_1 = require_aws_crc32(); | |
Object.defineProperty(exports, "AwsCrc32", { enumerable: true, get: function() { | |
return aws_crc32_1.AwsCrc32; | |
} }); | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-crypto+crc32c@3.0.0/node_modules/@aws-crypto/crc32c/build/aws_crc32c.js | |
var require_aws_crc32c = __commonJS({ | |
"../../node_modules/.pnpm/@aws-crypto+crc32c@3.0.0/node_modules/@aws-crypto/crc32c/build/aws_crc32c.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.AwsCrc32c = void 0; | |
var tslib_1 = (init_tslib_es62(), __toCommonJS(tslib_es6_exports2)); | |
var util_1 = require_build(); | |
var index_1 = require_build3(); | |
var AwsCrc32c = ( | |
/** @class */ | |
function() { | |
function AwsCrc32c2() { | |
this.crc32c = new index_1.Crc32c(); | |
} | |
AwsCrc32c2.prototype.update = function(toHash) { | |
if ((0, util_1.isEmptyData)(toHash)) | |
return; | |
this.crc32c.update((0, util_1.convertToBuffer)(toHash)); | |
}; | |
AwsCrc32c2.prototype.digest = function() { | |
return tslib_1.__awaiter(this, void 0, void 0, function() { | |
return tslib_1.__generator(this, function(_a) { | |
return [2, (0, util_1.numToUint8)(this.crc32c.digest())]; | |
}); | |
}); | |
}; | |
AwsCrc32c2.prototype.reset = function() { | |
this.crc32c = new index_1.Crc32c(); | |
}; | |
return AwsCrc32c2; | |
}() | |
); | |
exports.AwsCrc32c = AwsCrc32c; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-crypto+crc32c@3.0.0/node_modules/@aws-crypto/crc32c/build/index.js | |
var require_build3 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-crypto+crc32c@3.0.0/node_modules/@aws-crypto/crc32c/build/index.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.AwsCrc32c = exports.Crc32c = exports.crc32c = void 0; | |
var tslib_1 = (init_tslib_es62(), __toCommonJS(tslib_es6_exports2)); | |
var util_1 = require_build(); | |
function crc32c(data) { | |
return new Crc32c().update(data).digest(); | |
} | |
exports.crc32c = crc32c; | |
var Crc32c = ( | |
/** @class */ | |
function() { | |
function Crc32c2() { | |
this.checksum = 4294967295; | |
} | |
Crc32c2.prototype.update = function(data) { | |
var e_1, _a; | |
try { | |
for (var data_1 = tslib_1.__values(data), data_1_1 = data_1.next(); !data_1_1.done; data_1_1 = data_1.next()) { | |
var byte = data_1_1.value; | |
this.checksum = this.checksum >>> 8 ^ lookupTable[(this.checksum ^ byte) & 255]; | |
} | |
} catch (e_1_1) { | |
e_1 = { error: e_1_1 }; | |
} finally { | |
try { | |
if (data_1_1 && !data_1_1.done && (_a = data_1.return)) | |
_a.call(data_1); | |
} finally { | |
if (e_1) | |
throw e_1.error; | |
} | |
} | |
return this; | |
}; | |
Crc32c2.prototype.digest = function() { | |
return (this.checksum ^ 4294967295) >>> 0; | |
}; | |
return Crc32c2; | |
}() | |
); | |
exports.Crc32c = Crc32c; | |
var a_lookupTable = [ | |
0, | |
4067132163, | |
3778769143, | |
324072436, | |
3348797215, | |
904991772, | |
648144872, | |
3570033899, | |
2329499855, | |
2024987596, | |
1809983544, | |
2575936315, | |
1296289744, | |
3207089363, | |
2893594407, | |
1578318884, | |
274646895, | |
3795141740, | |
4049975192, | |
51262619, | |
3619967088, | |
632279923, | |
922689671, | |
3298075524, | |
2592579488, | |
1760304291, | |
2075979607, | |
2312596564, | |
1562183871, | |
2943781820, | |
3156637768, | |
1313733451, | |
549293790, | |
3537243613, | |
3246849577, | |
871202090, | |
3878099393, | |
357341890, | |
102525238, | |
4101499445, | |
2858735121, | |
1477399826, | |
1264559846, | |
3107202533, | |
1845379342, | |
2677391885, | |
2361733625, | |
2125378298, | |
820201905, | |
3263744690, | |
3520608582, | |
598981189, | |
4151959214, | |
85089709, | |
373468761, | |
3827903834, | |
3124367742, | |
1213305469, | |
1526817161, | |
2842354314, | |
2107672161, | |
2412447074, | |
2627466902, | |
1861252501, | |
1098587580, | |
3004210879, | |
2688576843, | |
1378610760, | |
2262928035, | |
1955203488, | |
1742404180, | |
2511436119, | |
3416409459, | |
969524848, | |
714683780, | |
3639785095, | |
205050476, | |
4266873199, | |
3976438427, | |
526918040, | |
1361435347, | |
2739821008, | |
2954799652, | |
1114974503, | |
2529119692, | |
1691668175, | |
2005155131, | |
2247081528, | |
3690758684, | |
697762079, | |
986182379, | |
3366744552, | |
476452099, | |
3993867776, | |
4250756596, | |
255256311, | |
1640403810, | |
2477592673, | |
2164122517, | |
1922457750, | |
2791048317, | |
1412925310, | |
1197962378, | |
3037525897, | |
3944729517, | |
427051182, | |
170179418, | |
4165941337, | |
746937522, | |
3740196785, | |
3451792453, | |
1070968646, | |
1905808397, | |
2213795598, | |
2426610938, | |
1657317369, | |
3053634322, | |
1147748369, | |
1463399397, | |
2773627110, | |
4215344322, | |
153784257, | |
444234805, | |
3893493558, | |
1021025245, | |
3467647198, | |
3722505002, | |
797665321, | |
2197175160, | |
1889384571, | |
1674398607, | |
2443626636, | |
1164749927, | |
3070701412, | |
2757221520, | |
1446797203, | |
137323447, | |
4198817972, | |
3910406976, | |
461344835, | |
3484808360, | |
1037989803, | |
781091935, | |
3705997148, | |
2460548119, | |
1623424788, | |
1939049696, | |
2180517859, | |
1429367560, | |
2807687179, | |
3020495871, | |
1180866812, | |
410100952, | |
3927582683, | |
4182430767, | |
186734380, | |
3756733383, | |
763408580, | |
1053836080, | |
3434856499, | |
2722870694, | |
1344288421, | |
1131464017, | |
2971354706, | |
1708204729, | |
2545590714, | |
2229949006, | |
1988219213, | |
680717673, | |
3673779818, | |
3383336350, | |
1002577565, | |
4010310262, | |
493091189, | |
238226049, | |
4233660802, | |
2987750089, | |
1082061258, | |
1395524158, | |
2705686845, | |
1972364758, | |
2279892693, | |
2494862625, | |
1725896226, | |
952904198, | |
3399985413, | |
3656866545, | |
731699698, | |
4283874585, | |
222117402, | |
510512622, | |
3959836397, | |
3280807620, | |
837199303, | |
582374963, | |
3504198960, | |
68661723, | |
4135334616, | |
3844915500, | |
390545967, | |
1230274059, | |
3141532936, | |
2825850620, | |
1510247935, | |
2395924756, | |
2091215383, | |
1878366691, | |
2644384480, | |
3553878443, | |
565732008, | |
854102364, | |
3229815391, | |
340358836, | |
3861050807, | |
4117890627, | |
119113024, | |
1493875044, | |
2875275879, | |
3090270611, | |
1247431312, | |
2660249211, | |
1828433272, | |
2141937292, | |
2378227087, | |
3811616794, | |
291187481, | |
34330861, | |
4032846830, | |
615137029, | |
3603020806, | |
3314634738, | |
939183345, | |
1776939221, | |
2609017814, | |
2295496738, | |
2058945313, | |
2926798794, | |
1545135305, | |
1330124605, | |
3173225534, | |
4084100981, | |
17165430, | |
307568514, | |
3762199681, | |
888469610, | |
3332340585, | |
3587147933, | |
665062302, | |
2042050490, | |
2346497209, | |
2559330125, | |
1793573966, | |
3190661285, | |
1279665062, | |
1595330642, | |
2910671697 | |
]; | |
var lookupTable = (0, util_1.uint32ArrayFrom)(a_lookupTable); | |
var aws_crc32c_1 = require_aws_crc32c(); | |
Object.defineProperty(exports, "AwsCrc32c", { enumerable: true, get: function() { | |
return aws_crc32c_1.AwsCrc32c; | |
} }); | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/selectChecksumAlgorithmFunction.js | |
var require_selectChecksumAlgorithmFunction = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/selectChecksumAlgorithmFunction.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.selectChecksumAlgorithmFunction = void 0; | |
var crc32_1 = require_build2(); | |
var crc32c_1 = require_build3(); | |
var constants_1 = require_constants2(); | |
var selectChecksumAlgorithmFunction = (checksumAlgorithm, config) => ({ | |
[constants_1.ChecksumAlgorithm.MD5]: config.md5, | |
[constants_1.ChecksumAlgorithm.CRC32]: crc32_1.AwsCrc32, | |
[constants_1.ChecksumAlgorithm.CRC32C]: crc32c_1.AwsCrc32c, | |
[constants_1.ChecksumAlgorithm.SHA1]: config.sha1, | |
[constants_1.ChecksumAlgorithm.SHA256]: config.sha256 | |
})[checksumAlgorithm]; | |
exports.selectChecksumAlgorithmFunction = selectChecksumAlgorithmFunction; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+util-buffer-from@3.208.0/node_modules/@aws-sdk/util-buffer-from/dist-cjs/index.js | |
var require_dist_cjs16 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+util-buffer-from@3.208.0/node_modules/@aws-sdk/util-buffer-from/dist-cjs/index.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.fromString = exports.fromArrayBuffer = void 0; | |
var is_array_buffer_1 = require_dist_cjs14(); | |
var buffer_1 = require("buffer"); | |
var fromArrayBuffer = (input, offset = 0, length = input.byteLength - offset) => { | |
if (!(0, is_array_buffer_1.isArrayBuffer)(input)) { | |
throw new TypeError(`The "input" argument must be ArrayBuffer. Received type ${typeof input} (${input})`); | |
} | |
return buffer_1.Buffer.from(input, offset, length); | |
}; | |
exports.fromArrayBuffer = fromArrayBuffer; | |
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_1.Buffer.from(input, encoding) : buffer_1.Buffer.from(input); | |
}; | |
exports.fromString = fromString; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+util-utf8@3.254.0/node_modules/@aws-sdk/util-utf8/dist-cjs/fromUtf8.js | |
var require_fromUtf8 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+util-utf8@3.254.0/node_modules/@aws-sdk/util-utf8/dist-cjs/fromUtf8.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.fromUtf8 = void 0; | |
var util_buffer_from_1 = require_dist_cjs16(); | |
var fromUtf8 = (input) => { | |
const buf = (0, util_buffer_from_1.fromString)(input, "utf8"); | |
return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength / Uint8Array.BYTES_PER_ELEMENT); | |
}; | |
exports.fromUtf8 = fromUtf8; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+util-utf8@3.254.0/node_modules/@aws-sdk/util-utf8/dist-cjs/toUint8Array.js | |
var require_toUint8Array = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+util-utf8@3.254.0/node_modules/@aws-sdk/util-utf8/dist-cjs/toUint8Array.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.toUint8Array = void 0; | |
var fromUtf8_1 = require_fromUtf8(); | |
var toUint8Array = (data) => { | |
if (typeof data === "string") { | |
return (0, fromUtf8_1.fromUtf8)(data); | |
} | |
if (ArrayBuffer.isView(data)) { | |
return new Uint8Array(data.buffer, data.byteOffset, data.byteLength / Uint8Array.BYTES_PER_ELEMENT); | |
} | |
return new Uint8Array(data); | |
}; | |
exports.toUint8Array = toUint8Array; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+util-utf8@3.254.0/node_modules/@aws-sdk/util-utf8/dist-cjs/toUtf8.js | |
var require_toUtf8 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+util-utf8@3.254.0/node_modules/@aws-sdk/util-utf8/dist-cjs/toUtf8.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.toUtf8 = void 0; | |
var util_buffer_from_1 = require_dist_cjs16(); | |
var toUtf8 = (input) => (0, util_buffer_from_1.fromArrayBuffer)(input.buffer, input.byteOffset, input.byteLength).toString("utf8"); | |
exports.toUtf8 = toUtf8; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+util-utf8@3.254.0/node_modules/@aws-sdk/util-utf8/dist-cjs/index.js | |
var require_dist_cjs17 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+util-utf8@3.254.0/node_modules/@aws-sdk/util-utf8/dist-cjs/index.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); | |
tslib_1.__exportStar(require_fromUtf8(), exports); | |
tslib_1.__exportStar(require_toUint8Array(), exports); | |
tslib_1.__exportStar(require_toUtf8(), exports); | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/stringHasher.js | |
var require_stringHasher = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/stringHasher.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.stringHasher = void 0; | |
var util_utf8_1 = require_dist_cjs17(); | |
var stringHasher = (checksumAlgorithmFn, body) => { | |
const hash = new checksumAlgorithmFn(); | |
hash.update((0, util_utf8_1.toUint8Array)(body || "")); | |
return hash.digest(); | |
}; | |
exports.stringHasher = stringHasher; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/getChecksum.js | |
var require_getChecksum = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/getChecksum.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.getChecksum = void 0; | |
var isStreaming_1 = require_isStreaming(); | |
var stringHasher_1 = require_stringHasher(); | |
var getChecksum = async (body, { streamHasher, checksumAlgorithmFn, base64Encoder }) => { | |
const digest = (0, isStreaming_1.isStreaming)(body) ? streamHasher(checksumAlgorithmFn, body) : (0, stringHasher_1.stringHasher)(checksumAlgorithmFn, body); | |
return base64Encoder(await digest); | |
}; | |
exports.getChecksum = getChecksum; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/getChecksumAlgorithmListForResponse.js | |
var require_getChecksumAlgorithmListForResponse = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/getChecksumAlgorithmListForResponse.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.getChecksumAlgorithmListForResponse = void 0; | |
var types_1 = require_types2(); | |
var getChecksumAlgorithmListForResponse = (responseAlgorithms = []) => { | |
const validChecksumAlgorithms = []; | |
for (const algorithm of types_1.PRIORITY_ORDER_ALGORITHMS) { | |
if (!responseAlgorithms.includes(algorithm) || !types_1.CLIENT_SUPPORTED_ALGORITHMS.includes(algorithm)) { | |
continue; | |
} | |
validChecksumAlgorithms.push(algorithm); | |
} | |
return validChecksumAlgorithms; | |
}; | |
exports.getChecksumAlgorithmListForResponse = getChecksumAlgorithmListForResponse; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/validateChecksumFromResponse.js | |
var require_validateChecksumFromResponse = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/validateChecksumFromResponse.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.validateChecksumFromResponse = void 0; | |
var getChecksum_1 = require_getChecksum(); | |
var getChecksumAlgorithmListForResponse_1 = require_getChecksumAlgorithmListForResponse(); | |
var getChecksumLocationName_1 = require_getChecksumLocationName(); | |
var selectChecksumAlgorithmFunction_1 = require_selectChecksumAlgorithmFunction(); | |
var validateChecksumFromResponse = async (response, { config, responseAlgorithms }) => { | |
const checksumAlgorithms = (0, getChecksumAlgorithmListForResponse_1.getChecksumAlgorithmListForResponse)(responseAlgorithms); | |
const { body: responseBody, headers: responseHeaders } = response; | |
for (const algorithm of checksumAlgorithms) { | |
const responseHeader = (0, getChecksumLocationName_1.getChecksumLocationName)(algorithm); | |
const checksumFromResponse = responseHeaders[responseHeader]; | |
if (checksumFromResponse) { | |
const checksumAlgorithmFn = (0, selectChecksumAlgorithmFunction_1.selectChecksumAlgorithmFunction)(algorithm, config); | |
const { streamHasher, base64Encoder } = config; | |
const checksum = await (0, getChecksum_1.getChecksum)(responseBody, { streamHasher, checksumAlgorithmFn, base64Encoder }); | |
if (checksum === checksumFromResponse) { | |
break; | |
} | |
throw new Error(`Checksum mismatch: expected "${checksum}" but received "${checksumFromResponse}" in response header "${responseHeader}".`); | |
} | |
} | |
}; | |
exports.validateChecksumFromResponse = validateChecksumFromResponse; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/flexibleChecksumsMiddleware.js | |
var require_flexibleChecksumsMiddleware = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/flexibleChecksumsMiddleware.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.flexibleChecksumsMiddleware = void 0; | |
var protocol_http_1 = require_dist_cjs8(); | |
var getChecksumAlgorithmForRequest_1 = require_getChecksumAlgorithmForRequest(); | |
var getChecksumLocationName_1 = require_getChecksumLocationName(); | |
var hasHeader_1 = require_hasHeader(); | |
var isStreaming_1 = require_isStreaming(); | |
var selectChecksumAlgorithmFunction_1 = require_selectChecksumAlgorithmFunction(); | |
var stringHasher_1 = require_stringHasher(); | |
var validateChecksumFromResponse_1 = require_validateChecksumFromResponse(); | |
var flexibleChecksumsMiddleware = (config, middlewareConfig) => (next) => async (args) => { | |
if (!protocol_http_1.HttpRequest.isInstance(args.request)) { | |
return next(args); | |
} | |
const { request } = args; | |
const { body: requestBody, headers } = request; | |
const { base64Encoder, streamHasher } = config; | |
const { input, requestChecksumRequired, requestAlgorithmMember } = middlewareConfig; | |
const checksumAlgorithm = (0, getChecksumAlgorithmForRequest_1.getChecksumAlgorithmForRequest)(input, { | |
requestChecksumRequired, | |
requestAlgorithmMember | |
}); | |
let updatedBody = requestBody; | |
let updatedHeaders = headers; | |
if (checksumAlgorithm) { | |
const checksumLocationName = (0, getChecksumLocationName_1.getChecksumLocationName)(checksumAlgorithm); | |
const checksumAlgorithmFn = (0, selectChecksumAlgorithmFunction_1.selectChecksumAlgorithmFunction)(checksumAlgorithm, config); | |
if ((0, isStreaming_1.isStreaming)(requestBody)) { | |
const { getAwsChunkedEncodingStream, bodyLengthChecker } = config; | |
updatedBody = getAwsChunkedEncodingStream(requestBody, { | |
base64Encoder, | |
bodyLengthChecker, | |
checksumLocationName, | |
checksumAlgorithmFn, | |
streamHasher | |
}); | |
updatedHeaders = { | |
...headers, | |
"content-encoding": headers["content-encoding"] ? `${headers["content-encoding"]},aws-chunked` : "aws-chunked", | |
"transfer-encoding": "chunked", | |
"x-amz-decoded-content-length": headers["content-length"], | |
"x-amz-content-sha256": "STREAMING-UNSIGNED-PAYLOAD-TRAILER", | |
"x-amz-trailer": checksumLocationName | |
}; | |
delete updatedHeaders["content-length"]; | |
} else if (!(0, hasHeader_1.hasHeader)(checksumLocationName, headers)) { | |
const rawChecksum = await (0, stringHasher_1.stringHasher)(checksumAlgorithmFn, requestBody); | |
updatedHeaders = { | |
...headers, | |
[checksumLocationName]: base64Encoder(rawChecksum) | |
}; | |
} | |
} | |
const result = await next({ | |
...args, | |
request: { | |
...request, | |
headers: updatedHeaders, | |
body: updatedBody | |
} | |
}); | |
const { requestValidationModeMember, responseAlgorithms } = middlewareConfig; | |
if (requestValidationModeMember && input[requestValidationModeMember] === "ENABLED") { | |
(0, validateChecksumFromResponse_1.validateChecksumFromResponse)(result.response, { | |
config, | |
responseAlgorithms | |
}); | |
} | |
return result; | |
}; | |
exports.flexibleChecksumsMiddleware = flexibleChecksumsMiddleware; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/getFlexibleChecksumsPlugin.js | |
var require_getFlexibleChecksumsPlugin = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/getFlexibleChecksumsPlugin.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.getFlexibleChecksumsPlugin = exports.flexibleChecksumsMiddlewareOptions = void 0; | |
var flexibleChecksumsMiddleware_1 = require_flexibleChecksumsMiddleware(); | |
exports.flexibleChecksumsMiddlewareOptions = { | |
name: "flexibleChecksumsMiddleware", | |
step: "build", | |
tags: ["BODY_CHECKSUM"], | |
override: true | |
}; | |
var getFlexibleChecksumsPlugin = (config, middlewareConfig) => ({ | |
applyToStack: (clientStack) => { | |
clientStack.add((0, flexibleChecksumsMiddleware_1.flexibleChecksumsMiddleware)(config, middlewareConfig), exports.flexibleChecksumsMiddlewareOptions); | |
} | |
}); | |
exports.getFlexibleChecksumsPlugin = getFlexibleChecksumsPlugin; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/index.js | |
var require_dist_cjs18 = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+middleware-flexible-checksums@3.272.0/node_modules/@aws-sdk/middleware-flexible-checksums/dist-cjs/index.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
var tslib_1 = (init_tslib_es6(), __toCommonJS(tslib_es6_exports)); | |
tslib_1.__exportStar(require_constants2(), exports); | |
tslib_1.__exportStar(require_flexibleChecksumsMiddleware(), exports); | |
tslib_1.__exportStar(require_getFlexibleChecksumsPlugin(), exports); | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteObjectsCommand.js | |
var require_DeleteObjectsCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteObjectsCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.DeleteObjectsCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_flexible_checksums_1 = require_dist_cjs18(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var DeleteObjectsCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteObjectsCommand.getEndpointParameterInstructions())); | |
this.middlewareStack.use((0, middleware_flexible_checksums_1.getFlexibleChecksumsPlugin)(configuration, { | |
input: this.input, | |
requestAlgorithmMember: "ChecksumAlgorithm", | |
requestChecksumRequired: true | |
})); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "DeleteObjectsCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.DeleteObjectsRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.DeleteObjectsOutputFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlDeleteObjectsCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlDeleteObjectsCommand)(output, context); | |
} | |
}; | |
exports.DeleteObjectsCommand = DeleteObjectsCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteObjectTaggingCommand.js | |
var require_DeleteObjectTaggingCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeleteObjectTaggingCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.DeleteObjectTaggingCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var DeleteObjectTaggingCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeleteObjectTaggingCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "DeleteObjectTaggingCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.DeleteObjectTaggingRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.DeleteObjectTaggingOutputFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlDeleteObjectTaggingCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlDeleteObjectTaggingCommand)(output, context); | |
} | |
}; | |
exports.DeleteObjectTaggingCommand = DeleteObjectTaggingCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeletePublicAccessBlockCommand.js | |
var require_DeletePublicAccessBlockCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/DeletePublicAccessBlockCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.DeletePublicAccessBlockCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var DeletePublicAccessBlockCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, DeletePublicAccessBlockCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "DeletePublicAccessBlockCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.DeletePublicAccessBlockRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: (output) => output | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlDeletePublicAccessBlockCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlDeletePublicAccessBlockCommand)(output, context); | |
} | |
}; | |
exports.DeletePublicAccessBlockCommand = DeletePublicAccessBlockCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketAccelerateConfigurationCommand.js | |
var require_GetBucketAccelerateConfigurationCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketAccelerateConfigurationCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.GetBucketAccelerateConfigurationCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var GetBucketAccelerateConfigurationCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketAccelerateConfigurationCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "GetBucketAccelerateConfigurationCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.GetBucketAccelerateConfigurationRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.GetBucketAccelerateConfigurationOutputFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlGetBucketAccelerateConfigurationCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketAccelerateConfigurationCommand)(output, context); | |
} | |
}; | |
exports.GetBucketAccelerateConfigurationCommand = GetBucketAccelerateConfigurationCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketAclCommand.js | |
var require_GetBucketAclCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketAclCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.GetBucketAclCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var GetBucketAclCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketAclCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "GetBucketAclCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.GetBucketAclRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.GetBucketAclOutputFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlGetBucketAclCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketAclCommand)(output, context); | |
} | |
}; | |
exports.GetBucketAclCommand = GetBucketAclCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketAnalyticsConfigurationCommand.js | |
var require_GetBucketAnalyticsConfigurationCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketAnalyticsConfigurationCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.GetBucketAnalyticsConfigurationCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var GetBucketAnalyticsConfigurationCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketAnalyticsConfigurationCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "GetBucketAnalyticsConfigurationCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.GetBucketAnalyticsConfigurationRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.GetBucketAnalyticsConfigurationOutputFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlGetBucketAnalyticsConfigurationCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketAnalyticsConfigurationCommand)(output, context); | |
} | |
}; | |
exports.GetBucketAnalyticsConfigurationCommand = GetBucketAnalyticsConfigurationCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketCorsCommand.js | |
var require_GetBucketCorsCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketCorsCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.GetBucketCorsCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var GetBucketCorsCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketCorsCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "GetBucketCorsCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.GetBucketCorsRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.GetBucketCorsOutputFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlGetBucketCorsCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketCorsCommand)(output, context); | |
} | |
}; | |
exports.GetBucketCorsCommand = GetBucketCorsCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketEncryptionCommand.js | |
var require_GetBucketEncryptionCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketEncryptionCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.GetBucketEncryptionCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var GetBucketEncryptionCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketEncryptionCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "GetBucketEncryptionCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.GetBucketEncryptionRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.GetBucketEncryptionOutputFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlGetBucketEncryptionCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketEncryptionCommand)(output, context); | |
} | |
}; | |
exports.GetBucketEncryptionCommand = GetBucketEncryptionCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketIntelligentTieringConfigurationCommand.js | |
var require_GetBucketIntelligentTieringConfigurationCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketIntelligentTieringConfigurationCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.GetBucketIntelligentTieringConfigurationCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var GetBucketIntelligentTieringConfigurationCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketIntelligentTieringConfigurationCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "GetBucketIntelligentTieringConfigurationCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.GetBucketIntelligentTieringConfigurationRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.GetBucketIntelligentTieringConfigurationOutputFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlGetBucketIntelligentTieringConfigurationCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketIntelligentTieringConfigurationCommand)(output, context); | |
} | |
}; | |
exports.GetBucketIntelligentTieringConfigurationCommand = GetBucketIntelligentTieringConfigurationCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketInventoryConfigurationCommand.js | |
var require_GetBucketInventoryConfigurationCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketInventoryConfigurationCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.GetBucketInventoryConfigurationCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var GetBucketInventoryConfigurationCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketInventoryConfigurationCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "GetBucketInventoryConfigurationCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.GetBucketInventoryConfigurationRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.GetBucketInventoryConfigurationOutputFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlGetBucketInventoryConfigurationCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketInventoryConfigurationCommand)(output, context); | |
} | |
}; | |
exports.GetBucketInventoryConfigurationCommand = GetBucketInventoryConfigurationCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketLifecycleConfigurationCommand.js | |
var require_GetBucketLifecycleConfigurationCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketLifecycleConfigurationCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.GetBucketLifecycleConfigurationCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var GetBucketLifecycleConfigurationCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketLifecycleConfigurationCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "GetBucketLifecycleConfigurationCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.GetBucketLifecycleConfigurationRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.GetBucketLifecycleConfigurationOutputFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlGetBucketLifecycleConfigurationCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketLifecycleConfigurationCommand)(output, context); | |
} | |
}; | |
exports.GetBucketLifecycleConfigurationCommand = GetBucketLifecycleConfigurationCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketLocationCommand.js | |
var require_GetBucketLocationCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketLocationCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.GetBucketLocationCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var GetBucketLocationCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketLocationCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "GetBucketLocationCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.GetBucketLocationRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.GetBucketLocationOutputFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlGetBucketLocationCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketLocationCommand)(output, context); | |
} | |
}; | |
exports.GetBucketLocationCommand = GetBucketLocationCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketLoggingCommand.js | |
var require_GetBucketLoggingCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketLoggingCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.GetBucketLoggingCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var GetBucketLoggingCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketLoggingCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "GetBucketLoggingCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.GetBucketLoggingRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.GetBucketLoggingOutputFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlGetBucketLoggingCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketLoggingCommand)(output, context); | |
} | |
}; | |
exports.GetBucketLoggingCommand = GetBucketLoggingCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketMetricsConfigurationCommand.js | |
var require_GetBucketMetricsConfigurationCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketMetricsConfigurationCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.GetBucketMetricsConfigurationCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var GetBucketMetricsConfigurationCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketMetricsConfigurationCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "GetBucketMetricsConfigurationCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.GetBucketMetricsConfigurationRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.GetBucketMetricsConfigurationOutputFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlGetBucketMetricsConfigurationCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketMetricsConfigurationCommand)(output, context); | |
} | |
}; | |
exports.GetBucketMetricsConfigurationCommand = GetBucketMetricsConfigurationCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketNotificationConfigurationCommand.js | |
var require_GetBucketNotificationConfigurationCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketNotificationConfigurationCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.GetBucketNotificationConfigurationCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var GetBucketNotificationConfigurationCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketNotificationConfigurationCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "GetBucketNotificationConfigurationCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.GetBucketNotificationConfigurationRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.NotificationConfigurationFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlGetBucketNotificationConfigurationCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketNotificationConfigurationCommand)(output, context); | |
} | |
}; | |
exports.GetBucketNotificationConfigurationCommand = GetBucketNotificationConfigurationCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketOwnershipControlsCommand.js | |
var require_GetBucketOwnershipControlsCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketOwnershipControlsCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.GetBucketOwnershipControlsCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var GetBucketOwnershipControlsCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketOwnershipControlsCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "GetBucketOwnershipControlsCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.GetBucketOwnershipControlsRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.GetBucketOwnershipControlsOutputFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlGetBucketOwnershipControlsCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketOwnershipControlsCommand)(output, context); | |
} | |
}; | |
exports.GetBucketOwnershipControlsCommand = GetBucketOwnershipControlsCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketPolicyCommand.js | |
var require_GetBucketPolicyCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketPolicyCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.GetBucketPolicyCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var GetBucketPolicyCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketPolicyCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "GetBucketPolicyCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.GetBucketPolicyRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.GetBucketPolicyOutputFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlGetBucketPolicyCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketPolicyCommand)(output, context); | |
} | |
}; | |
exports.GetBucketPolicyCommand = GetBucketPolicyCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketPolicyStatusCommand.js | |
var require_GetBucketPolicyStatusCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketPolicyStatusCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.GetBucketPolicyStatusCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var GetBucketPolicyStatusCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketPolicyStatusCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "GetBucketPolicyStatusCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.GetBucketPolicyStatusRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.GetBucketPolicyStatusOutputFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlGetBucketPolicyStatusCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketPolicyStatusCommand)(output, context); | |
} | |
}; | |
exports.GetBucketPolicyStatusCommand = GetBucketPolicyStatusCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketReplicationCommand.js | |
var require_GetBucketReplicationCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketReplicationCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.GetBucketReplicationCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var GetBucketReplicationCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketReplicationCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "GetBucketReplicationCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.GetBucketReplicationRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.GetBucketReplicationOutputFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlGetBucketReplicationCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketReplicationCommand)(output, context); | |
} | |
}; | |
exports.GetBucketReplicationCommand = GetBucketReplicationCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketRequestPaymentCommand.js | |
var require_GetBucketRequestPaymentCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketRequestPaymentCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.GetBucketRequestPaymentCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var GetBucketRequestPaymentCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketRequestPaymentCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "GetBucketRequestPaymentCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.GetBucketRequestPaymentRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.GetBucketRequestPaymentOutputFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlGetBucketRequestPaymentCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketRequestPaymentCommand)(output, context); | |
} | |
}; | |
exports.GetBucketRequestPaymentCommand = GetBucketRequestPaymentCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketTaggingCommand.js | |
var require_GetBucketTaggingCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketTaggingCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.GetBucketTaggingCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var GetBucketTaggingCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketTaggingCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "GetBucketTaggingCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.GetBucketTaggingRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.GetBucketTaggingOutputFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlGetBucketTaggingCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketTaggingCommand)(output, context); | |
} | |
}; | |
exports.GetBucketTaggingCommand = GetBucketTaggingCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketVersioningCommand.js | |
var require_GetBucketVersioningCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketVersioningCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.GetBucketVersioningCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var GetBucketVersioningCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketVersioningCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "GetBucketVersioningCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.GetBucketVersioningRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.GetBucketVersioningOutputFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlGetBucketVersioningCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketVersioningCommand)(output, context); | |
} | |
}; | |
exports.GetBucketVersioningCommand = GetBucketVersioningCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketWebsiteCommand.js | |
var require_GetBucketWebsiteCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetBucketWebsiteCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.GetBucketWebsiteCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var GetBucketWebsiteCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetBucketWebsiteCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "GetBucketWebsiteCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.GetBucketWebsiteRequestFilterSensitiveLog, | |
outputFilterSensitiveLog: models_0_1.GetBucketWebsiteOutputFilterSensitiveLog | |
}; | |
const { requestHandler } = configuration; | |
return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext); | |
} | |
serialize(input, context) { | |
return (0, Aws_restXml_1.serializeAws_restXmlGetBucketWebsiteCommand)(input, context); | |
} | |
deserialize(output, context) { | |
return (0, Aws_restXml_1.deserializeAws_restXmlGetBucketWebsiteCommand)(output, context); | |
} | |
}; | |
exports.GetBucketWebsiteCommand = GetBucketWebsiteCommand; | |
} | |
}); | |
// ../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetObjectAclCommand.js | |
var require_GetObjectAclCommand = __commonJS({ | |
"../../node_modules/.pnpm/@aws-sdk+client-s3@3.272.0/node_modules/@aws-sdk/client-s3/dist-cjs/commands/GetObjectAclCommand.js"(exports) { | |
"use strict"; | |
Object.defineProperty(exports, "__esModule", { value: true }); | |
exports.GetObjectAclCommand = void 0; | |
var middleware_endpoint_1 = require_dist_cjs5(); | |
var middleware_serde_1 = require_dist_cjs3(); | |
var smithy_client_1 = require_dist_cjs7(); | |
var models_0_1 = require_models_0(); | |
var Aws_restXml_1 = require_Aws_restXml(); | |
var GetObjectAclCommand = class extends smithy_client_1.Command { | |
constructor(input) { | |
super(); | |
this.input = input; | |
} | |
static getEndpointParameterInstructions() { | |
return { | |
Bucket: { type: "contextParams", name: "Bucket" }, | |
ForcePathStyle: { type: "clientContextParams", name: "forcePathStyle" }, | |
UseArnRegion: { type: "clientContextParams", name: "useArnRegion" }, | |
DisableMultiRegionAccessPoints: { type: "clientContextParams", name: "disableMultiregionAccessPoints" }, | |
Accelerate: { type: "clientContextParams", name: "useAccelerateEndpoint" }, | |
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" } | |
}; | |
} | |
resolveMiddleware(clientStack, configuration, options) { | |
this.middlewareStack.use((0, middleware_serde_1.getSerdePlugin)(configuration, this.serialize, this.deserialize)); | |
this.middlewareStack.use((0, middleware_endpoint_1.getEndpointPlugin)(configuration, GetObjectAclCommand.getEndpointParameterInstructions())); | |
const stack = clientStack.concat(this.middlewareStack); | |
const { logger } = configuration; | |
const clientName = "S3Client"; | |
const commandName = "GetObjectAclCommand"; | |
const handlerExecutionContext = { | |
logger, | |
clientName, | |
commandName, | |
inputFilterSensitiveLog: models_0_1.GetObjectAclRequestFilterSensitiveLog, | |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment