@openstax/ts-utils 1.33.0 → 1.34.0

package/packages/utils/src/services/searchProvider/openSearch.ts

@@ -0,0 +1,195 @@
+// cspell:ignore opensearch, Sigv
+import { defaultProvider } from '@aws-sdk/credential-provider-node';
+import { Client, RequestParams } from '@opensearch-project/opensearch';
+import { SearchResponse } from '@opensearch-project/opensearch/api/types';
+import { AwsSigv4Signer } from '@opensearch-project/opensearch/aws';
+import { RequestBody, RequestNDBody } from '@opensearch-project/opensearch/lib/Transport';
+import { ConfigProviderForConfig, resolveConfigValue } from '../../config';
+import { ifDefined, isDefined } from '../../guards';
+import { once } from '../../misc/helpers';
+import { FieldMappings, Filter, IndexOptions, SearchOptions } from '.';
+
+export type Config = {
+  node: string;
+  region: string;
+};
+
+export interface Initializer<C> {
+  configSpace?: C;
+}
+
+export type IndexConfig = {
+  name: string;
+  mappings: FieldMappings;
+  pageSize?: number;
+};
+
+const mapFilter = (filter: Filter) => {
+  if ('key' in filter && 'value' in filter) {
+    const { key } = filter;
+    const values = filter.value instanceof Array ? filter.value : [filter.value];
+    return { terms: {[key]: values} };
+  } else {
+    return filter;
+  }
+};
+
+export const openSearchService = <C extends string = 'deployed'>(initializer: Initializer<C> = {}) =>
+  (configProvider: {[_key in C]: ConfigProviderForConfig<Config>}) => {
+    const config = configProvider[ifDefined(initializer.configSpace, 'deployed' as C)];
+    const client = once(async() => new Client({
+      ...AwsSigv4Signer({
+        getCredentials: () => defaultProvider()(),
+        region: await resolveConfigValue(config.region),
+        service: 'es',
+      }),
+      maxRetries: 4, // default is 3
+      requestTimeout: 5000, // default is 30000
+      pingTimeout: 2000, // default is 30000
+      node: await resolveConfigValue(config.node),
+    }));
+
+    return <T>(indexConfig: IndexConfig) => {
+      const pageSize = indexConfig.pageSize || 10;
+
+      const deleteIndexIfExists = async() => {
+        const { indices } = await client();
+        const index = indexConfig.name;
+        const { body } = await indices.exists({ index });
+
+        if (body) {
+          await indices.delete({ index });
+        }
+      };
+
+      const ensureIndexCreated = async() => {
+        const { indices } = await client();
+        const index = indexConfig.name;
+        const { body } = await indices.exists({ index });
+
+        if (!body) {
+          await indices.create({
+            index,
+            body: {
+              mappings: {
+                dynamic: false,
+                properties: indexConfig.mappings
+              }
+            }
+          });
+        }
+      };
+
+      const index = async (params: IndexOptions<T>) => {
+        const openSearchClient = await client();
+
+        await openSearchClient.index({
+          index: indexConfig.name,
+          body: params.body as RequestBody,
+          id: params.id,
+          refresh: true
+        }, {
+          requestTimeout: 10000,
+          maxRetries: 1,
+        });
+      };
+
+      const bulkIndex = async (items: IndexOptions<T>[]) => {
+        const openSearchClient = await client();
+        await openSearchClient.bulk({
+          index: indexConfig.name,
+          body: items.flatMap((item) => [
+            { index: { _id: item.id } },
+            item.body
+          ]) as RequestNDBody,
+          refresh: true
+        }, {
+          requestTimeout: 10000,
+          maxRetries: 1,
+        });
+      };
+
+      const search = async(options: SearchOptions) => {
+        const body: RequestParams.Search['body'] = {
+          query: { bool: {} },
+          track_total_hits: true,
+          size: pageSize
+        };
+
+        if (options.query) {
+          body.query.bool.must = [{
+            multi_match: {
+              fields: options.fields.map((field) => 'weight' in field ? `${field.key}^${field.weight}` : field.key),
+              query: options.query
+            }
+          }];
+        }
+
+        const {must_not, should, must, filter} = options;
+
+        if (filter && filter.length > 0) {
+          body.query.bool.filter = filter.map(mapFilter);
+        }
+
+        if (must && must.length > 0) {
+          body.query.bool.must ||= [];
+          body.query.bool.must = body.query.bool.must.concat(must.map(mapFilter));
+        }
+
+        if (must_not && must_not.length > 0) {
+          body.query.bool.must_not = must_not.map(mapFilter);
+        }
+
+        if (should && should.length > 0) {
+          body.query.bool.should = should.map(mapFilter);
+          body.query.bool.minimum_should_match = 1;
+        }
+
+        if (options.sort && options.sort.length > 0) {
+          body.sort = options.sort.map(sort => ({
+            [sort.key]: { order: sort.order }
+          }));
+        }
+
+        if (options.page) {
+          body.from = (options.page - 1) * pageSize;
+        }
+
+        const response = await (await client()).search<SearchResponse<T>>({
+          body,
+          index: indexConfig.name
+        });
+
+        if (response.statusCode !== 200) {
+          throw new Error(`Unexpected status code: ${response.statusCode} from OpenSearch`);
+        }
+
+        const hits = response.body.hits;
+
+        const items = hits.hits.map((hit) => hit._source).filter(isDefined);
+
+        const currentPage = options.page || 1;
+        const { total } = hits;
+        const totalItems = typeof total === 'number' ? total : total.value;
+        const totalPages = Math.ceil(totalItems / pageSize) || 1;
+
+        return { items, pageSize, currentPage, totalItems, totalPages };
+      };
+
+      const updateMappings = async () => {
+        const { indices } = await client();
+
+        await indices.putMapping({
+          index: indexConfig.name,
+          body: {
+            properties: indexConfig.mappings
+          }
+        }, {
+          requestTimeout: 10000,
+          maxRetries: 1,
+        });
+      };
+
+      return { ensureIndexCreated, deleteIndexIfExists, index, bulkIndex, search, updateMappings };
+    };
+  };

package/{dist/esm/types.d.ts → packages/utils/src/types.ts}

@@ -6,26 +6,54 @@
  *
  * There may be a better way to do this; `T1 extends T2` doesn't work
  */
-export type TupleExtends<T1, T2> = T1 extends [infer T1Head, ...infer T1Tail] ? T2 extends [infer T2Head, ...infer T2Tail] ? T1Head extends T2Head ? TupleExtends<T1Tail, T2Tail> extends 'yes' ? 'yes' : 'no' : 'no' : T2 extends [] ? 'yes' : 'no' : T1 extends [] ? T2 extends [] ? 'yes' : 'no' : 'no';
+export type TupleExtends<T1, T2> = T1 extends [infer T1Head, ...infer T1Tail]
+  ? T2 extends [infer T2Head, ...infer T2Tail]
+    ? T1Head extends T2Head
+      ? TupleExtends<T1Tail, T2Tail> extends 'yes'
+        ? 'yes'
+        : 'no'
+      : 'no'
+    : T2 extends []
+      ? 'yes'
+      : 'no'
+  : T1 extends []
+    ? T2 extends []
+      ? 'yes'
+      : 'no'
+    : 'no'
+;
+
 /**
  * unions each member of the tuple
  */
-export type TupleZip<T1, T2> = T1 extends [infer T1Head, ...infer T1Tail] ? T2 extends [infer T2Head, ...infer T2Tail] ? [T1Head & T2Head, ...TupleZip<T1Tail, T2Tail>] : T2 extends [] ? T1 : never : T1 extends [] ? T2 extends any[] ? T2 : never : never;
+export type TupleZip<T1, T2> = T1 extends [infer T1Head, ...infer T1Tail]
+  ? T2 extends [infer T2Head, ...infer T2Tail]
+    ? [T1Head & T2Head, ...TupleZip<T1Tail, T2Tail>]
+    : T2 extends []
+      ? T1
+      : never
+  : T1 extends []
+    ? T2 extends any[]
+      ? T2
+      : never
+    : never
+;
+
 /**
  * If `R` is `Promise<I>`, returns `I`, otherwise returns `R`
  * @deprecated use TypeScript builtin Awaited instead:
  * @see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-5.html#the-awaited-type-and-promise-improvements
  */
 export type UnwrapPromise<R> = R extends Promise<infer I> ? I : R;
+
 /**
  * turns `thing | thing2` into `thing & thing2`
  * @see https://stackoverflow.com/a/50375286/14809536
  */
-export type UnionToIntersection<U> = (U extends any ? (k: U) => void : never) extends ((k: infer I) => void) ? I : never;
+export type UnionToIntersection<U> = (U extends any ? (k: U)=>void : never) extends ((k: infer I)=>void) ? I : never;
+
 /**
  * make certain fields required
  * @see https://stackoverflow.com/a/69328045/14809536
  */
-export type WithRequired<T, K extends keyof T> = T & {
-    [P in K]-?: T[P];
-};
+export type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] };

package/packages/utils/tsconfig.json

@@ -0,0 +1,31 @@
+{
+  "compilerOptions": {
+    "incremental": true,
+    "allowJs": false,
+    "allowSyntheticDefaultImports": true,
+    "alwaysStrict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+    "module": "commonjs",
+    "moduleResolution": "node",
+    "noEmit": true,
+    "noImplicitAny": true,
+    "listEmittedFiles": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "target": "es2019",
+    "lib": [
+      "es2020"
+    ],
+    "noFallthroughCasesInSwitch": true,
+    "outDir": "dist",
+    "declaration": true
+  },
+  "include": [
+    "src"
+  ]
+}

package/packages/utils/tsconfig.without-specs.cjs.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.without-specs",
+  "compilerOptions": {
+    "module": "commonjs",
+    "outDir": "dist/cjs"
+  }
+}

package/packages/utils/tsconfig.without-specs.esm.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.without-specs",
+  "compilerOptions": {
+    "module": "es6",
+    "outDir": "dist/esm"
+  }
+}

package/packages/utils/tsconfig.without-specs.json

@@ -0,0 +1,6 @@
+{
+  "extends": "./tsconfig",
+  "exclude": [
+    "**/*.spec.ts"
+  ]
+}

package/scripts/build.bash

@@ -0,0 +1,24 @@
+#!/usr/bin/env bash
+# spell-checker: ignore pipefail
+set -euo pipefail; if [ -n "${DEBUG-}" ]; then set -x; fi
+
+project_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )/.." >/dev/null 2>&1 && pwd )"
+
+cd "$project_dir"
+
+# packages that must be built before other ones (in this order)
+# trying to be graceful about the template being copied and packages
+# getting removed without requiring updating the world
+build_order=()
+test -d ./packages/utils/ && build_order+=("@openstax/ts-utils")
+test -d ./packages/lambda/ && build_order+=("@project/lambdas")
+
+# all other packages
+all_packages=$(yarn --silent workspaces info | node -e "process.stdout.write(Object.keys(JSON.parse(require('fs').readFileSync('/dev/stdin').toString())).join(' '))")
+remaining_packages=$(echo "${build_order[@]}" "$all_packages" | tr ' ' '\n' | sort | uniq -u)
+
+# build em
+for package in "${build_order[@]}" $remaining_packages; do
+  echo "building $package ..."
+  yarn workspace "$package" build:clean
+done

package/scripts/ci.bash

@@ -0,0 +1,10 @@
+#!/usr/bin/env bash
+# spell-checker: ignore pipefail
+set -euo pipefail; if [ -n "${DEBUG-}" ]; then set -x; fi
+
+project_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )/.." >/dev/null 2>&1 && pwd )"
+
+cd "$project_dir"
+
+yarn build
+yarn workspaces run ci

package/scripts/start.bash

@@ -0,0 +1,29 @@
+#!/usr/bin/env bash
+# spell-checker: ignore pipefail SIGINT
+set -euo pipefail; if [ -n "${DEBUG-}" ]; then set -x; fi
+
+project_dir="$( cd "$( dirname "${BASH_SOURCE[0]}" )/.." >/dev/null 2>&1 && pwd )"
+
+cd "$project_dir"
+
+source $(yarn -s ts-utils which init-constants-script)
+
+./scripts/build.bash
+
+all_packages=$(yarn --silent workspaces info | node -e "process.stdout.write(Object.keys(JSON.parse(require('fs').readFileSync('/dev/stdin').toString())).join(' '))")
+
+function start() {
+  # looping instead of running `yarn workspaces run start`
+  # so that each command can be sent to background
+  for package in $all_packages; do
+    echo "checking startup commands in $package ..."
+    yarn --silent workspace "$package" run data:seed 2>&1 || true
+    echo "starting $package ..."
+    yarn workspace "$package" start &
+  done
+
+  # wait for ctrl-c
+  read -r -d '' _ </dev/tty
+}
+
+(trap 'kill 0' SIGINT EXIT; start)

package/dist/cjs/assertions/index.d.ts

@@ -1,89 +0,0 @@
-export type AssertionFailed = string | Error | (() => never) | undefined;
-export declare const doThrow: (failed: AssertionFailed) => never;
-/**
- * Asserts that the given value is true.
- *
- * @param x The value to assert.
- * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
- *  to provide some value for this for traceability. Passing an Error instead of a string
- *  makes the stack trace more useful and allows you to handle assertion failures differently.
- * @example const definitelyTrue = assertTrue(randomThing, new Error('thing was not true'));
- * @returns the value that was asserted
- */
-export declare const assertTrue: <X>(x: X, failed?: AssertionFailed) => X & true;
-/**
- * Asserts that the given value is false.
- *
- * @param x The value to assert.
- * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
- *  to provide some value for this for traceability. Passing an Error instead of a string
- *  makes the stack trace more useful and allows you to handle assertion failures differently.
- * @example const definitelyFalse = assertFalse(randomThing, new Error('thing was not false'));
- * @returns the value that was asserted
- */
-export declare const assertFalse: <X>(x: X, failed?: AssertionFailed) => X & false;
-/**
- * Asserts that the given value is defined.
- *
- * @param x The value to assert.
- * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
- *  to provide some value for this for traceability. Passing an Error instead of a string
- *  makes the stack trace more useful and allows you to handle assertion failures differently.
- * @example const definitelyDefined = assertDefined(randomThing, new Error('thing was undefined'));
- * @returns the value that was asserted, with a type that excludes undefined
- */
-export declare const assertDefined: <X>(x: X, failed?: AssertionFailed) => Exclude<X, undefined>;
-/**
- * Asserts that the given value is a string.
- *
- * @param x The value to assert.
- * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
- *  to provide some value for this for traceability. Passing an Error instead of a string
- *  makes the stack trace more useful and allows you to handle assertion failures differently.
- * @example const definitelyAString = assertString(randomThing, new Error('thing is not a string'));
- * @returns the value that was asserted
- */
-export declare const assertString: <X>(x: X, failed?: AssertionFailed) => string;
-/**
- * Asserts that the given value is not `NaN`. Does not assert that the value is a number.
- *
- * @param thing The value to assert.
- * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
- *  to provide some value for this for traceability. Passing an Error instead of a string
- *  makes the stack trace more useful and allows you to handle assertion failures differently.
- * @example const definitelyNotNotANumber = assertNotNaN(randomThing, new Error('thing was NaN'));
- * @returns the value that was asserted
- */
-export declare const assertNotNaN: <T>(thing: T, failed?: AssertionFailed) => T;
-/**
- * @deprecated use assertNotNaN instead
- */
-export declare const notNaN: <T>(thing: T, failed?: AssertionFailed) => T;
-/**
- * Asserts that the first argument is an instance of the second.
- *
- * @param thing The value to assert.
- * @param constructable The class to check against.
- * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
- *  to provide some value for this for traceability. Passing an Error instead of a string
- *  makes the stack trace more useful and allows you to handle assertion failures differently.
- * @example const definitelySyntaxError = assertInstanceOf(error, SyntaxError, new Error('argument was not a SyntaxError'));
- * @returns the value that was asserted
- */
-export declare const assertInstanceOf: <T>(thing: any, constructable: Function & {
-    new (...args: any[]): T;
-}, failed?: AssertionFailed) => T;
-/**
- * Asserts that the error in the first argument is an instance of the error given as the
- * second argument
- *
- * @param thing The value to assert.
- * @param constructable The error class to check against.
- * @example const definitelySyntaxError = assertInstanceOf(error, SyntaxError);
- * @returns the value that was asserted
- * @throws the original error if the check fails
- * @see assertInstanceOf
- */
-export declare const assertErrorInstanceOf: <T extends Error>(thing: unknown, constructable: Function & {
-    new (...args: any[]): T;
-}) => T;

package/dist/cjs/assertions/index.js

@@ -1,157 +0,0 @@
-"use strict";
-/*
- * all of these assertions take either a string, throw function, or nothing
- * for the second argument. its STRONGLY encouraged to provide some error
- * or message that explains the reason for the assertion
- *
- * eg:
- *   assertDefined(user, new UnauthorizedException())
- *   assertDefined(thing.otherThing, 'otherThing should be guaranteed to exist, but is missing')
- *
- * passing an Error instead of a string makes the first element of the resulting
- * stack trace more useful, and allows you to use specific error types
- * that might be handled differently.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.assertErrorInstanceOf = exports.assertInstanceOf = exports.notNaN = exports.assertNotNaN = exports.assertString = exports.assertDefined = exports.assertFalse = exports.assertTrue = exports.doThrow = void 0;
-const doThrow = (failed) => {
-    if (typeof failed === 'string') {
-        throw new Error(failed);
-    }
-    if (failed instanceof Error) {
-        throw failed;
-    }
-    if (!failed) {
-        throw new Error();
-    }
-    return failed();
-};
-exports.doThrow = doThrow;
-/**
- * Asserts that the given value is true.
- *
- * @param x The value to assert.
- * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
- *  to provide some value for this for traceability. Passing an Error instead of a string
- *  makes the stack trace more useful and allows you to handle assertion failures differently.
- * @example const definitelyTrue = assertTrue(randomThing, new Error('thing was not true'));
- * @returns the value that was asserted
- */
-const assertTrue = (x, failed) => {
-    if (typeof x !== 'boolean' || x !== true) {
-        return (0, exports.doThrow)(failed);
-    }
-    return x;
-};
-exports.assertTrue = assertTrue;
-/**
- * Asserts that the given value is false.
- *
- * @param x The value to assert.
- * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
- *  to provide some value for this for traceability. Passing an Error instead of a string
- *  makes the stack trace more useful and allows you to handle assertion failures differently.
- * @example const definitelyFalse = assertFalse(randomThing, new Error('thing was not false'));
- * @returns the value that was asserted
- */
-const assertFalse = (x, failed) => {
-    if (typeof x !== 'boolean' || x !== false) {
-        return (0, exports.doThrow)(failed);
-    }
-    return x;
-};
-exports.assertFalse = assertFalse;
-/**
- * Asserts that the given value is defined.
- *
- * @param x The value to assert.
- * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
- *  to provide some value for this for traceability. Passing an Error instead of a string
- *  makes the stack trace more useful and allows you to handle assertion failures differently.
- * @example const definitelyDefined = assertDefined(randomThing, new Error('thing was undefined'));
- * @returns the value that was asserted, with a type that excludes undefined
- */
-const assertDefined = (x, failed) => {
-    if (x === undefined) {
-        return (0, exports.doThrow)(failed);
-    }
-    return x;
-};
-exports.assertDefined = assertDefined;
-/**
- * Asserts that the given value is a string.
- *
- * @param x The value to assert.
- * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
- *  to provide some value for this for traceability. Passing an Error instead of a string
- *  makes the stack trace more useful and allows you to handle assertion failures differently.
- * @example const definitelyAString = assertString(randomThing, new Error('thing is not a string'));
- * @returns the value that was asserted
- */
-const assertString = (x, failed) => {
-    if (typeof x !== 'string') {
-        return (0, exports.doThrow)(failed);
-    }
-    return x;
-};
-exports.assertString = assertString;
-/**
- * Asserts that the given value is not `NaN`. Does not assert that the value is a number.
- *
- * @param thing The value to assert.
- * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
- *  to provide some value for this for traceability. Passing an Error instead of a string
- *  makes the stack trace more useful and allows you to handle assertion failures differently.
- * @example const definitelyNotNotANumber = assertNotNaN(randomThing, new Error('thing was NaN'));
- * @returns the value that was asserted
- */
-const assertNotNaN = (thing, failed) => {
-    if (typeof thing === 'number' && isNaN(thing)) {
-        return (0, exports.doThrow)(failed);
-    }
-    return thing;
-};
-exports.assertNotNaN = assertNotNaN;
-/**
- * @deprecated use assertNotNaN instead
- */
-exports.notNaN = exports.assertNotNaN;
-/**
- * Asserts that the first argument is an instance of the second.
- *
- * @param thing The value to assert.
- * @param constructable The class to check against.
- * @param failed The error to throw if the assertion fails. It is STRONGLY encouraged
- *  to provide some value for this for traceability. Passing an Error instead of a string
- *  makes the stack trace more useful and allows you to handle assertion failures differently.
- * @example const definitelySyntaxError = assertInstanceOf(error, SyntaxError, new Error('argument was not a SyntaxError'));
- * @returns the value that was asserted
- */
-const assertInstanceOf = (thing, constructable, failed) => {
-    if (thing instanceof constructable) {
-        return thing;
-    }
-    return (0, exports.doThrow)(failed);
-};
-exports.assertInstanceOf = assertInstanceOf;
-/**
- * Asserts that the error in the first argument is an instance of the error given as the
- * second argument
- *
- * @param thing The value to assert.
- * @param constructable The error class to check against.
- * @example const definitelySyntaxError = assertInstanceOf(error, SyntaxError);
- * @returns the value that was asserted
- * @throws the original error if the check fails
- * @see assertInstanceOf
- */
-const assertErrorInstanceOf = (thing, constructable) => {
-    if (thing instanceof Error) {
-        return (0, exports.assertInstanceOf)(thing, constructable, thing);
-    }
-    else {
-        // this separate branch prevents an unknown non-Error thing from being passed to the assertion as an AssertionFailed
-        throw new Error(`assertErrorInstanceOf received non-Error argument of type "${typeof thing}" and string representation "${thing}"`);
-    }
-};
-exports.assertErrorInstanceOf = assertErrorInstanceOf;

package/dist/cjs/aws/ssmService.d.ts

@@ -1,5 +0,0 @@
-import { SSM } from '@aws-sdk/client-ssm';
-/**
- * A memoized instance of the AWS SSM client.
- */
-export declare const ssmService: () => SSM;

package/dist/cjs/aws/ssmService.js

@@ -1,9 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ssmService = void 0;
-const client_ssm_1 = require("@aws-sdk/client-ssm");
-const __1 = require("..");
-/**
- * A memoized instance of the AWS SSM client.
- */
-exports.ssmService = (0, __1.once)(() => new client_ssm_1.SSM({ apiVersion: '2012-08-10' }));

package/dist/cjs/config/awsParameterConfig.d.ts

@@ -1,10 +0,0 @@
-import { ConfigValueProvider } from '.';
-/**
- * Returns a value from the AWS Parameter Store.
- *
- * @param parameterName the name of the parameter; can be a literal name (string) or can itself
- * be accessed via another parameter by giving a configuration value provider.
- * @example const someValue = resolveConfig(awsParameterConfig('some-parameter-name'));
- * @returns the configuration value provider for the value
- */
-export declare const awsParameterConfig: (parameterName: ConfigValueProvider<string>) => ConfigValueProvider<string>;