@mavogel/awscdk-rootmail 0.0.324 → 0.0.325

package/node_modules/@smithy/types/dist-types/ts3.4/schema/schema.d.ts

@@ -7,9 +7,9 @@ import { StaticSchema } from "./static-schemas";
 import { TraitBitVector } from "./traits";
 /**
  * A schema is an object or value that describes how to serialize/deserialize data.
- * @public
+ * @alpha
  */
-export type Schema = UnitSchema | TraitsSchema | SimpleSchema | ListSchema | MapSchema | StructureSchema | MemberSchema | OperationSchema | StaticSchema | NormalizedSchema;
+export type $Schema = UnitSchema | SimpleSchema | $MemberSchema | StaticSchema | NormalizedSchema;
 /**
  * Traits attached to schema objects.
  *
@@ -20,16 +20,6 @@ export type Schema = UnitSchema | TraitsSchema | SimpleSchema | ListSchema | Map
  * @public
  */
 export type SchemaTraits = TraitBitVector | SchemaTraitsObject;
-/**
- * A schema that has traits.
- *
- * @public
- */
-export interface TraitsSchema {
-    namespace: string;
-    name: string;
-    traits: SchemaTraits;
-}
 /**
  * Simple schemas are those corresponding to simple Smithy types.
  * @see https://smithy.io/2.0/spec/simple-types.html
@@ -52,7 +42,7 @@ export type BlobSchemas = BlobSchema | StreamingBlobSchema;
  * Signal value for the Smithy void value. Typically used for
  * operation input and outputs.
  *
- * @internal
+ * @alpha
  */
 export type UnitSchema = "unit";
 /**
@@ -111,66 +101,31 @@ export type SchemaTraitsObject = {
     [traitName: string]: unknown;
 };
 /**
- * Schema for the structure aggregate type.
- * @public
- */
-export interface StructureSchema extends TraitsSchema {
-    name: string;
-    traits: SchemaTraits;
-    memberNames: string[];
-    memberList: SchemaRef[];
-    /**
-     * @deprecated structure member iteration will be linear on the memberNames and memberList arrays.
-     * It can be collected into a hashmap form on an ad-hoc basis, but will not initialize as such.
-     */
-    members?: Record<string, [
-        SchemaRef,
-        SchemaTraits
-    ]> | undefined;
-}
-/**
- * Schema for the list aggregate type.
- * @public
+ * Indicates the schema is a member of a parent Structure schema.
+ * It may also have a set of member traits distinct from its target shape's traits.
+ * @alpha
  */
-export interface ListSchema extends TraitsSchema {
-    name: string;
-    traits: SchemaTraits;
-    valueSchema: SchemaRef;
-}
-/**
- * Schema for the map aggregate type.
- * @public
- */
-export interface MapSchema extends TraitsSchema {
-    name: string;
-    traits: SchemaTraits;
-    keySchema: SchemaRef;
-    valueSchema: SchemaRef;
-}
-/**
- * @public
- */
-export type MemberSchema = [
-    SchemaRef,
+export type $MemberSchema = [
+    $SchemaRef,
     SchemaTraits
 ];
 /**
  * Schema for an operation.
- *
- * @public
+ * @alpha
  */
-export interface OperationSchema extends TraitsSchema {
+export interface $OperationSchema {
+    namespace: string;
     name: string;
     traits: SchemaTraits;
-    input: SchemaRef;
-    output: SchemaRef;
+    input: $SchemaRef;
+    output: $SchemaRef;
 }
 /**
  * Normalization wrapper for various schema data objects.
  * @public
  */
 export interface NormalizedSchema {
-    getSchema(): Schema;
+    getSchema(): $Schema;
     getName(): string | undefined;
     isMemberSchema(): boolean;
     isListSchema(): boolean;
@@ -204,17 +159,17 @@ export interface NormalizedSchema {
  * A schema "reference" is either a schema or a function that
  * provides a schema. This is useful for lazy loading, and to allow
  * code generation to define schema out of dependency order.
- * @public
+ * @alpha
  */
-export type SchemaRef = Schema | (() => Schema);
+export type $SchemaRef = $Schema | (() => $Schema);
 /**
  * A codec creates serializers and deserializers for some format such as JSON, XML, or CBOR.
  *
  * @public
  */
-export interface Codec<S, D> extends ConfigurableSerdeContext {
-    createSerializer(): ShapeSerializer<S>;
-    createDeserializer(): ShapeDeserializer<D>;
+export interface $Codec<S, D> extends ConfigurableSerdeContext {
+    createSerializer(): $ShapeSerializer<S>;
+    createDeserializer(): $ShapeDeserializer<D>;
 }
 /**
  * Configuration for codecs. Different protocols may share codecs, but require different behaviors from them.
@@ -241,25 +196,25 @@ export type CodecSettings = {
  * Turns a serialization into a data object.
  * @public
  */
-export interface ShapeDeserializer<SerializationType = Uint8Array> extends ConfigurableSerdeContext {
+export interface $ShapeDeserializer<SerializationType = Uint8Array> extends ConfigurableSerdeContext {
     /**
      * Optionally async.
      */
-    read(schema: Schema, data: SerializationType): any | Promise<any>;
+    read(schema: $Schema, data: SerializationType): any | Promise<any>;
 }
 /**
  * Turns a data object into a serialization.
  * @public
  */
-export interface ShapeSerializer<SerializationType = Uint8Array> extends ConfigurableSerdeContext {
-    write(schema: Schema, value: unknown): void;
+export interface $ShapeSerializer<SerializationType = Uint8Array> extends ConfigurableSerdeContext {
+    write(schema: $Schema, value: unknown): void;
     flush(): SerializationType;
 }
 /**
  * A client protocol defines how to convert a message (e.g. HTTP request/response) to and from a data object.
  * @public
  */
-export interface ClientProtocol<Request, Response> extends ConfigurableSerdeContext {
+export interface $ClientProtocol<Request, Response> extends ConfigurableSerdeContext {
     /**
      * @returns the Smithy qualified shape id.
      */
@@ -274,10 +229,10 @@ export interface ClientProtocol<Request, Response> extends ConfigurableSerdeCont
      * @returns the payload codec if the requests/responses have a symmetric format.
      * It otherwise may return null.
      */
-    getPayloadCodec(): Codec<any, any>;
-    serializeRequest<Input extends object>(operationSchema: OperationSchema, input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<Request>;
+    getPayloadCodec(): $Codec<any, any>;
+    serializeRequest<Input extends object>(operationSchema: $OperationSchema, input: Input, context: HandlerExecutionContext & SerdeFunctions & EndpointBearer): Promise<Request>;
     updateServiceEndpoint(request: Request, endpoint: EndpointV2): Request;
-    deserializeResponse<Output extends MetadataBearer>(operationSchema: OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: Response): Promise<Output>;
+    deserializeResponse<Output extends MetadataBearer>(operationSchema: $OperationSchema, context: HandlerExecutionContext & SerdeFunctions, response: Response): Promise<Output>;
 }
 /**
  * Allows a protocol, codec, or serde utility to accept the serdeContext

package/node_modules/@smithy/types/dist-types/ts3.4/schema/static-schemas.d.ts

@@ -1,4 +1,4 @@
-import { SchemaRef, SchemaTraits } from "../schema/schema";
+import { $SchemaRef, SchemaTraits } from "../schema/schema";
 /**
  * @alpha
  */
@@ -42,8 +42,8 @@ export type StaticSimpleSchema = [
     StaticSchemaIdSimple,
     ShapeNamespace,
     ShapeName,
-    SchemaRef,
-    SchemaTraits
+    SchemaTraits,
+    $SchemaRef
 ];
 /**
  * @alpha
@@ -53,7 +53,7 @@ export type StaticListSchema = [
     ShapeNamespace,
     ShapeName,
     SchemaTraits,
-    SchemaRef
+    $SchemaRef
 ];
 /**
  * @alpha
@@ -63,8 +63,8 @@ export type StaticMapSchema = [
     ShapeNamespace,
     ShapeName,
     SchemaTraits,
-    SchemaRef,
-    SchemaRef
+    $SchemaRef,
+    $SchemaRef
 ];
 /**
  * @alpha
@@ -75,7 +75,7 @@ export type StaticStructureSchema = [
     ShapeName,
     SchemaTraits,
     string[],
-    SchemaRef[]
+    $SchemaRef[]
 ];
 /**
  * @alpha
@@ -86,7 +86,7 @@ export type StaticErrorSchema = [
     ShapeName,
     SchemaTraits,
     string[],
-    SchemaRef[]
+    $SchemaRef[]
 ];
 /**
  * @alpha
@@ -96,6 +96,6 @@ export type StaticOperationSchema = [
     ShapeNamespace,
     ShapeName,
     SchemaTraits,
-    SchemaRef,
-    SchemaRef
+    $SchemaRef,
+    $SchemaRef
 ];

package/node_modules/@smithy/types/dist-types/ts3.4/serde.d.ts

@@ -1,5 +1,5 @@
 import { Endpoint } from "./http";
-import { ClientProtocol } from "./schema/schema";
+import { $ClientProtocol } from "./schema/schema";
 import { RequestHandler } from "./transfer";
 import { Decoder, Encoder, Provider } from "./util";
 /**
@@ -29,7 +29,7 @@ export interface StreamCollector {
 export interface SerdeContext extends SerdeFunctions, EndpointBearer {
     requestHandler: RequestHandler<any, any>;
     disableHostPrefix: boolean;
-    protocol?: ClientProtocol<any, any>;
+    protocol?: $ClientProtocol<any, any>;
 }
 /**
  * @public

package/node_modules/@smithy/types/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithy/types",
-  "version": "4.7.0",
+  "version": "4.8.0",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types && yarn build:types:downlevel'",
     "build:cjs": "node ../../scripts/inline types",

package/node_modules/@smithy/url-parser/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithy/url-parser",
-  "version": "4.2.1",
+  "version": "4.2.3",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types && yarn build:types:downlevel'",
     "build:cjs": "node ../../scripts/inline url-parser",
@@ -24,8 +24,8 @@
   "license": "Apache-2.0",
   "sideEffects": false,
   "dependencies": {
-    "@smithy/querystring-parser": "^4.2.1",
-    "@smithy/types": "^4.7.0",
+    "@smithy/querystring-parser": "^4.2.3",
+    "@smithy/types": "^4.8.0",
     "tslib": "^2.6.2"
   },
   "typesVersions": {

package/node_modules/@smithy/util-defaults-mode-browser/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithy/util-defaults-mode-browser",
-  "version": "4.3.1",
+  "version": "4.3.3",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types && yarn build:types:downlevel'",
     "build:cjs": "node ../../scripts/inline util-defaults-mode-browser",
@@ -24,9 +24,9 @@
   "license": "Apache-2.0",
   "sideEffects": false,
   "dependencies": {
-    "@smithy/property-provider": "^4.2.1",
-    "@smithy/smithy-client": "^4.8.0",
-    "@smithy/types": "^4.7.0",
+    "@smithy/property-provider": "^4.2.3",
+    "@smithy/smithy-client": "^4.9.0",
+    "@smithy/types": "^4.8.0",
     "tslib": "^2.6.2"
   },
   "devDependencies": {

package/node_modules/@smithy/util-defaults-mode-node/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smithy/util-defaults-mode-node",
-  "version": "4.2.2",
+  "version": "4.2.4",
   "scripts": {
     "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types && yarn build:types:downlevel'",
     "build:cjs": "node ../../scripts/inline util-defaults-mode-node",
@@ -24,12 +24,12 @@
   "license": "Apache-2.0",
   "sideEffects": false,
   "dependencies": {
-    "@smithy/config-resolver": "^4.3.1",
-    "@smithy/credential-provider-imds": "^4.2.1",
-    "@smithy/node-config-provider": "^4.3.1",
-    "@smithy/property-provider": "^4.2.1",
-    "@smithy/smithy-client": "^4.8.0",
-    "@smithy/types": "^4.7.0",
+    "@smithy/config-resolver": "^4.3.3",
+    "@smithy/credential-provider-imds": "^4.2.3",
+    "@smithy/node-config-provider": "^4.3.3",
+    "@smithy/property-provider": "^4.2.3",
+    "@smithy/smithy-client": "^4.9.0",
+    "@smithy/types": "^4.8.0",
     "tslib": "^2.6.2"
   },
   "devDependencies": {

package/node_modules/@smithy/util-endpoints/dist-cjs/index.js

@@ -260,22 +260,25 @@ const evaluateExpression = (obj, keyName, options) => {
         return evaluateTemplate(obj, options);
     }
     else if (obj["fn"]) {
-        return callFunction(obj, options);
+        return group$2.callFunction(obj, options);
     }
     else if (obj["ref"]) {
         return getReferenceValue(obj, options);
     }
     throw new EndpointError(`'${keyName}': ${String(obj)} is not a string, function or reference.`);
 };
-
 const callFunction = ({ fn, argv }, options) => {
-    const evaluatedArgs = argv.map((arg) => ["boolean", "number"].includes(typeof arg) ? arg : evaluateExpression(arg, "arg", options));
+    const evaluatedArgs = argv.map((arg) => ["boolean", "number"].includes(typeof arg) ? arg : group$2.evaluateExpression(arg, "arg", options));
     const fnSegments = fn.split(".");
     if (fnSegments[0] in customEndpointFunctions && fnSegments[1] != null) {
         return customEndpointFunctions[fnSegments[0]][fnSegments[1]](...evaluatedArgs);
     }
     return endpointFunctions[fn](...evaluatedArgs);
 };
+const group$2 = {
+    evaluateExpression,
+    callFunction,
+};
 
 const evaluateCondition = ({ assign, ...fnArgs }, options) => {
     if (assign && assign in options.referenceRecord) {
@@ -321,6 +324,10 @@ const getEndpointHeaders = (headers, options) => Object.entries(headers).reduce(
     }),
 }), {});
 
+const getEndpointProperties = (properties, options) => Object.entries(properties).reduce((acc, [propertyKey, propertyVal]) => ({
+    ...acc,
+    [propertyKey]: group$1.getEndpointProperty(propertyVal, options),
+}), {});
 const getEndpointProperty = (property, options) => {
     if (Array.isArray(property)) {
         return property.map((propertyEntry) => getEndpointProperty(propertyEntry, options));
@@ -332,18 +339,17 @@ const getEndpointProperty = (property, options) => {
             if (property === null) {
                 throw new EndpointError(`Unexpected endpoint property: ${property}`);
             }
-            return getEndpointProperties(property, options);
+            return group$1.getEndpointProperties(property, options);
         case "boolean":
             return property;
         default:
             throw new EndpointError(`Unexpected endpoint property type: ${typeof property}`);
     }
 };
-
-const getEndpointProperties = (properties, options) => Object.entries(properties).reduce((acc, [propertyKey, propertyVal]) => ({
-    ...acc,
-    [propertyKey]: getEndpointProperty(propertyVal, options),
-}), {});
+const group$1 = {
+    getEndpointProperty,
+    getEndpointProperties,
+};
 
 const getEndpointUrl = (endpointUrl, options) => {
     const expression = evaluateExpression(endpointUrl, "Endpoint URL", options);
@@ -394,18 +400,6 @@ const evaluateErrorRule = (errorRule, options) => {
     }));
 };
 
-const evaluateTreeRule = (treeRule, options) => {
-    const { conditions, rules } = treeRule;
-    const { result, referenceRecord } = evaluateConditions(conditions, options);
-    if (!result) {
-        return;
-    }
-    return evaluateRules(rules, {
-        ...options,
-        referenceRecord: { ...options.referenceRecord, ...referenceRecord },
-    });
-};
-
 const evaluateRules = (rules, options) => {
     for (const rule of rules) {
         if (rule.type === "endpoint") {
@@ -418,7 +412,7 @@ const evaluateRules = (rules, options) => {
             evaluateErrorRule(rule, options);
         }
         else if (rule.type === "tree") {
-            const endpointOrUndefined = evaluateTreeRule(rule, options);
+            const endpointOrUndefined = group.evaluateTreeRule(rule, options);
             if (endpointOrUndefined) {
                 return endpointOrUndefined;
             }
@@ -429,6 +423,21 @@ const evaluateRules = (rules, options) => {
     }
     throw new EndpointError(`Rules evaluation failed`);
 };
+const evaluateTreeRule = (treeRule, options) => {
+    const { conditions, rules } = treeRule;
+    const { result, referenceRecord } = evaluateConditions(conditions, options);
+    if (!result) {
+        return;
+    }
+    return group.evaluateRules(rules, {
+        ...options,
+        referenceRecord: { ...options.referenceRecord, ...referenceRecord },
+    });
+};
+const group = {
+    evaluateRules,
+    evaluateTreeRule,
+};
 
 const resolveEndpoint = (ruleSetObject, options) => {
     const { endpointParams, logger } = options;

package/node_modules/@smithy/util-endpoints/dist-es/utils/callFunction.js

@@ -1,11 +1 @@
-import { customEndpointFunctions } from "./customEndpointFunctions";
-import { endpointFunctions } from "./endpointFunctions";
-import { evaluateExpression } from "./evaluateExpression";
-export const callFunction = ({ fn, argv }, options) => {
-    const evaluatedArgs = argv.map((arg) => ["boolean", "number"].includes(typeof arg) ? arg : evaluateExpression(arg, "arg", options));
-    const fnSegments = fn.split(".");
-    if (fnSegments[0] in customEndpointFunctions && fnSegments[1] != null) {
-        return customEndpointFunctions[fnSegments[0]][fnSegments[1]](...evaluatedArgs);
-    }
-    return endpointFunctions[fn](...evaluatedArgs);
-};
+export { callFunction } from "./evaluateExpression";

package/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateExpression.js

@@ -1,5 +1,6 @@
 import { EndpointError } from "../types";
-import { callFunction } from "./callFunction";
+import { customEndpointFunctions } from "./customEndpointFunctions";
+import { endpointFunctions } from "./endpointFunctions";
 import { evaluateTemplate } from "./evaluateTemplate";
 import { getReferenceValue } from "./getReferenceValue";
 export const evaluateExpression = (obj, keyName, options) => {
@@ -7,10 +8,22 @@ export const evaluateExpression = (obj, keyName, options) => {
         return evaluateTemplate(obj, options);
     }
     else if (obj["fn"]) {
-        return callFunction(obj, options);
+        return group.callFunction(obj, options);
     }
     else if (obj["ref"]) {
         return getReferenceValue(obj, options);
     }
     throw new EndpointError(`'${keyName}': ${String(obj)} is not a string, function or reference.`);
 };
+export const callFunction = ({ fn, argv }, options) => {
+    const evaluatedArgs = argv.map((arg) => ["boolean", "number"].includes(typeof arg) ? arg : group.evaluateExpression(arg, "arg", options));
+    const fnSegments = fn.split(".");
+    if (fnSegments[0] in customEndpointFunctions && fnSegments[1] != null) {
+        return customEndpointFunctions[fnSegments[0]][fnSegments[1]](...evaluatedArgs);
+    }
+    return endpointFunctions[fn](...evaluatedArgs);
+};
+export const group = {
+    evaluateExpression,
+    callFunction,
+};

package/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateRules.js

@@ -1,7 +1,7 @@
 import { EndpointError } from "../types";
+import { evaluateConditions } from "./evaluateConditions";
 import { evaluateEndpointRule } from "./evaluateEndpointRule";
 import { evaluateErrorRule } from "./evaluateErrorRule";
-import { evaluateTreeRule } from "./evaluateTreeRule";
 export const evaluateRules = (rules, options) => {
     for (const rule of rules) {
         if (rule.type === "endpoint") {
@@ -14,7 +14,7 @@ export const evaluateRules = (rules, options) => {
             evaluateErrorRule(rule, options);
         }
         else if (rule.type === "tree") {
-            const endpointOrUndefined = evaluateTreeRule(rule, options);
+            const endpointOrUndefined = group.evaluateTreeRule(rule, options);
             if (endpointOrUndefined) {
                 return endpointOrUndefined;
             }
@@ -25,3 +25,18 @@ export const evaluateRules = (rules, options) => {
     }
     throw new EndpointError(`Rules evaluation failed`);
 };
+export const evaluateTreeRule = (treeRule, options) => {
+    const { conditions, rules } = treeRule;
+    const { result, referenceRecord } = evaluateConditions(conditions, options);
+    if (!result) {
+        return;
+    }
+    return group.evaluateRules(rules, {
+        ...options,
+        referenceRecord: { ...options.referenceRecord, ...referenceRecord },
+    });
+};
+export const group = {
+    evaluateRules,
+    evaluateTreeRule,
+};

package/node_modules/@smithy/util-endpoints/dist-es/utils/evaluateTreeRule.js

@@ -1,13 +1 @@
-import { evaluateConditions } from "./evaluateConditions";
-import { evaluateRules } from "./evaluateRules";
-export const evaluateTreeRule = (treeRule, options) => {
-    const { conditions, rules } = treeRule;
-    const { result, referenceRecord } = evaluateConditions(conditions, options);
-    if (!result) {
-        return;
-    }
-    return evaluateRules(rules, {
-        ...options,
-        referenceRecord: { ...options.referenceRecord, ...referenceRecord },
-    });
-};
+export { evaluateTreeRule } from "./evaluateRules";

package/node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointProperties.js

@@ -1,5 +1,28 @@
-import { getEndpointProperty } from "./getEndpointProperty";
+import { EndpointError } from "../types";
+import { evaluateTemplate } from "./evaluateTemplate";
 export const getEndpointProperties = (properties, options) => Object.entries(properties).reduce((acc, [propertyKey, propertyVal]) => ({
     ...acc,
-    [propertyKey]: getEndpointProperty(propertyVal, options),
+    [propertyKey]: group.getEndpointProperty(propertyVal, options),
 }), {});
+export const getEndpointProperty = (property, options) => {
+    if (Array.isArray(property)) {
+        return property.map((propertyEntry) => getEndpointProperty(propertyEntry, options));
+    }
+    switch (typeof property) {
+        case "string":
+            return evaluateTemplate(property, options);
+        case "object":
+            if (property === null) {
+                throw new EndpointError(`Unexpected endpoint property: ${property}`);
+            }
+            return group.getEndpointProperties(property, options);
+        case "boolean":
+            return property;
+        default:
+            throw new EndpointError(`Unexpected endpoint property type: ${typeof property}`);
+    }
+};
+export const group = {
+    getEndpointProperty,
+    getEndpointProperties,
+};

package/node_modules/@smithy/util-endpoints/dist-es/utils/getEndpointProperty.js

@@ -1,21 +1 @@
-import { EndpointError } from "../types";
-import { evaluateTemplate } from "./evaluateTemplate";
-import { getEndpointProperties } from "./getEndpointProperties";
-export const getEndpointProperty = (property, options) => {
-    if (Array.isArray(property)) {
-        return property.map((propertyEntry) => getEndpointProperty(propertyEntry, options));
-    }
-    switch (typeof property) {
-        case "string":
-            return evaluateTemplate(property, options);
-        case "object":
-            if (property === null) {
-                throw new EndpointError(`Unexpected endpoint property: ${property}`);
-            }
-            return getEndpointProperties(property, options);
-        case "boolean":
-            return property;
-        default:
-            throw new EndpointError(`Unexpected endpoint property type: ${typeof property}`);
-    }
-};
+export { getEndpointProperty } from "./getEndpointProperties";

package/node_modules/@smithy/util-endpoints/dist-types/ts3.4/utils/callFunction.d.ts

@@ -1,2 +1 @@
-import { EvaluateOptions, FunctionObject, FunctionReturn } from "../types";
-export declare const callFunction: ({ fn, argv }: FunctionObject, options: EvaluateOptions) => FunctionReturn;
+export { callFunction } from "./evaluateExpression";

package/node_modules/@smithy/util-endpoints/dist-types/ts3.4/utils/evaluateExpression.d.ts

@@ -1,2 +1,7 @@
-import { EvaluateOptions, Expression } from "../types";
-export declare const evaluateExpression: (obj: Expression, keyName: string, options: EvaluateOptions) => import("../types").FunctionReturn;
+import { EvaluateOptions, Expression, FunctionObject, FunctionReturn } from "../types";
+export declare const evaluateExpression: (obj: Expression, keyName: string, options: EvaluateOptions) => FunctionReturn;
+export declare const callFunction: ({ fn, argv }: FunctionObject, options: EvaluateOptions) => FunctionReturn;
+export declare const group: {
+    evaluateExpression: (obj: Expression, keyName: string, options: EvaluateOptions) => FunctionReturn;
+    callFunction: ({ fn, argv }: FunctionObject, options: EvaluateOptions) => FunctionReturn;
+};

package/node_modules/@smithy/util-endpoints/dist-types/ts3.4/utils/evaluateRules.d.ts

@@ -1,3 +1,8 @@
 import { EndpointV2 } from "@smithy/types";
-import { EvaluateOptions, RuleSetRules } from "../types";
+import { EvaluateOptions, RuleSetRules, TreeRuleObject } from "../types";
 export declare const evaluateRules: (rules: RuleSetRules, options: EvaluateOptions) => EndpointV2;
+export declare const evaluateTreeRule: (treeRule: TreeRuleObject, options: EvaluateOptions) => EndpointV2 | undefined;
+export declare const group: {
+    evaluateRules: (rules: RuleSetRules, options: EvaluateOptions) => EndpointV2;
+    evaluateTreeRule: (treeRule: TreeRuleObject, options: EvaluateOptions) => EndpointV2 | undefined;
+};

package/node_modules/@smithy/util-endpoints/dist-types/ts3.4/utils/evaluateTreeRule.d.ts

@@ -1,3 +1 @@
-import { EndpointV2 } from "@smithy/types";
-import { EvaluateOptions, TreeRuleObject } from "../types";
-export declare const evaluateTreeRule: (treeRule: TreeRuleObject, options: EvaluateOptions) => EndpointV2 | undefined;
+export { evaluateTreeRule } from "./evaluateRules";

package/node_modules/@smithy/util-endpoints/dist-types/ts3.4/utils/getEndpointProperties.d.ts

@@ -1,2 +1,8 @@
+import { EndpointObjectProperty } from "@smithy/types";
 import { EndpointObjectProperties, EvaluateOptions } from "../types";
 export declare const getEndpointProperties: (properties: EndpointObjectProperties, options: EvaluateOptions) => {};
+export declare const getEndpointProperty: (property: EndpointObjectProperty, options: EvaluateOptions) => EndpointObjectProperty;
+export declare const group: {
+    getEndpointProperty: (property: EndpointObjectProperty, options: EvaluateOptions) => EndpointObjectProperty;
+    getEndpointProperties: (properties: EndpointObjectProperties, options: EvaluateOptions) => {};
+};

package/node_modules/@smithy/util-endpoints/dist-types/ts3.4/utils/getEndpointProperty.d.ts

@@ -1,3 +1 @@
-import { EndpointObjectProperty } from "@smithy/types";
-import { EvaluateOptions } from "../types";
-export declare const getEndpointProperty: (property: EndpointObjectProperty, options: EvaluateOptions) => EndpointObjectProperty;
+export { getEndpointProperty } from "./getEndpointProperties";

package/node_modules/@smithy/util-endpoints/dist-types/utils/callFunction.d.ts

@@ -1,2 +1 @@
-import type { EvaluateOptions, FunctionObject, FunctionReturn } from "../types";
-export declare const callFunction: ({ fn, argv }: FunctionObject, options: EvaluateOptions) => FunctionReturn;
+export { callFunction } from "./evaluateExpression";