@cdklabs/cdk-construct-connect-datalake 0.0.17 → 0.0.18

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/index.d.ts

@@ -0,0 +1,24 @@
+export { toEndpointV1 } from "@smithy/core/transport";
+export { BinaryDecisionDiagram } from "./util-endpoints/bdd/BinaryDecisionDiagram";
+export { EndpointCache } from "./util-endpoints/cache/EndpointCache";
+export { decideEndpoint } from "./util-endpoints/decideEndpoint";
+export { isIpAddress } from "./util-endpoints/lib/isIpAddress";
+export { isValidHostLabel } from "@smithy/core/transport";
+export { customEndpointFunctions } from "./util-endpoints/utils/customEndpointFunctions";
+export { resolveEndpoint } from "./util-endpoints/resolveEndpoint";
+export { EndpointError } from "./util-endpoints/types";
+export { ConditionObject, DeprecatedObject, EndpointFunctions, EndpointObject, EndpointObjectHeaders, EndpointObjectProperties, EndpointParams, EndpointResolverOptions, EndpointRuleObject, ErrorRuleObject, EvaluateOptions, Expression, FunctionArgv, FunctionObject, FunctionReturn, ParameterObject, ReferenceObject, ReferenceRecord, RuleSetObject, RuleSetRules, TreeRuleObject, } from "./util-endpoints/types";
+export declare const getEndpointFromInstructions: <T extends import("@smithy/types").EndpointParameters, CommandInput extends object, Config extends object>(commandInput: CommandInput, instructionsSupplier: import("./middleware-endpoint/adaptors/getEndpointFromInstructions").EndpointParameterInstructionsSupplier, clientConfig: Partial<import("./middleware-endpoint/resolveEndpointConfig").EndpointResolvedConfig<T>> & Config, context?: import("@smithy/types").HandlerExecutionContext) => Promise<import("@smithy/types").EndpointV2>;
+export declare const resolveEndpointConfig: <T, P extends import("@smithy/types").EndpointParameters = import("@smithy/types").EndpointParameters>(input: T & import("./middleware-endpoint/resolveEndpointConfig").EndpointInputConfig<P> & import("./middleware-endpoint/resolveEndpointConfig").PreviouslyResolved<P>) => T & import("./middleware-endpoint/resolveEndpointConfig").EndpointResolvedConfig<P>;
+export declare const endpointMiddleware: <T extends import("@smithy/types").EndpointParameters>({ config, instructions, }: {
+    config: import("./middleware-endpoint/resolveEndpointConfig").EndpointResolvedConfig<T>;
+    instructions: import("@smithy/types").EndpointParameterInstructions;
+}) => import("@smithy/types").SerializeMiddleware<any, any>;
+export declare const getEndpointPlugin: <T extends import("@smithy/types").EndpointParameters>(config: import("./middleware-endpoint/resolveEndpointConfig").EndpointResolvedConfig<T>, instructions: import("@smithy/types").EndpointParameterInstructions) => import("@smithy/types").Pluggable<any, any>;
+export { resolveParams, EndpointParameterInstructionsSupplier } from "./middleware-endpoint/adaptors/getEndpointFromInstructions";
+export { toEndpointV1 as middlewareEndpointToEndpointV1 } from "./middleware-endpoint/adaptors/toEndpointV1";
+export { endpointMiddlewareOptions } from "./middleware-endpoint/getEndpointPlugin";
+export { EndpointInputConfig, EndpointResolvedConfig } from "./middleware-endpoint/resolveEndpointConfig";
+export { resolveEndpointRequiredConfig } from "./middleware-endpoint/resolveEndpointRequiredConfig";
+export { EndpointRequiredInputConfig, EndpointRequiredResolvedConfig, } from "./middleware-endpoint/resolveEndpointRequiredConfig";
+export { EndpointParameterInstructions, BuiltInParamInstruction, ClientContextParamInstruction, ContextParamInstruction, OperationContextParamInstruction, StaticContextParamInstruction, } from "@smithy/types";

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/middleware-endpoint/adaptors/createConfigValueProvider.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Normalize some key of the client config to an async provider.
+ * @internal
+ *
+ * @param configKey - the key to look up in config.
+ * @param canonicalEndpointParamKey - this is the name the EndpointRuleSet uses.
+ *                                    it will most likely not contain the config
+ *                                    value, but we use it as a fallback.
+ * @param config - container of the config values.
+ * @param isClientContextParam - whether this is a client context parameter.
+ *
+ * @returns async function that will resolve with the value.
+ */
+export declare const createConfigValueProvider: <Config extends Record<string, unknown>>(configKey: string, canonicalEndpointParamKey: string, config: Config, isClientContextParam?: boolean) => () => Promise<any>;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/middleware-endpoint/adaptors/getEndpointFromConfig.browser.d.ts

@@ -0,0 +1 @@
+export declare const getEndpointFromConfig: (serviceId?: string) => Promise<string | undefined>;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/middleware-endpoint/adaptors/getEndpointFromConfig.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @internal
+ */
+export declare const getEndpointFromConfig: (serviceId?: string) => Promise<string | undefined>;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/middleware-endpoint/adaptors/getEndpointFromInstructions.d.ts

@@ -0,0 +1,20 @@
+import { EndpointParameterInstructions, EndpointParameters, EndpointV2, HandlerExecutionContext } from "@smithy/types";
+import { EndpointResolvedConfig } from "../resolveEndpointConfig";
+/**
+ * @internal
+ */
+export type EndpointParameterInstructionsSupplier = Partial<{
+    getEndpointParameterInstructions(): EndpointParameterInstructions;
+}>;
+/**
+ * @internal
+ */
+export type GetEndpointFromConfig = (serviceId?: string) => Promise<string | undefined>;
+/**
+ * @internal
+ */
+export declare function bindGetEndpointFromInstructions(getEndpointFromConfig: GetEndpointFromConfig): <T extends EndpointParameters, CommandInput extends object, Config extends object>(commandInput: CommandInput, instructionsSupplier: EndpointParameterInstructionsSupplier, clientConfig: Partial<EndpointResolvedConfig<T>> & Config, context?: HandlerExecutionContext) => Promise<EndpointV2>;
+/**
+ * @internal
+ */
+export declare const resolveParams: <T extends EndpointParameters, CommandInput, Config>(commandInput: CommandInput, instructionsSupplier: EndpointParameterInstructionsSupplier, clientConfig: Partial<EndpointResolvedConfig<T>> & Config) => Promise<EndpointParameters>;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/middleware-endpoint/adaptors/getEndpointUrlConfig.d.ts

@@ -0,0 +1,2 @@
+import { LoadedConfigSelectors } from "@smithy/core/config";
+export declare const getEndpointUrlConfig: (serviceId: string) => LoadedConfigSelectors<string | undefined>;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/middleware-endpoint/adaptors/toEndpointV1.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @deprecated Use `toEndpointV1` from `@smithy/core/transport` instead.
+ * @internal
+ */
+export { toEndpointV1 } from "@smithy/core/transport";

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/middleware-endpoint/endpointMiddleware.d.ts

@@ -0,0 +1,10 @@
+import { EndpointParameterInstructions, EndpointParameters, SerializeMiddleware } from "@smithy/types";
+import { GetEndpointFromConfig } from "./adaptors/getEndpointFromInstructions";
+import { EndpointResolvedConfig } from "./resolveEndpointConfig";
+/**
+ * @internal
+ */
+export declare function bindEndpointMiddleware(getEndpointFromConfig: GetEndpointFromConfig): <T extends EndpointParameters>({ config, instructions, }: {
+    config: EndpointResolvedConfig<T>;
+    instructions: EndpointParameterInstructions;
+}) => SerializeMiddleware<any, any>;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/middleware-endpoint/getEndpointPlugin.d.ts

@@ -0,0 +1,11 @@
+import { EndpointParameterInstructions, EndpointParameters, Pluggable, RelativeMiddlewareOptions, SerializeHandlerOptions } from "@smithy/types";
+import { GetEndpointFromConfig } from "./adaptors/getEndpointFromInstructions";
+import { EndpointResolvedConfig } from "./resolveEndpointConfig";
+/**
+ * @internal
+ */
+export declare const endpointMiddlewareOptions: SerializeHandlerOptions & RelativeMiddlewareOptions;
+/**
+ * @internal
+ */
+export declare function bindGetEndpointPlugin(getEndpointFromConfig: GetEndpointFromConfig): <T extends EndpointParameters>(config: EndpointResolvedConfig<T>, instructions: EndpointParameterInstructions) => Pluggable<any, any>;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/middleware-endpoint/resolveEndpointConfig.d.ts

@@ -0,0 +1,110 @@
+import { Endpoint, EndpointParameters, EndpointV2, Logger, Provider, UrlParser } from "@smithy/types";
+import { GetEndpointFromConfig } from "./adaptors/getEndpointFromInstructions";
+/**
+ * Endpoint config interfaces and resolver for Endpoint v2. They live in separate package to allow per-service onboarding.
+ * When all services onboard Endpoint v2, the resolver in config-resolver package can be removed.
+ * This interface includes all the endpoint parameters with built-in bindings of "AWS::*" and "SDK::*"
+ *
+ * @public
+ */
+export interface EndpointInputConfig<T extends EndpointParameters = EndpointParameters> {
+    /**
+     * The fully qualified endpoint of the webservice. This is only for using
+     * a custom endpoint (for example, when using a local version of S3).
+     *
+     * Endpoint transformations such as S3 applying a bucket to the hostname are
+     * still applicable to this custom endpoint.
+     */
+    endpoint?: string | Endpoint | Provider<Endpoint> | EndpointV2 | Provider<EndpointV2>;
+    /**
+     * Providing a custom endpointProvider will override
+     * built-in transformations of the endpoint such as S3 adding the bucket
+     * name to the hostname, since they are part of the default endpointProvider.
+     */
+    endpointProvider?: (params: T, context?: {
+        logger?: Logger;
+    }) => EndpointV2;
+    /**
+     * Whether TLS is enabled for requests.
+     * @deprecated
+     */
+    tls?: boolean;
+    /**
+     * Enables IPv6/IPv4 dualstack endpoint.
+     */
+    useDualstackEndpoint?: boolean | Provider<boolean | undefined>;
+    /**
+     * Enables FIPS compatible endpoints.
+     */
+    useFipsEndpoint?: boolean | Provider<boolean | undefined>;
+    /**
+     * This field is used internally so you should not fill any value to this field.
+     *
+     * @internal
+     */
+    serviceConfiguredEndpoint?: never;
+}
+/**
+ * @internal
+ */
+export interface PreviouslyResolved<T extends EndpointParameters = EndpointParameters> {
+    urlParser: UrlParser;
+    endpointProvider: (params: T, context?: {
+        logger?: Logger;
+    }) => EndpointV2;
+    logger?: Logger;
+    serviceId?: string;
+}
+/**
+ * This supersedes the similarly named EndpointsResolvedConfig (no parametric types)
+ * from resolveEndpointsConfig.ts in \@smithy/config-resolver.
+ *
+ * @internal
+ */
+export interface EndpointResolvedConfig<T extends EndpointParameters = EndpointParameters> {
+    /**
+     * Custom endpoint provided by the user.
+     * This is normalized to a single interface from the various acceptable types.
+     * This field will be undefined if a custom endpoint is not provided.
+     */
+    endpoint?: Provider<Endpoint>;
+    endpointProvider: (params: T, context?: {
+        logger?: Logger;
+    }) => EndpointV2;
+    /**
+     * Whether TLS is enabled for requests.
+     * @deprecated
+     */
+    tls: boolean;
+    /**
+     * Whether the endpoint is specified by caller.
+     * This should be used over checking the existence of `endpoint`, since
+     * that may have been set by other means, such as the default regional
+     * endpoint provider function.
+     *
+     * @internal
+     */
+    isCustomEndpoint?: boolean;
+    /**
+     * Resolved value for input {@link EndpointsInputConfig.useDualstackEndpoint}
+     */
+    useDualstackEndpoint: Provider<boolean>;
+    /**
+     * Resolved value for input {@link EndpointsInputConfig.useFipsEndpoint}
+     */
+    useFipsEndpoint: Provider<boolean>;
+    /**
+     * Unique service identifier.
+     * @internal
+     */
+    serviceId?: string;
+    /**
+     * A configured endpoint global or specific to the service from ENV or AWS SDK configuration files.
+     * @internal
+     */
+    serviceConfiguredEndpoint?: Provider<string | undefined>;
+}
+/**
+ * @internal
+ */
+export declare function bindResolveEndpointConfig(getEndpointFromConfig: GetEndpointFromConfig): <T, P extends EndpointParameters = EndpointParameters>(input: T & EndpointInputConfig<P> & PreviouslyResolved<P>) => T & EndpointResolvedConfig<P>;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/middleware-endpoint/resolveEndpointRequiredConfig.d.ts

@@ -0,0 +1,32 @@
+import { Endpoint, EndpointV2, Provider } from "@smithy/types";
+/**
+ * This is an additional config resolver layer for clients using the default
+ * endpoints ruleset. It modifies the input and output config types to make
+ * the endpoint configuration property required.
+ *
+ * It must be placed after the `resolveEndpointConfig`
+ * resolver. This replaces the "CustomEndpoints" config resolver, which was used
+ * prior to default endpoint rulesets.
+ *
+ * @public
+ */
+export interface EndpointRequiredInputConfig {
+    endpoint: string | Endpoint | Provider<Endpoint> | EndpointV2 | Provider<EndpointV2>;
+}
+/**
+ * @internal
+ */
+interface PreviouslyResolved {
+    endpoint?: Provider<Endpoint>;
+}
+/**
+ * @internal
+ */
+export interface EndpointRequiredResolvedConfig {
+    endpoint: Provider<Endpoint>;
+}
+/**
+ * @internal
+ */
+export declare const resolveEndpointRequiredConfig: <T>(input: T & EndpointRequiredInputConfig & PreviouslyResolved) => T & EndpointRequiredResolvedConfig;
+export {};

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/middleware-endpoint/service-customizations/index.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @internal
+ */
+export { DOT_PATTERN, S3_HOSTNAME_PATTERN, isArnBucketName, isDnsCompatibleBucketName, resolveParamsForS3 } from "./s3";

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/middleware-endpoint/service-customizations/s3.d.ts

@@ -0,0 +1,26 @@
+import { EndpointParameters } from "@smithy/types";
+/**
+ * @internal
+ */
+export declare const resolveParamsForS3: (endpointParams: EndpointParameters) => Promise<EndpointParameters>;
+/**
+ * @internal
+ */
+export declare const DOT_PATTERN: RegExp;
+/**
+ * @internal
+ */
+export declare const S3_HOSTNAME_PATTERN: RegExp;
+/**
+ * Determines whether a given string is DNS compliant per the rules outlined by
+ * S3. Length, capitaization, and leading dot restrictions are enforced by the
+ * DOMAIN_PATTERN regular expression.
+ * @internal
+ *
+ * @see https://docs.aws.amazon.com/AmazonS3/latest/dev/BucketRestrictions.html
+ */
+export declare const isDnsCompatibleBucketName: (bucketName: string) => boolean;
+/**
+ * @internal
+ */
+export declare const isArnBucketName: (bucketName: string) => boolean;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/bdd/BinaryDecisionDiagram.d.ts

@@ -0,0 +1,41 @@
+import { EndpointObjectHeaders, ParameterObject } from "@smithy/types";
+import { Expression, FunctionArgv } from "../types/shared";
+/**
+ * @internal
+ */
+type BddCondition = [
+    string,
+    FunctionArgv
+] | [
+    string,
+    FunctionArgv,
+    string
+];
+/**
+ * @internal
+ */
+type BddResult = [
+    -1
+] | [
+    -1,
+    Expression
+] | [
+    string,
+    Record<string, ParameterObject>,
+    EndpointObjectHeaders
+] | [
+    string,
+    Record<string, ParameterObject>
+];
+/**
+ * @internal
+ */
+export declare class BinaryDecisionDiagram {
+    nodes: Int32Array;
+    root: number;
+    conditions: BddCondition[];
+    results: BddResult[];
+    private constructor();
+    static from(bdd: Int32Array, root: number, conditions: BddCondition[] | any[], results: BddResult[] | any[]): BinaryDecisionDiagram;
+}
+export {};

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/cache/EndpointCache.d.ts

@@ -0,0 +1,34 @@
+import { EndpointParams, EndpointV2 } from "@smithy/types";
+/**
+ * Cache for endpoint ruleSet resolution.
+ *
+ * @internal
+ */
+export declare class EndpointCache {
+    private capacity;
+    private data;
+    private parameters;
+    /**
+     * @param [size] - desired average maximum capacity. A buffer of 10 additional keys will be allowed
+     *                 before keys are dropped.
+     * @param [params] - list of params to consider as part of the cache key.
+     *
+     * If the params list is not populated, no caching will happen.
+     * This may be out of order depending on how the object is created and arrives to this class.
+     */
+    constructor({ size, params }: {
+        size?: number;
+        params?: string[];
+    });
+    /**
+     * @param endpointParams - query for endpoint.
+     * @param resolver - provider of the value if not present.
+     * @returns endpoint corresponding to the query.
+     */
+    get(endpointParams: EndpointParams, resolver: () => EndpointV2): EndpointV2;
+    size(): number;
+    /**
+     * @returns cache key or false if not cachable.
+     */
+    private hash;
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/debug/debugId.d.ts

@@ -0,0 +1 @@
+export declare const debugId = "endpoints";

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/debug/index.d.ts

@@ -0,0 +1,2 @@
+export { debugId } from "./debugId";
+export { toDebugString } from "./toDebugString";

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/debug/toDebugString.d.ts

@@ -0,0 +1,9 @@
+import { EndpointParameters, EndpointV2 } from "@smithy/types";
+import { GetAttrValue } from "../lib";
+import { EndpointObject, FunctionObject, FunctionReturn } from "../types";
+export declare function toDebugString(input: EndpointParameters): string;
+export declare function toDebugString(input: EndpointV2): string;
+export declare function toDebugString(input: GetAttrValue): string;
+export declare function toDebugString(input: FunctionObject): string;
+export declare function toDebugString(input: FunctionReturn): string;
+export declare function toDebugString(input: EndpointObject): string;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/decideEndpoint.d.ts

@@ -0,0 +1,7 @@
+import { EndpointV2 } from "@smithy/types";
+import { BinaryDecisionDiagram } from "./bdd/BinaryDecisionDiagram";
+import { EndpointResolverOptions } from "./types";
+/**
+ * Resolves an endpoint URL by processing the endpoints bdd and options.
+ */
+export declare const decideEndpoint: (bdd: BinaryDecisionDiagram, options: EndpointResolverOptions) => EndpointV2;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/getEndpointUrlConfig.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Inlined from @smithy/core/config to avoid circular dependency.
+ *
+ * @internal
+ */
+type LoadedConfigSelectors<T> = {
+    environmentVariableSelector: (env: Record<string, string | undefined>) => T | undefined;
+    configFileSelector: (profile: Record<string, string | undefined>, configFile?: Record<string, Record<string, string | undefined>>) => T | undefined;
+    default: T | (() => T);
+};
+export declare const getEndpointUrlConfig: (serviceId: string) => LoadedConfigSelectors<string | undefined>;
+export {};

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/lib/booleanEquals.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Evaluates two boolean values value1 and value2 for equality and returns
+ * true if both values match.
+ */
+export declare const booleanEquals: (value1: boolean, value2: boolean) => boolean;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/lib/coalesce.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Evaluates arguments in order and returns the first non-empty result,
+ * otherwise returns the result of the last argument.
+ *
+ * @internal
+ */
+export declare function coalesce<T>(...args: (T | undefined)[]): T | undefined;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/lib/getAttr.d.ts

@@ -0,0 +1,7 @@
+export type GetAttrValue = string | boolean | {
+    [key: string]: GetAttrValue;
+} | Array<GetAttrValue>;
+/**
+ * Returns value corresponding to pathing string for an array or object.
+ */
+export declare const getAttr: (value: GetAttrValue, path: string) => GetAttrValue;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/lib/getAttrPathList.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Parses path as a getAttr expression, returning a list of strings.
+ */
+export declare const getAttrPathList: (path: string) => Array<string>;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/lib/index.d.ts

@@ -0,0 +1,13 @@
+export { booleanEquals } from "./booleanEquals";
+export { coalesce } from "./coalesce";
+export { getAttr } from "./getAttr";
+export { GetAttrValue } from "./getAttr";
+export { isSet } from "./isSet";
+export { isValidHostLabel } from "@smithy/core/transport";
+export { ite } from "./ite";
+export { not } from "./not";
+export { parseURL } from "./parseURL";
+export { split } from "./split";
+export { stringEquals } from "./stringEquals";
+export { substring } from "./substring";
+export { uriEncode } from "./uriEncode";

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/lib/isIpAddress.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Validates if the provided value is an IP address.
+ */
+export declare const isIpAddress: (value: string) => boolean;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/lib/isSet.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Evaluates whether a value is set (aka not null or undefined).
+ * Returns true if the value is set, otherwise returns false.
+ */
+export declare const isSet: (value: unknown) => value is {};

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/lib/ite.d.ts

@@ -0,0 +1,6 @@
+/**
+ * An if-then-else function that returns one of two values based on a boolean condition.
+ *
+ * @internal
+ */
+export declare function ite<T>(condition: boolean, trueValue: T | undefined, falseValue: T | undefined): T | undefined;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/lib/not.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Performs logical negation on the provided boolean value,
+ * returning the negated value.
+ */
+export declare const not: (value: boolean) => boolean;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/lib/parseURL.d.ts

@@ -0,0 +1,5 @@
+import { Endpoint, EndpointURL } from "@smithy/types";
+/**
+ * Parses a string, URL, or Endpoint into it’s Endpoint URL components.
+ */
+export declare const parseURL: (value: string | URL | Endpoint) => EndpointURL | null;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/lib/split.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The split function divides a string into an array of substrings based on a non-empty delimiter.
+ * The behavior is controlled by the limit parameter:
+ *
+ * limit = 0: Split all occurrences (unlimited).
+ * limit = 1: No split performed (returns original string as single element array).
+ * limit > 1: Split into at most 'limit' parts (performs limit-1 splits).
+ *
+ * @internal
+ */
+export declare function split(value: string, delimiter: string, limit: number): string[];

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/lib/stringEquals.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Evaluates two string values value1 and value2 for equality and returns
+ * true if both values match.
+ */
+export declare const stringEquals: (value1: string, value2: string) => boolean;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/lib/substring.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Computes the substring of a given string, conditionally indexing from the end of the string.
+ * When the string is long enough to fully include the substring, return the substring.
+ * Otherwise, return None. The start index is inclusive and the stop index is exclusive.
+ * The length of the returned string will always be stop-start.
+ */
+export declare const substring: (input: string, start: number, stop: number, reverse: boolean) => string | null;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/lib/uriEncode.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Performs percent-encoding per RFC3986 section 2.1
+ */
+export declare const uriEncode: (value: string) => string;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/resolveEndpoint.d.ts

@@ -0,0 +1,6 @@
+import { EndpointV2 } from "@smithy/types";
+import { EndpointResolverOptions, RuleSetObject } from "./types";
+/**
+ * Resolves an endpoint URL by processing the endpoints ruleset and options.
+ */
+export declare const resolveEndpoint: (ruleSetObject: RuleSetObject, options: EndpointResolverOptions) => EndpointV2;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/types/EndpointError.d.ts

@@ -0,0 +1,3 @@
+export declare class EndpointError extends Error {
+    constructor(message: string);
+}

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/types/EndpointFunctions.d.ts

@@ -0,0 +1,2 @@
+import { FunctionReturn } from "./shared";
+export type EndpointFunctions = Record<string, (...args: any[]) => FunctionReturn>;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/types/EndpointRuleObject.d.ts

@@ -0,0 +1,5 @@
+import { EndpointObject as __EndpointObject, EndpointObjectHeaders as __EndpointObjectHeaders, EndpointObjectProperties as __EndpointObjectProperties, EndpointRuleObject as __EndpointRuleObject } from "@smithy/types";
+export type EndpointObjectProperties = __EndpointObjectProperties;
+export type EndpointObjectHeaders = __EndpointObjectHeaders;
+export type EndpointObject = __EndpointObject;
+export type EndpointRuleObject = __EndpointRuleObject;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/types/ErrorRuleObject.d.ts

@@ -0,0 +1,2 @@
+import { ErrorRuleObject as __ErrorRuleObject } from "@smithy/types";
+export type ErrorRuleObject = __ErrorRuleObject;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/types/RuleSetObject.d.ts

@@ -0,0 +1,4 @@
+import { DeprecatedObject as __DeprecatedObject, ParameterObject as __ParameterObject, RuleSetObject as __RuleSetObject } from "@smithy/types";
+export type DeprecatedObject = __DeprecatedObject;
+export type ParameterObject = __ParameterObject;
+export type RuleSetObject = __RuleSetObject;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/types/TreeRuleObject.d.ts

@@ -0,0 +1,3 @@
+import { RuleSetRules as __RuleSetRules, TreeRuleObject as __TreeRuleObject } from "@smithy/types";
+export type RuleSetRules = __RuleSetRules;
+export type TreeRuleObject = __TreeRuleObject;

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/types/index.d.ts

@@ -0,0 +1,7 @@
+export { EndpointError } from "./EndpointError";
+export { EndpointFunctions } from "./EndpointFunctions";
+export { EndpointObject, EndpointObjectHeaders, EndpointObjectProperties, EndpointRuleObject, } from "./EndpointRuleObject";
+export { ErrorRuleObject } from "./ErrorRuleObject";
+export { DeprecatedObject, ParameterObject, RuleSetObject } from "./RuleSetObject";
+export { RuleSetRules, TreeRuleObject } from "./TreeRuleObject";
+export { ConditionObject, EndpointParams, EndpointResolverOptions, EvaluateOptions, Expression, FunctionArgv, FunctionObject, FunctionReturn, ReferenceObject, ReferenceRecord, } from "./shared";

package/node_modules/@smithy/core/dist-types/ts3.4/submodules/endpoints/util-endpoints/types/shared.d.ts

@@ -0,0 +1,25 @@
+import { EndpointARN, EndpointPartition, EndpointURL, Logger } from "@smithy/types";
+export type ReferenceObject = {
+    ref: string;
+};
+export type FunctionObject = {
+    fn: string;
+    argv: FunctionArgv;
+};
+export type FunctionArgv = Array<Expression | boolean | number>;
+export type FunctionReturn = string | boolean | number | EndpointARN | EndpointPartition | EndpointURL | {
+    [key: string]: FunctionReturn;
+} | Array<FunctionReturn> | null;
+export type ConditionObject = FunctionObject & {
+    assign?: string;
+};
+export type Expression = string | ReferenceObject | FunctionObject;
+export type EndpointParams = Record<string, string | boolean>;
+export type EndpointResolverOptions = {
+    endpointParams: EndpointParams;
+    logger?: Logger;
+};
+export type ReferenceRecord = Record<string, FunctionReturn>;
+export type EvaluateOptions = EndpointResolverOptions & {
+    referenceRecord: ReferenceRecord;
+};

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

@@ -0,0 +1 @@
+export { callFunction } from "./evaluateExpression";

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

@@ -0,0 +1,4 @@
+import { EndpointFunctions } from "../types/EndpointFunctions";
+export declare const customEndpointFunctions: {
+    [key: string]: EndpointFunctions;
+};

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

@@ -0,0 +1,2 @@
+import { EndpointFunctions } from "../types";
+export declare const endpointFunctions: EndpointFunctions;

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

@@ -0,0 +1,11 @@
+import { ConditionObject, EvaluateOptions } from "../types";
+export declare const evaluateCondition: (condition: ConditionObject, options: EvaluateOptions) => {
+    result: boolean;
+    toAssign: {
+        name: string;
+        value: import("../types").FunctionReturn;
+    };
+} | {
+    result: boolean;
+    toAssign?: undefined;
+};

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

@@ -0,0 +1,8 @@
+import { ConditionObject, EvaluateOptions, FunctionReturn } from "../types";
+export declare const evaluateConditions: (conditions: ConditionObject[] | undefined, options: EvaluateOptions) => {
+    result: boolean;
+    referenceRecord: Record<string, FunctionReturn>;
+} | {
+    result: boolean;
+    referenceRecord?: undefined;
+};