plugin-file-preview-auth 1.1.2 → 1.1.4

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

@@ -0,0 +1,83 @@
+import { collectBody } from "@smithy/core/protocols";
+import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
+import { calculateBodyLength } from "@smithy/util-body-length-browser";
+import { cbor } from "./cbor";
+import { tag, tagSymbol } from "./cbor-types";
+export const parseCborBody = (streamBody, context) => {
+    return collectBody(streamBody, context).then(async (bytes) => {
+        if (bytes.length) {
+            try {
+                return cbor.deserialize(bytes);
+            }
+            catch (e) {
+                Object.defineProperty(e, "$responseBodyText", {
+                    value: context.utf8Encoder(bytes),
+                });
+                throw e;
+            }
+        }
+        return {};
+    });
+};
+export const dateToTag = (date) => {
+    return tag({
+        tag: 1,
+        value: date.getTime() / 1000,
+    });
+};
+export const parseCborErrorBody = async (errorBody, context) => {
+    const value = await parseCborBody(errorBody, context);
+    value.message = value.message ?? value.Message;
+    return value;
+};
+export const loadSmithyRpcV2CborErrorCode = (output, data) => {
+    const sanitizeErrorCode = (rawValue) => {
+        let cleanValue = rawValue;
+        if (typeof cleanValue === "number") {
+            cleanValue = cleanValue.toString();
+        }
+        if (cleanValue.indexOf(",") >= 0) {
+            cleanValue = cleanValue.split(",")[0];
+        }
+        if (cleanValue.indexOf(":") >= 0) {
+            cleanValue = cleanValue.split(":")[0];
+        }
+        if (cleanValue.indexOf("#") >= 0) {
+            cleanValue = cleanValue.split("#")[1];
+        }
+        return cleanValue;
+    };
+    if (data["__type"] !== undefined) {
+        return sanitizeErrorCode(data["__type"]);
+    }
+    if (data.code !== undefined) {
+        return sanitizeErrorCode(data.code);
+    }
+};
+export const checkCborResponse = (response) => {
+    if (String(response.headers["smithy-protocol"]).toLowerCase() !== "rpc-v2-cbor") {
+        throw new Error("Malformed RPCv2 CBOR response, status: " + response.statusCode);
+    }
+};
+export const buildHttpRpcRequest = async (context, headers, path, resolvedHostname, body) => {
+    const { hostname, protocol = "https", port, path: basePath } = await context.endpoint();
+    const contents = {
+        protocol,
+        hostname,
+        port,
+        method: "POST",
+        path: basePath.endsWith("/") ? basePath.slice(0, -1) + path : basePath + path,
+        headers,
+    };
+    if (resolvedHostname !== undefined) {
+        contents.hostname = resolvedHostname;
+    }
+    if (body !== undefined) {
+        contents.body = body;
+        try {
+            contents.headers["content-length"] = String(calculateBodyLength(body));
+        }
+        catch (e) { }
+    }
+    return new __HttpRequest(contents);
+};

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

@@ -0,0 +1,11 @@
+import { Uint8ArrayBlobAdapter } from "@smithy/util-stream";
+export const collectBody = async (streamBody = new Uint8Array(), context) => {
+    if (streamBody instanceof Uint8Array) {
+        return Uint8ArrayBlobAdapter.mutate(streamBody);
+    }
+    if (!streamBody) {
+        return Uint8ArrayBlobAdapter.mutate(new Uint8Array());
+    }
+    const fromContext = context.streamCollector(streamBody);
+    return Uint8ArrayBlobAdapter.mutate(await fromContext);
+};

package/dist/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-es/submodules/protocols/extended-encode-uri-component.js

@@ -0,0 +1,5 @@
+export function extendedEncodeURIComponent(str) {
+    return encodeURIComponent(str).replace(/[!'()*]/g, function (c) {
+        return "%" + c.charCodeAt(0).toString(16).toUpperCase();
+    });
+}

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

@@ -0,0 +1,4 @@
+export * from "./collect-stream-body";
+export * from "./extended-encode-uri-component";
+export * from "./requestBuilder";
+export * from "./resolve-path";

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

@@ -0,0 +1,67 @@
+import { HttpRequest } from "@smithy/protocol-http";
+import { resolvedPath } from "./resolve-path";
+export function requestBuilder(input, context) {
+    return new RequestBuilder(input, context);
+}
+export class RequestBuilder {
+    constructor(input, context) {
+        this.input = input;
+        this.context = context;
+        this.query = {};
+        this.method = "";
+        this.headers = {};
+        this.path = "";
+        this.body = null;
+        this.hostname = "";
+        this.resolvePathStack = [];
+    }
+    async build() {
+        const { hostname, protocol = "https", port, path: basePath } = await this.context.endpoint();
+        this.path = basePath;
+        for (const resolvePath of this.resolvePathStack) {
+            resolvePath(this.path);
+        }
+        return new HttpRequest({
+            protocol,
+            hostname: this.hostname || hostname,
+            port,
+            method: this.method,
+            path: this.path,
+            query: this.query,
+            body: this.body,
+            headers: this.headers,
+        });
+    }
+    hn(hostname) {
+        this.hostname = hostname;
+        return this;
+    }
+    bp(uriLabel) {
+        this.resolvePathStack.push((basePath) => {
+            this.path = `${basePath?.endsWith("/") ? basePath.slice(0, -1) : basePath || ""}` + uriLabel;
+        });
+        return this;
+    }
+    p(memberName, labelValueProvider, uriLabel, isGreedyLabel) {
+        this.resolvePathStack.push((path) => {
+            this.path = resolvedPath(path, this.input, memberName, labelValueProvider, uriLabel, isGreedyLabel);
+        });
+        return this;
+    }
+    h(headers) {
+        this.headers = headers;
+        return this;
+    }
+    q(query) {
+        this.query = query;
+        return this;
+    }
+    b(body) {
+        this.body = body;
+        return this;
+    }
+    m(method) {
+        this.method = method;
+        return this;
+    }
+}

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

@@ -0,0 +1,19 @@
+import { extendedEncodeURIComponent } from "./extended-encode-uri-component";
+export const resolvedPath = (resolvedPath, input, memberName, labelValueProvider, uriLabel, isGreedyLabel) => {
+    if (input != null && input[memberName] !== undefined) {
+        const labelValue = labelValueProvider();
+        if (labelValue.length <= 0) {
+            throw new Error("Empty value provided for input HTTP label: " + memberName + ".");
+        }
+        resolvedPath = resolvedPath.replace(uriLabel, isGreedyLabel
+            ? labelValue
+                .split("/")
+                .map((segment) => extendedEncodeURIComponent(segment))
+                .join("/")
+            : extendedEncodeURIComponent(labelValue));
+    }
+    else {
+        throw new Error("No value provided for input HTTP label: " + memberName + ".");
+    }
+    return resolvedPath;
+};

package/dist/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-es/util-identity-and-auth/DefaultIdentityProviderConfig.js

@@ -0,0 +1,13 @@
+export class DefaultIdentityProviderConfig {
+    constructor(config) {
+        this.authSchemes = new Map();
+        for (const [key, value] of Object.entries(config)) {
+            if (value !== undefined) {
+                this.authSchemes.set(key, value);
+            }
+        }
+    }
+    getIdentityProvider(schemeId) {
+        return this.authSchemes.get(schemeId);
+    }
+}

package/dist/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-es/util-identity-and-auth/httpAuthSchemes/httpApiKeyAuth.js

@@ -0,0 +1,34 @@
+import { HttpRequest } from "@smithy/protocol-http";
+import { HttpApiKeyAuthLocation } from "@smithy/types";
+export class HttpApiKeyAuthSigner {
+    async sign(httpRequest, identity, signingProperties) {
+        if (!signingProperties) {
+            throw new Error("request could not be signed with `apiKey` since the `name` and `in` signer properties are missing");
+        }
+        if (!signingProperties.name) {
+            throw new Error("request could not be signed with `apiKey` since the `name` signer property is missing");
+        }
+        if (!signingProperties.in) {
+            throw new Error("request could not be signed with `apiKey` since the `in` signer property is missing");
+        }
+        if (!identity.apiKey) {
+            throw new Error("request could not be signed with `apiKey` since the `apiKey` is not defined");
+        }
+        const clonedRequest = HttpRequest.clone(httpRequest);
+        if (signingProperties.in === HttpApiKeyAuthLocation.QUERY) {
+            clonedRequest.query[signingProperties.name] = identity.apiKey;
+        }
+        else if (signingProperties.in === HttpApiKeyAuthLocation.HEADER) {
+            clonedRequest.headers[signingProperties.name] = signingProperties.scheme
+                ? `${signingProperties.scheme} ${identity.apiKey}`
+                : identity.apiKey;
+        }
+        else {
+            throw new Error("request can only be signed with `apiKey` locations `query` or `header`, " +
+                "but found: `" +
+                signingProperties.in +
+                "`");
+        }
+        return clonedRequest;
+    }
+}

package/dist/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-es/util-identity-and-auth/httpAuthSchemes/httpBearerAuth.js

@@ -0,0 +1,11 @@
+import { HttpRequest } from "@smithy/protocol-http";
+export class HttpBearerAuthSigner {
+    async sign(httpRequest, identity, signingProperties) {
+        const clonedRequest = HttpRequest.clone(httpRequest);
+        if (!identity.token) {
+            throw new Error("request could not be signed with `token` since the `token` is not defined");
+        }
+        clonedRequest.headers["Authorization"] = `Bearer ${identity.token}`;
+        return clonedRequest;
+    }
+}

package/dist/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-es/util-identity-and-auth/httpAuthSchemes/index.js

@@ -0,0 +1,3 @@
+export * from "./httpApiKeyAuth";
+export * from "./httpBearerAuth";
+export * from "./noAuth";

package/dist/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-es/util-identity-and-auth/httpAuthSchemes/noAuth.js

@@ -0,0 +1,5 @@
+export class NoAuthSigner {
+    async sign(httpRequest, identity, signingProperties) {
+        return httpRequest;
+    }
+}

package/dist/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-es/util-identity-and-auth/index.js

@@ -0,0 +1,3 @@
+export * from "./DefaultIdentityProviderConfig";
+export * from "./httpAuthSchemes";
+export * from "./memoizeIdentityProvider";

package/dist/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-es/util-identity-and-auth/memoizeIdentityProvider.js

@@ -0,0 +1,53 @@
+export const createIsIdentityExpiredFunction = (expirationMs) => (identity) => doesIdentityRequireRefresh(identity) && identity.expiration.getTime() - Date.now() < expirationMs;
+export const EXPIRATION_MS = 300000;
+export const isIdentityExpired = createIsIdentityExpiredFunction(EXPIRATION_MS);
+export const doesIdentityRequireRefresh = (identity) => identity.expiration !== undefined;
+export const memoizeIdentityProvider = (provider, isExpired, requiresRefresh) => {
+    if (provider === undefined) {
+        return undefined;
+    }
+    const normalizedProvider = typeof provider !== "function" ? async () => Promise.resolve(provider) : provider;
+    let resolved;
+    let pending;
+    let hasResult;
+    let isConstant = false;
+    const coalesceProvider = async (options) => {
+        if (!pending) {
+            pending = normalizedProvider(options);
+        }
+        try {
+            resolved = await pending;
+            hasResult = true;
+            isConstant = false;
+        }
+        finally {
+            pending = undefined;
+        }
+        return resolved;
+    };
+    if (isExpired === undefined) {
+        return async (options) => {
+            if (!hasResult || options?.forceRefresh) {
+                resolved = await coalesceProvider(options);
+            }
+            return resolved;
+        };
+    }
+    return async (options) => {
+        if (!hasResult || options?.forceRefresh) {
+            resolved = await coalesceProvider(options);
+        }
+        if (isConstant) {
+            return resolved;
+        }
+        if (!requiresRefresh(resolved)) {
+            isConstant = true;
+            return resolved;
+        }
+        if (isExpired(resolved)) {
+            await coalesceProvider(options);
+            return resolved;
+        }
+        return resolved;
+    };
+};

package/dist/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-types/getSmithyContext.d.ts

@@ -0,0 +1,5 @@
+import { HandlerExecutionContext } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare const getSmithyContext: (context: HandlerExecutionContext) => Record<string, unknown>;

package/dist/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-types/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./getSmithyContext";
+export * from "./middleware-http-auth-scheme";
+export * from "./middleware-http-signing";
+export * from "./normalizeProvider";
+export { createPaginator } from "./pagination/createPaginator";
+export * from "./protocols/requestBuilder";
+export * from "./setFeature";
+export * from "./util-identity-and-auth";

package/dist/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-types/middleware-http-auth-scheme/getHttpAuthSchemeEndpointRuleSetPlugin.d.ts

@@ -0,0 +1,18 @@
+import { HandlerExecutionContext, HttpAuthSchemeParameters, HttpAuthSchemeParametersProvider, IdentityProviderConfig, Pluggable, RelativeMiddlewareOptions, SerializeHandlerOptions } from "@smithy/types";
+import { PreviouslyResolved } from "./httpAuthSchemeMiddleware";
+/**
+ * @internal
+ */
+export declare const httpAuthSchemeEndpointRuleSetMiddlewareOptions: SerializeHandlerOptions & RelativeMiddlewareOptions;
+/**
+ * @internal
+ */
+interface HttpAuthSchemeEndpointRuleSetPluginOptions<TConfig extends object, TContext extends HandlerExecutionContext, TParameters extends HttpAuthSchemeParameters, TInput extends object> {
+    httpAuthSchemeParametersProvider: HttpAuthSchemeParametersProvider<TConfig, TContext, TParameters, TInput>;
+    identityProviderConfigProvider: (config: TConfig) => Promise<IdentityProviderConfig>;
+}
+/**
+ * @internal
+ */
+export declare const getHttpAuthSchemeEndpointRuleSetPlugin: <TConfig extends object, TContext extends HandlerExecutionContext, TParameters extends HttpAuthSchemeParameters, TInput extends object>(config: TConfig & PreviouslyResolved<TParameters>, { httpAuthSchemeParametersProvider, identityProviderConfigProvider, }: HttpAuthSchemeEndpointRuleSetPluginOptions<TConfig, TContext, TParameters, TInput>) => Pluggable<any, any>;
+export {};

package/dist/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-types/middleware-http-auth-scheme/getHttpAuthSchemePlugin.d.ts

@@ -0,0 +1,18 @@
+import { HandlerExecutionContext, HttpAuthSchemeParameters, HttpAuthSchemeParametersProvider, IdentityProviderConfig, Pluggable, RelativeMiddlewareOptions, SerializeHandlerOptions } from "@smithy/types";
+import { PreviouslyResolved } from "./httpAuthSchemeMiddleware";
+/**
+ * @internal
+ */
+export declare const httpAuthSchemeMiddlewareOptions: SerializeHandlerOptions & RelativeMiddlewareOptions;
+/**
+ * @internal
+ */
+interface HttpAuthSchemePluginOptions<TConfig extends object, TContext extends HandlerExecutionContext, TParameters extends HttpAuthSchemeParameters, TInput extends object> {
+    httpAuthSchemeParametersProvider: HttpAuthSchemeParametersProvider<TConfig, TContext, TParameters, TInput>;
+    identityProviderConfigProvider: (config: TConfig) => Promise<IdentityProviderConfig>;
+}
+/**
+ * @internal
+ */
+export declare const getHttpAuthSchemePlugin: <TConfig extends object, TContext extends HandlerExecutionContext, TParameters extends HttpAuthSchemeParameters, TInput extends object>(config: TConfig & PreviouslyResolved<TParameters>, { httpAuthSchemeParametersProvider, identityProviderConfigProvider, }: HttpAuthSchemePluginOptions<TConfig, TContext, TParameters, TInput>) => Pluggable<any, any>;
+export {};

package/dist/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-types/middleware-http-auth-scheme/httpAuthSchemeMiddleware.d.ts

@@ -0,0 +1,32 @@
+import { HandlerExecutionContext, HttpAuthScheme, HttpAuthSchemeParameters, HttpAuthSchemeParametersProvider, HttpAuthSchemeProvider, IdentityProviderConfig, SelectedHttpAuthScheme, SerializeMiddleware, SMITHY_CONTEXT_KEY } from "@smithy/types";
+/**
+ * @internal
+ */
+export interface PreviouslyResolved<TParameters extends HttpAuthSchemeParameters> {
+    httpAuthSchemes: HttpAuthScheme[];
+    httpAuthSchemeProvider: HttpAuthSchemeProvider<TParameters>;
+}
+/**
+ * @internal
+ */
+interface HttpAuthSchemeMiddlewareOptions<TConfig extends object, TContext extends HandlerExecutionContext, TParameters extends HttpAuthSchemeParameters, TInput extends object> {
+    httpAuthSchemeParametersProvider: HttpAuthSchemeParametersProvider<TConfig, TContext, TParameters, TInput>;
+    identityProviderConfigProvider: (config: TConfig) => Promise<IdentityProviderConfig>;
+}
+/**
+ * @internal
+ */
+interface HttpAuthSchemeMiddlewareSmithyContext extends Record<string, unknown> {
+    selectedHttpAuthScheme?: SelectedHttpAuthScheme;
+}
+/**
+ * @internal
+ */
+interface HttpAuthSchemeMiddlewareHandlerExecutionContext extends HandlerExecutionContext {
+    [SMITHY_CONTEXT_KEY]?: HttpAuthSchemeMiddlewareSmithyContext;
+}
+/**
+ * @internal
+ */
+export declare const httpAuthSchemeMiddleware: <TInput extends object, Output extends object, TConfig extends object, TContext extends HttpAuthSchemeMiddlewareHandlerExecutionContext, TParameters extends HttpAuthSchemeParameters>(config: TConfig & PreviouslyResolved<TParameters>, mwOptions: HttpAuthSchemeMiddlewareOptions<TConfig, TContext, TParameters, TInput>) => SerializeMiddleware<TInput, Output>;
+export {};

package/dist/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-types/middleware-http-auth-scheme/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./httpAuthSchemeMiddleware";
+export * from "./getHttpAuthSchemeEndpointRuleSetPlugin";
+export * from "./getHttpAuthSchemePlugin";

package/dist/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-types/middleware-http-signing/getHttpSigningMiddleware.d.ts

@@ -0,0 +1,9 @@
+import { FinalizeRequestHandlerOptions, Pluggable, RelativeMiddlewareOptions } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare const httpSigningMiddlewareOptions: FinalizeRequestHandlerOptions & RelativeMiddlewareOptions;
+/**
+ * @internal
+ */
+export declare const getHttpSigningPlugin: <Input extends object, Output extends object>(config: object) => Pluggable<Input, Output>;

package/dist/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-types/middleware-http-signing/httpSigningMiddleware.d.ts

@@ -0,0 +1,5 @@
+import { FinalizeRequestMiddleware } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare const httpSigningMiddleware: <Input extends object, Output extends object>(config: object) => FinalizeRequestMiddleware<Input, Output>;

package/dist/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-types/middleware-http-signing/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./httpSigningMiddleware";
+export * from "./getHttpSigningMiddleware";

package/dist/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-types/normalizeProvider.d.ts

@@ -0,0 +1,7 @@
+import { Provider } from "@smithy/types";
+/**
+ * @internal
+ *
+ * @returns a provider function for the input value if it isn't already one.
+ */
+export declare const normalizeProvider: <T>(input: T | Provider<T>) => Provider<T>;

package/dist/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-types/pagination/createPaginator.d.ts

@@ -0,0 +1,7 @@
+import type { PaginationConfiguration, Paginator } from "@smithy/types";
+/**
+ * @internal
+ *
+ * Creates a paginator.
+ */
+export declare function createPaginator<PaginationConfigType extends PaginationConfiguration, InputType extends object, OutputType extends object>(ClientCtor: any, CommandCtor: any, inputTokenName: string, outputTokenName: string, pageSizeTokenName?: string): (config: PaginationConfigType, input: InputType, ...additionalArguments: any[]) => Paginator<OutputType>;

package/dist/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-types/protocols/requestBuilder.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @internal
+ * Backwards compatibility re-export.
+ */
+export { requestBuilder } from "@smithy/core/protocols";

package/dist/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-types/setFeature.d.ts

@@ -0,0 +1,12 @@
+import type { HandlerExecutionContext, SmithyFeatures } from "@smithy/types";
+/**
+ * @internal
+ * Indicates to the request context that a given feature is active.
+ *
+ * @param context - handler execution context.
+ * @param feature - readable name of feature.
+ * @param value - encoding value of feature. This is required because the
+ * specification asks the library not to include a runtime lookup of all
+ * the feature identifiers.
+ */
+export declare function setFeature<F extends keyof SmithyFeatures>(context: HandlerExecutionContext, feature: F, value: SmithyFeatures[F]): void;

package/dist/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-types/submodules/cbor/cbor-decode.d.ts

@@ -0,0 +1,17 @@
+import { CborValueType, Float32, Uint8, Uint32 } from "./cbor-types";
+/**
+ * @internal
+ * @param bytes - to be set as the decode source.
+ *
+ * Sets the decode bytearray source and its data view.
+ */
+export declare function setPayload(bytes: Uint8Array): void;
+/**
+ * @internal
+ * Decodes the data between the two indices.
+ */
+export declare function decode(at: Uint32, to: Uint32): CborValueType;
+/**
+ * @internal
+ */
+export declare function bytesToFloat16(a: Uint8, b: Uint8): Float32;

package/dist/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-types/submodules/cbor/cbor-encode.d.ts

@@ -0,0 +1,9 @@
+/**
+ * @internal
+ */
+export declare function toUint8Array(): Uint8Array;
+export declare function resize(size: number): void;
+/**
+ * @param _input - JS data object.
+ */
+export declare function encode(_input: any): void;

package/dist/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-types/submodules/cbor/cbor-types.d.ts

@@ -0,0 +1,64 @@
+/// <reference types="node" />
+/// <reference types="node" />
+export type CborItemType = undefined | boolean | number | bigint | [CborUnstructuredByteStringType, Uint64] | string | CborTagType;
+export type CborTagType = {
+    tag: Uint64 | number;
+    value: CborValueType;
+    [tagSymbol]: true;
+};
+export type CborUnstructuredByteStringType = Uint8Array;
+export type CborListType<T = any> = Array<T>;
+export type CborMapType<T = any> = Record<string, T>;
+export type CborCollectionType<T = any> = CborMapType<T> | CborListType<T>;
+export type CborValueType = CborItemType | CborCollectionType | any;
+export type CborArgumentLength = 1 | 2 | 4 | 8;
+export type CborArgumentLengthOffset = 1 | 2 | 3 | 5 | 9;
+export type CborOffset = number;
+export type Uint8 = number;
+export type Uint32 = number;
+export type Uint64 = bigint;
+export type Float32 = number;
+export type Int64 = bigint;
+export type Float16Binary = number;
+export type Float32Binary = number;
+export type CborMajorType = typeof majorUint64 | typeof majorNegativeInt64 | typeof majorUnstructuredByteString | typeof majorUtf8String | typeof majorList | typeof majorMap | typeof majorTag | typeof majorSpecial;
+export declare const majorUint64 = 0;
+export declare const majorNegativeInt64 = 1;
+export declare const majorUnstructuredByteString = 2;
+export declare const majorUtf8String = 3;
+export declare const majorList = 4;
+export declare const majorMap = 5;
+export declare const majorTag = 6;
+export declare const majorSpecial = 7;
+export declare const specialFalse = 20;
+export declare const specialTrue = 21;
+export declare const specialNull = 22;
+export declare const specialUndefined = 23;
+export declare const extendedOneByte = 24;
+export declare const extendedFloat16 = 25;
+export declare const extendedFloat32 = 26;
+export declare const extendedFloat64 = 27;
+export declare const minorIndefinite = 31;
+export declare function alloc(size: number): Uint8Array | Buffer;
+/**
+ * @public
+ *
+ * The presence of this symbol as an object key indicates it should be considered a tag
+ * for CBOR serialization purposes.
+ *
+ * The object must also have the properties "tag" and "value".
+ */
+export declare const tagSymbol: unique symbol;
+/**
+ * @public
+ * Applies the tag symbol to the object.
+ */
+export declare function tag(data: {
+    tag: number | bigint;
+    value: any;
+    [tagSymbol]?: true;
+}): {
+    tag: number | bigint;
+    value: any;
+    [tagSymbol]: true;
+};

package/dist/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-types/submodules/cbor/cbor.d.ts

@@ -0,0 +1,26 @@
+/**
+ * This implementation is synchronous and only implements the parts of CBOR
+ * specification used by Smithy RPCv2 CBOR protocol.
+ *
+ * This cbor serde implementation is derived from AWS SDK for Go's implementation.
+ * @see https://github.com/aws/smithy-go/tree/main/encoding/cbor
+ *
+ * The cbor-x implementation was also instructional:
+ * @see https://github.com/kriszyp/cbor-x
+ */
+export declare const cbor: {
+    deserialize(payload: Uint8Array): any;
+    serialize(input: any): Uint8Array;
+    /**
+     * @public
+     * @param size - byte length to allocate.
+     *
+     * This may be used to garbage collect the CBOR
+     * shared encoding buffer space,
+     * e.g. resizeEncodingBuffer(0);
+     *
+     * This may also be used to pre-allocate more space for
+     * CBOR encoding, e.g. resizeEncodingBuffer(100_000_000);
+     */
+    resizeEncodingBuffer(size: number): void;
+};

package/dist/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-types/submodules/cbor/index.d.ts

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

package/dist/node_modules/@aws-sdk/client-s3/node_modules/@smithy/core/dist-types/submodules/cbor/parseCborBody.d.ts

@@ -0,0 +1,31 @@
+import { HttpRequest as __HttpRequest } from "@smithy/protocol-http";
+import { HeaderBag as __HeaderBag, HttpResponse, SerdeContext as __SerdeContext, SerdeContext } from "@smithy/types";
+import { tag, tagSymbol } from "./cbor-types";
+/**
+ * @internal
+ */
+export declare const parseCborBody: (streamBody: any, context: SerdeContext) => any;
+/**
+ * @internal
+ */
+export declare const dateToTag: (date: Date) => {
+    tag: number | bigint;
+    value: any;
+    [tagSymbol]: true;
+};
+/**
+ * @internal
+ */
+export declare const parseCborErrorBody: (errorBody: any, context: SerdeContext) => Promise<any>;
+/**
+ * @internal
+ */
+export declare const loadSmithyRpcV2CborErrorCode: (output: HttpResponse, data: any) => string | undefined;
+/**
+ * @internal
+ */
+export declare const checkCborResponse: (response: HttpResponse) => void;
+/**
+ * @internal
+ */
+export declare const buildHttpRpcRequest: (context: __SerdeContext, headers: __HeaderBag, path: string, resolvedHostname: string | undefined, body: any) => Promise<__HttpRequest>;