@aws/cloudformation-validate 1.8.0-beta → 1.10.0

package/bindings_wasm.js

@@ -48,18 +48,92 @@ class WasmCelEngine {
         WasmCelEngineFinalization.register(this, this.__wbg_ptr, this);
         return this;
     }
+    /**
+     * @param {any} request
+     * @returns {any}
+     */
+    validateAwsCliCommand(request) {
+        const ret = wasm.wasmcelengine_validateAwsCliCommand(this.__wbg_ptr, request);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
     /**
      * @param {Uint8Array} template
      * @param {ValidateConfig} options
      * @param {string} file_path
      * @returns {any}
      */
-    validateDetailed(template, options, file_path) {
+    validateTemplate(template, options, file_path) {
         const ptr0 = passArray8ToWasm0(template, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(file_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmcelengine_validateDetailed(this.__wbg_ptr, ptr0, len0, options, ptr1, len1);
+        const ret = wasm.wasmcelengine_validateTemplate(this.__wbg_ptr, ptr0, len0, options, ptr1, len1);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+}
+if (Symbol.dispose) WasmCelEngine.prototype[Symbol.dispose] = WasmCelEngine.prototype.free;
+exports.WasmCelEngine = WasmCelEngine;
+
+class WasmCompositeEngine {
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        WasmCompositeEngineFinalization.unregister(this);
+        return ptr;
+    }
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_wasmcompositeengine_free(ptr, 0);
+    }
+    /**
+     * @returns {string}
+     */
+    engineName() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.wasmcompositeengine_engineName(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
+    /**
+     * @returns {any}
+     */
+    listRules() {
+        const ret = wasm.wasmcompositeengine_listRules(this.__wbg_ptr);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return takeFromExternrefTable0(ret[0]);
+    }
+    /**
+     * @param {CompositeEngineConfig} config
+     */
+    constructor(config) {
+        const ret = wasm.wasmcompositeengine_new(config);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        this.__wbg_ptr = ret[0];
+        WasmCompositeEngineFinalization.register(this, this.__wbg_ptr, this);
+        return this;
+    }
+    /**
+     * @param {any} request
+     * @returns {any}
+     */
+    validateAwsCliCommand(request) {
+        const ret = wasm.wasmcompositeengine_validateAwsCliCommand(this.__wbg_ptr, request);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -71,20 +145,20 @@ class WasmCelEngine {
      * @param {string} file_path
      * @returns {any}
      */
-    validateStandard(template, options, file_path) {
+    validateTemplate(template, options, file_path) {
         const ptr0 = passArray8ToWasm0(template, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(file_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmcelengine_validateStandard(this.__wbg_ptr, ptr0, len0, options, ptr1, len1);
+        const ret = wasm.wasmcompositeengine_validateTemplate(this.__wbg_ptr, ptr0, len0, options, ptr1, len1);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
         return takeFromExternrefTable0(ret[0]);
     }
 }
-if (Symbol.dispose) WasmCelEngine.prototype[Symbol.dispose] = WasmCelEngine.prototype.free;
-exports.WasmCelEngine = WasmCelEngine;
+if (Symbol.dispose) WasmCompositeEngine.prototype[Symbol.dispose] = WasmCompositeEngine.prototype.free;
+exports.WasmCompositeEngine = WasmCompositeEngine;
 
 class WasmRegoEngine {
     __destroy_into_raw() {
@@ -135,17 +209,11 @@ class WasmRegoEngine {
         return this;
     }
     /**
-     * @param {Uint8Array} template
-     * @param {ValidateConfig} options
-     * @param {string} file_path
+     * @param {any} request
      * @returns {any}
      */
-    validateDetailed(template, options, file_path) {
-        const ptr0 = passArray8ToWasm0(template, wasm.__wbindgen_malloc);
-        const len0 = WASM_VECTOR_LEN;
-        const ptr1 = passStringToWasm0(file_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
-        const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmregoengine_validateDetailed(this.__wbg_ptr, ptr0, len0, options, ptr1, len1);
+    validateAwsCliCommand(request) {
+        const ret = wasm.wasmregoengine_validateAwsCliCommand(this.__wbg_ptr, request);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -157,12 +225,12 @@ class WasmRegoEngine {
      * @param {string} file_path
      * @returns {any}
      */
-    validateStandard(template, options, file_path) {
+    validateTemplate(template, options, file_path) {
         const ptr0 = passArray8ToWasm0(template, wasm.__wbindgen_malloc);
         const len0 = WASM_VECTOR_LEN;
         const ptr1 = passStringToWasm0(file_path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
         const len1 = WASM_VECTOR_LEN;
-        const ret = wasm.wasmregoengine_validateStandard(this.__wbg_ptr, ptr0, len0, options, ptr1, len1);
+        const ret = wasm.wasmregoengine_validateTemplate(this.__wbg_ptr, ptr0, len0, options, ptr1, len1);
         if (ret[2]) {
             throw takeFromExternrefTable0(ret[1]);
         }
@@ -401,6 +469,12 @@ function __wbg_get_imports() {
             getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
             getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
         },
+        __wbg___wbindgen_bigint_get_as_i64_d968e41184ae354f: function (arg0, arg1) {
+            const v = arg1;
+            const ret = typeof v === 'bigint' ? v : undefined;
+            getDataViewMemory0().setBigInt64(arg0 + 8 * 1, isLikeNone(ret) ? BigInt(0) : ret, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, !isLikeNone(ret), true);
+        },
         __wbg___wbindgen_boolean_get_fa956cfa2d1bd751: function (arg0) {
             const v = arg0;
             const ret = typeof v === 'boolean' ? v : undefined;
@@ -417,6 +491,10 @@ function __wbg_get_imports() {
             const ret = arg0 in arg1;
             return ret;
         },
+        __wbg___wbindgen_is_bigint_2f76dc55065b4273: function (arg0) {
+            const ret = typeof arg0 === 'bigint';
+            return ret;
+        },
         __wbg___wbindgen_is_function_1ff95bcc5517c252: function (arg0) {
             const ret = typeof arg0 === 'function';
             return ret;
@@ -434,6 +512,10 @@ function __wbg_get_imports() {
             const ret = arg0 === undefined;
             return ret;
         },
+        __wbg___wbindgen_jsval_eq_e659fcf7b0e32763: function (arg0, arg1) {
+            const ret = arg0 === arg1;
+            return ret;
+        },
         __wbg___wbindgen_jsval_loose_eq_db4c3b15f63fc170: function (arg0, arg1) {
             const ret = arg0 == arg1;
             return ret;
@@ -485,6 +567,10 @@ function __wbg_get_imports() {
                 globalThis.crypto.getRandomValues(getArrayU8FromWasm0(arg0, arg1));
             }, arguments);
         },
+        __wbg_getTime_d6f070c088c9b5ed: function (arg0) {
+            const ret = arg0.getTime();
+            return ret;
+        },
         __wbg_get_507a50627bffa49b: function (arg0, arg1) {
             const ret = arg0[arg1 >>> 0];
             return ret;
@@ -513,6 +599,16 @@ function __wbg_get_imports() {
             const ret = result;
             return ret;
         },
+        __wbg_instanceof_Map_e5b5e3db98422fcc: function (arg0) {
+            let result;
+            try {
+                result = arg0 instanceof Map;
+            } catch (_) {
+                result = false;
+            }
+            const ret = result;
+            return ret;
+        },
         __wbg_instanceof_Uint8Array_309b927aaf7a3fc7: function (arg0) {
             let result;
             try {
@@ -543,6 +639,10 @@ function __wbg_get_imports() {
             const ret = arg0.length;
             return ret;
         },
+        __wbg_new_0_3da9e97f24fc69be: function () {
+            const ret = new Date();
+            return ret;
+        },
         __wbg_new_227d7c05414eb861: function () {
             const ret = new Error();
             return ret;
@@ -661,6 +761,10 @@ const WasmCelEngineFinalization =
     typeof FinalizationRegistry === 'undefined'
         ? { register: () => {}, unregister: () => {} }
         : new FinalizationRegistry((ptr) => wasm.__wbg_wasmcelengine_free(ptr, 1));
+const WasmCompositeEngineFinalization =
+    typeof FinalizationRegistry === 'undefined'
+        ? { register: () => {}, unregister: () => {} }
+        : new FinalizationRegistry((ptr) => wasm.__wbg_wasmcompositeengine_free(ptr, 1));
 const WasmRegoEngineFinalization =
     typeof FinalizationRegistry === 'undefined'
         ? { register: () => {}, unregister: () => {} }

package/bindings_wasm_bg.wasm.d.ts

@@ -2,6 +2,7 @@
 /* eslint-disable */
 export const memory: WebAssembly.Memory;
 export const __wbg_wasmcelengine_free: (a: number, b: number) => void;
+export const __wbg_wasmcompositeengine_free: (a: number, b: number) => void;
 export const __wbg_wasmregoengine_free: (a: number, b: number) => void;
 export const __wbg_wasmschemavalidator_free: (a: number, b: number) => void;
 export const __wbg_wasmsemanticmodel_free: (a: number, b: number) => void;
@@ -10,7 +11,8 @@ export const version: () => [number, number];
 export const wasmcelengine_engineName: (a: number) => [number, number];
 export const wasmcelengine_listRules: (a: number) => [number, number, number];
 export const wasmcelengine_new: (a: any) => [number, number, number];
-export const wasmcelengine_validateDetailed: (
+export const wasmcelengine_validateAwsCliCommand: (a: number, b: any) => [number, number, number];
+export const wasmcelengine_validateTemplate: (
     a: number,
     b: number,
     c: number,
@@ -18,7 +20,11 @@ export const wasmcelengine_validateDetailed: (
     e: number,
     f: number,
 ) => [number, number, number];
-export const wasmcelengine_validateStandard: (
+export const wasmcompositeengine_engineName: (a: number) => [number, number];
+export const wasmcompositeengine_listRules: (a: number) => [number, number, number];
+export const wasmcompositeengine_new: (a: any) => [number, number, number];
+export const wasmcompositeengine_validateAwsCliCommand: (a: number, b: any) => [number, number, number];
+export const wasmcompositeengine_validateTemplate: (
     a: number,
     b: number,
     c: number,
@@ -29,15 +35,8 @@ export const wasmcelengine_validateStandard: (
 export const wasmregoengine_engineName: (a: number) => [number, number];
 export const wasmregoengine_listRules: (a: number) => [number, number, number];
 export const wasmregoengine_new: (a: any) => [number, number, number];
-export const wasmregoengine_validateDetailed: (
-    a: number,
-    b: number,
-    c: number,
-    d: any,
-    e: number,
-    f: number,
-) => [number, number, number];
-export const wasmregoengine_validateStandard: (
+export const wasmregoengine_validateAwsCliCommand: (a: number, b: any) => [number, number, number];
+export const wasmregoengine_validateTemplate: (
     a: number,
     b: number,
     c: number,

package/index.d.ts

@@ -1,5 +1,6 @@
 import type {
-    DetailedReport,
+    Diagnostic,
+    ValidationReport,
     DiagnosticModel,
     AdditionalSchemaSource,
     ExternalRuleSource,
@@ -8,8 +9,6 @@ import type {
     ResolvedResource,
     RuleInfo,
     SourceSpan,
-    StandardDiagnostic,
-    StandardReport,
     ValidateConfig,
 } from './bindings_wasm';
 export type {
@@ -29,14 +28,12 @@ export type {
     ResourceRef,
     RelatedResource,
     ViolationContext,
-    StandardDiagnostic,
-    DetailedDiagnostic,
+    Diagnostic,
     PhaseMetric,
     PerformanceMetrics,
     Summary,
     ReportMetadata,
-    StandardReport,
-    DetailedReport,
+    ValidationReport,
     PseudoParameterOverrides,
     ValidateConfig,
     ExternalRuleSource,
@@ -79,9 +76,55 @@ export type JsonValue =
     | {
           [key: string]: JsonValue;
       };
+export type AwsCliOperationKind =
+    | 'READ_ONLY'
+    | 'CLOUD_FORMATION_CREATE'
+    | 'CLOUD_FORMATION_UPDATE'
+    | 'CLOUD_FORMATION_DELETE'
+    | 'DATA_PLANE_MUTATION'
+    | 'UNMAPPED_MUTATION';
+export type AwsCliCommandValidationStatus = 'VALIDATED' | 'SKIPPED';
+export type AwsCliTemplateSource =
+    'TEMPLATE_BODY' | 'CLOUD_CONTROL_DESIRED_STATE' | 'SYNTHESIZED_CREATE' | 'SYNTHESIZED_UPDATE';
+export interface AwsCliCommandOptions {
+    servicePrefix?: string;
+    httpMethod?: string;
+    isReadOnly?: boolean;
+}
+/**
+ * Service, operation, and input values for one AWS CLI command.
+ *
+ * `serviceName` is the canonical botocore service name and is normalized only
+ * for ASCII case. Callers adapting an SDK request must translate its native
+ * service identity before constructing this request; endpoint and signing-name
+ * aliases are never guessed by the validation core.
+ */
+export declare class AwsCliCommand {
+    readonly serviceName: string;
+    readonly operationName: string;
+    readonly parameters: Record<string, unknown>;
+    readonly servicePrefix?: string;
+    readonly httpMethod?: string;
+    readonly isReadOnly?: boolean;
+    constructor(
+        serviceName: string,
+        operationName: string,
+        parameters: Record<string, unknown>,
+        options?: AwsCliCommandOptions,
+    );
+}
+export interface AwsCliCommandValidation {
+    operationKind: AwsCliOperationKind;
+    status: AwsCliCommandValidationStatus;
+    templateSource: AwsCliTemplateSource | null;
+    resourceTypes: string[];
+    reason: string;
+    report: ValidationReport | null;
+    template: Uint8Array | null;
+}
 export interface Engine {
-    validateStandard(template: TemplateFile, config?: ValidateConfig): StandardReport;
-    validateDetailed(template: TemplateFile, config?: ValidateConfig): DetailedReport;
+    validateTemplate(template: TemplateFile, config?: ValidateConfig): ValidationReport;
+    validateAwsCliCommand(request: AwsCliCommand): AwsCliCommandValidation;
     listRules(): RuleInfo[];
     engineName(): string;
     free(): void;
@@ -119,6 +162,24 @@ export interface EngineConfig {
      */
     schemaValidatorConfig?: SchemaValidatorConfig;
 }
+/**
+ * Configuration for the {@link CompositeEngine}. The built-in rules are always
+ * evaluated by the engine's fixed built-in evaluator, so these fields only layer
+ * external rules on top - there is no engine-native custom-rule field.
+ */
+export interface CompositeEngineConfig {
+    /** Custom Rego rules layered on top of the built-in rules. */
+    regoRules?: RuleSource[];
+    /** Custom CEL rules layered on top of the built-in rules. */
+    celRules?: RuleSource[];
+    /** CloudFormation Guard DSL rules layered on top of the built-in rules. */
+    guardRules?: RuleSource[];
+    /**
+     * Optional schema validator configuration, observed by both the built-in and
+     * external rule evaluation.
+     */
+    schemaValidatorConfig?: SchemaValidatorConfig;
+}
 /**
  * Configuration for the schema validator. Additional schemas are merged on top
  * of the bundled CloudFormation provider schemas before schema validation.
@@ -150,9 +211,10 @@ export declare class SchemaValidator {
     constructor(config?: SchemaValidatorConfig);
     listRules(): RuleInfo[];
     schemaCount(): number;
-    validate(template: TemplateFile, region?: string): StandardDiagnostic[];
+    validate(template: TemplateFile, region?: string): Diagnostic[];
     free(): void;
 }
 export declare const RegoEngine: new (config?: EngineConfig) => Engine;
 export declare const CelEngine: new (config?: EngineConfig) => Engine;
+export declare const CompositeEngine: new (config?: CompositeEngineConfig) => Engine;
 export declare function version(): string;

package/index.js

@@ -1,15 +1,203 @@
 'use strict';
 Object.defineProperty(exports, '__esModule', { value: true });
-exports.CelEngine =
+exports.CompositeEngine =
+    exports.CelEngine =
     exports.RegoEngine =
     exports.SchemaValidator =
     exports.TemplateModel =
     exports.SchemaFile =
     exports.RuleFile =
     exports.TemplateFile =
+    exports.AwsCliCommand =
         void 0;
 exports.version = version;
 const fs_1 = require('fs');
+/**
+ * Service, operation, and input values for one AWS CLI command.
+ *
+ * `serviceName` is the canonical botocore service name and is normalized only
+ * for ASCII case. Callers adapting an SDK request must translate its native
+ * service identity before constructing this request; endpoint and signing-name
+ * aliases are never guessed by the validation core.
+ */
+class AwsCliCommand {
+    constructor(serviceName, operationName, parameters, options = {}) {
+        this.serviceName = serviceName;
+        this.operationName = operationName;
+        if (!isPlainRecord(parameters)) {
+            throw new TypeError('parameters must be a plain object with string keys');
+        }
+        const copiedParameters = Object.create(null);
+        for (const key of Reflect.ownKeys(parameters)) {
+            if (typeof key !== 'string') {
+                throw new TypeError('request parameter names must be strings');
+            }
+            const descriptor = Object.getOwnPropertyDescriptor(parameters, key);
+            if (descriptor === undefined || !('value' in descriptor)) {
+                throw new TypeError(`request parameter ${JSON.stringify(key)} must be a value property`);
+            }
+            copiedParameters[key] = descriptor.value;
+        }
+        this.parameters = copiedParameters;
+        this.servicePrefix = options.servicePrefix;
+        this.httpMethod = options.httpMethod;
+        this.isReadOnly = options.isReadOnly;
+    }
+}
+exports.AwsCliCommand = AwsCliCommand;
+const MIN_SIGNED_64 = -(1n << 63n);
+const MAX_SIGNED_64 = (1n << 63n) - 1n;
+const MAX_UNSIGNED_64 = (1n << 64n) - 1n;
+const MAX_REQUEST_VALUE_DEPTH = 64;
+const DATE_GET_TIME = Date.prototype.getTime;
+const DATE_TO_ISO_STRING = Date.prototype.toISOString;
+const UINT8_ARRAY_FOR_EACH = Uint8Array.prototype.forEach;
+function isPlainRecord(value) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        return false;
+    }
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+}
+function unsupportedValue(typeName) {
+    return { type: 'UNSUPPORTED', type_name: typeName };
+}
+function encodeAwsCliValue(value, depth = 0, ancestors = new Set()) {
+    if (depth > MAX_REQUEST_VALUE_DEPTH) {
+        return unsupportedValue('recursion depth exceeded');
+    }
+    if (value === null) {
+        return { type: 'NULL' };
+    }
+    if (typeof value === 'boolean') {
+        return { type: 'BOOLEAN', value };
+    }
+    if (typeof value === 'number') {
+        if (!Number.isFinite(value)) {
+            return unsupportedValue('non-finite floating-point number');
+        }
+        if (Number.isInteger(value)) {
+            return Number.isSafeInteger(value)
+                ? { type: 'INTEGER', value }
+                : unsupportedValue('integer outside the JavaScript safe range');
+        }
+        return { type: 'NUMBER', value };
+    }
+    if (typeof value === 'bigint') {
+        if (value >= MIN_SIGNED_64 && value <= MAX_SIGNED_64) {
+            return { type: 'INTEGER', value };
+        }
+        if (value >= 0n && value <= MAX_UNSIGNED_64) {
+            return { type: 'UNSIGNED_INTEGER', value };
+        }
+        return unsupportedValue('integer outside the 64-bit request range');
+    }
+    if (typeof value === 'string') {
+        return { type: 'STRING', value };
+    }
+    if (value instanceof Uint8Array) {
+        const bytes = [];
+        try {
+            UINT8_ARRAY_FOR_EACH.call(value, (byte) => {
+                bytes.push(byte);
+            });
+        } catch {
+            return unsupportedValue('invalid Uint8Array');
+        }
+        return { type: 'BYTES', value: bytes };
+    }
+    if (value instanceof Date) {
+        try {
+            const timestamp = DATE_GET_TIME.call(value);
+            return Number.isFinite(timestamp)
+                ? { type: 'STRING', value: DATE_TO_ISO_STRING.call(value) }
+                : unsupportedValue('invalid Date');
+        } catch {
+            return unsupportedValue('invalid Date');
+        }
+    }
+    if (Array.isArray(value)) {
+        if (ancestors.has(value)) {
+            return unsupportedValue('cyclic array');
+        }
+        ancestors.add(value);
+        try {
+            const lengthDescriptor = Object.getOwnPropertyDescriptor(value, 'length');
+            if (
+                lengthDescriptor === undefined ||
+                !('value' in lengthDescriptor) ||
+                !Number.isSafeInteger(lengthDescriptor.value) ||
+                lengthDescriptor.value < 0
+            ) {
+                return unsupportedValue('array with invalid length');
+            }
+            const items = [];
+            for (let index = 0; index < lengthDescriptor.value; index += 1) {
+                const descriptor = Object.getOwnPropertyDescriptor(value, String(index));
+                if (descriptor === undefined) {
+                    return unsupportedValue('sparse array');
+                }
+                if (!('value' in descriptor)) {
+                    return unsupportedValue('array with accessor elements');
+                }
+                items.push(encodeAwsCliValue(descriptor.value, depth + 1, ancestors));
+            }
+            return { type: 'ARRAY', items };
+        } finally {
+            ancestors.delete(value);
+        }
+    }
+    if (isPlainRecord(value)) {
+        if (ancestors.has(value)) {
+            return unsupportedValue('cyclic object');
+        }
+        ancestors.add(value);
+        try {
+            const entries = Object.create(null);
+            for (const key of Reflect.ownKeys(value)) {
+                if (typeof key !== 'string') {
+                    return unsupportedValue('mapping with non-string keys');
+                }
+                const descriptor = Object.getOwnPropertyDescriptor(value, key);
+                if (descriptor === undefined || !('value' in descriptor)) {
+                    return unsupportedValue('mapping with accessor properties');
+                }
+                entries[key] = encodeAwsCliValue(descriptor.value, depth + 1, ancestors);
+            }
+            return { type: 'OBJECT', entries };
+        } finally {
+            ancestors.delete(value);
+        }
+    }
+    return unsupportedValue(typeof value);
+}
+function toWireAwsCliCommand(request) {
+    const parameters = Object.create(null);
+    for (const [name, value] of Object.entries(request.parameters)) {
+        try {
+            parameters[name] = encodeAwsCliValue(value);
+        } catch {
+            parameters[name] = unsupportedValue('request value inspection failed');
+        }
+    }
+    return {
+        serviceName: request.serviceName,
+        operationName: request.operationName,
+        parameters,
+        ...(request.servicePrefix === undefined ? {} : { servicePrefix: request.servicePrefix }),
+        ...(request.httpMethod === undefined ? {} : { httpMethod: request.httpMethod }),
+        ...(request.isReadOnly === undefined ? {} : { isReadOnly: request.isReadOnly }),
+    };
+}
+function fromWireAwsCliCommandValidation(validation) {
+    const template = validation.template;
+    return {
+        ...validation,
+        templateSource: validation.templateSource ?? null,
+        report: validation.report ?? null,
+        template: template == null ? null : Uint8Array.from(template),
+    };
+}
 const bridge = require('./bindings_wasm');
 class TemplateFile {
     constructor(path) {
@@ -62,6 +250,16 @@ function toWasmEngineConfig(config) {
             : undefined,
     };
 }
+function toWasmCompositeEngineConfig(config) {
+    return {
+        regoRules: toExternalRuleSources(config?.regoRules),
+        celRules: toExternalRuleSources(config?.celRules),
+        guardRules: toExternalRuleSources(config?.guardRules),
+        schemaValidatorConfig: config?.schemaValidatorConfig
+            ? toWasmSchemaValidatorConfig(config.schemaValidatorConfig)
+            : undefined,
+    };
+}
 function toWasmSchemaValidatorConfig(config) {
     return {
         additionalSchemas: toAdditionalSchemas(config?.additionalSchemas),
@@ -126,16 +324,19 @@ class SchemaValidator {
     }
 }
 exports.SchemaValidator = SchemaValidator;
-function createEngineClass(WasmClass) {
+function createEngineClass(WasmClass, toWasmConfig) {
     return class {
         constructor(config) {
-            this.inner = new WasmClass(toWasmEngineConfig(config));
+            this.inner = new WasmClass(toWasmConfig(config));
         }
-        validateStandard(template, config) {
-            return this.inner.validateStandard(template.readBytes(), config ?? {}, template.path);
+        validateTemplate(template, config) {
+            return this.inner.validateTemplate(template.readBytes(), config ?? {}, template.path);
         }
-        validateDetailed(template, config) {
-            return this.inner.validateDetailed(template.readBytes(), config ?? {}, template.path);
+        validateAwsCliCommand(request) {
+            if (!(request instanceof AwsCliCommand)) {
+                throw new TypeError('request must be an AwsCliCommand');
+            }
+            return fromWireAwsCliCommandValidation(this.inner.validateAwsCliCommand(toWireAwsCliCommand(request)));
         }
         listRules() {
             return this.inner.listRules();
@@ -148,8 +349,9 @@ function createEngineClass(WasmClass) {
         }
     };
 }
-exports.RegoEngine = createEngineClass(bridge.WasmRegoEngine);
-exports.CelEngine = createEngineClass(bridge.WasmCelEngine);
+exports.RegoEngine = createEngineClass(bridge.WasmRegoEngine, toWasmEngineConfig);
+exports.CelEngine = createEngineClass(bridge.WasmCelEngine, toWasmEngineConfig);
+exports.CompositeEngine = createEngineClass(bridge.WasmCompositeEngine, toWasmCompositeEngineConfig);
 function version() {
     return bridge.version();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws/cloudformation-validate",
-  "version": "1.8.0-beta",
+  "version": "1.10.0",
   "description": "Fast, offline, embeddable validation for AWS CloudFormation templates",
   "keywords": [
     "aws",