@aws-cdk/toolkit-lib 0.1.4 → 0.1.5

package/lib/api/cloud-assembly/source-builder.d.ts

@@ -15,6 +15,15 @@ export interface AssemblyBuilderProps {
     };
 }
 export type AssemblyBuilder = (props: AssemblyBuilderProps) => Promise<cxschema.ICloudAssembly>;
+/**
+ * Configuration for creating a CLI from an AWS CDK App directory
+ */
+export interface AssemblyDirectoryProps {
+    /**
+     * Options to configure loading of the assembly after it has been synthesized
+     */
+    readonly loadAssemblyOptions?: LoadAssemblyOptions;
+}
 /**
  * Configuration for creating a CLI from an AWS CDK App directory
  */
@@ -53,6 +62,10 @@ export interface AssemblySourceProps {
      * Options that are passed through the context to a CDK app on synth
      */
     readonly synthOptions?: AppSynthOptions;
+    /**
+     * Options to configure loading of the assembly after it has been synthesized
+     */
+    readonly loadAssemblyOptions?: LoadAssemblyOptions;
 }
 /**
  * Settings that are passed to a CDK app via the context
@@ -111,3 +124,26 @@ export interface AppSynthOptions {
      */
     readonly bundlingForStacks?: string;
 }
+/**
+ * Options to configure loading of the assembly after it has been synthesized
+ */
+export interface LoadAssemblyOptions {
+    /**
+     * Check the Toolkit supports the Cloud Assembly Schema version
+     *
+     * When disabled, allows to Toolkit to read a newer cloud assembly than the CX API is designed
+     * to support. Your application may not be aware of all features that in use in the Cloud Assembly.
+     *
+     * @default true
+     */
+    readonly checkVersion?: boolean;
+    /**
+     * Validate enums to only have known values
+     *
+     * When disabled, the Toolkit may read enum values it doesn't know about yet.
+     * You will have to make sure to always check the values of enums you encounter in the manifest.
+     *
+     * @default true
+     */
+    readonly checkEnums?: boolean;
+}

package/lib/api/cloud-assembly/source-builder.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/cloud-assembly/stack-selector.d.ts

@@ -1,81 +1,2 @@
-/**
- * Which stacks should be selected from a cloud assembly
- */
-export declare enum StackSelectionStrategy {
-    /**
-     * Returns all stacks in the app regardless of patterns,
-     * including stacks inside nested assemblies.
-     */
-    ALL_STACKS = "all-stacks",
-    /**
-     * Returns all stacks in the main (top level) assembly only.
-     */
-    MAIN_ASSEMBLY = "main-assembly",
-    /**
-     * If the assembly includes a single stack, returns it.
-     * Otherwise throws an exception.
-     */
-    ONLY_SINGLE = "only-single",
-    /**
-     * Return stacks matched by patterns.
-     * If no stacks are found, execution is halted successfully.
-     * Most likely you don't want to use this but `StackSelectionStrategy.MUST_MATCH_PATTERN`
-     */
-    PATTERN_MATCH = "pattern-match",
-    /**
-     * Return stacks matched by patterns.
-     * Throws an exception if the patterns don't match at least one stack in the assembly.
-     */
-    PATTERN_MUST_MATCH = "pattern-must-match",
-    /**
-     * Returns if exactly one stack is matched by the pattern(s).
-     * Throws an exception if no stack, or more than exactly one stack are matched.
-     */
-    PATTERN_MUST_MATCH_SINGLE = "pattern-must-match-single"
-}
-/**
- * When selecting stacks, what other stacks to include because of dependencies
- */
-export declare enum ExpandStackSelection {
-    /**
-     * Don't select any extra stacks
-     */
-    NONE = "none",
-    /**
-     * Include stacks that this stack depends on
-     */
-    UPSTREAM = "upstream",
-    /**
-     * Include stacks that depend on this stack
-     */
-    DOWNSTREAM = "downstream"
-}
-/**
- * A specification of which stacks should be selected
- */
-export interface StackSelector {
-    /**
-     * The behavior if if no selectors are provided.
-     */
-    strategy: StackSelectionStrategy;
-    /**
-     * A list of patterns to match the stack hierarchical ids
-     * Only used with `PATTERN_*` selection strategies.
-     */
-    patterns?: string[];
-    /**
-     * Expand the selection to upstream/downstream stacks.
-     * @default ExpandStackSelection.None only select the specified/matched stacks
-     */
-    expand?: ExpandStackSelection;
-    /**
-     * By default, we throw an exception if the assembly contains no stacks.
-     * Set to `false`, to halt execution for empty assemblies without error.
-     *
-     * Note that actions can still throw if a stack selection result is empty,
-     * but the assembly contains stacks in principle.
-     *
-     * @default true
-     */
-    failOnEmpty?: boolean;
-}
+export type { StackSelector } from '../shared-public';
+export { ExpandStackSelection, StackSelectionStrategy } from '../shared-public';

package/lib/api/cloud-assembly/stack-selector.js

@@ -1,64 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExpandStackSelection = exports.StackSelectionStrategy = void 0;
-/**
- * Which stacks should be selected from a cloud assembly
- */
-var StackSelectionStrategy;
-(function (StackSelectionStrategy) {
-    /**
-     * Returns all stacks in the app regardless of patterns,
-     * including stacks inside nested assemblies.
-     */
-    StackSelectionStrategy["ALL_STACKS"] = "all-stacks";
-    /**
-     * Returns all stacks in the main (top level) assembly only.
-     */
-    StackSelectionStrategy["MAIN_ASSEMBLY"] = "main-assembly";
-    /**
-     * If the assembly includes a single stack, returns it.
-     * Otherwise throws an exception.
-     */
-    StackSelectionStrategy["ONLY_SINGLE"] = "only-single";
-    /**
-     * Return stacks matched by patterns.
-     * If no stacks are found, execution is halted successfully.
-     * Most likely you don't want to use this but `StackSelectionStrategy.MUST_MATCH_PATTERN`
-     */
-    StackSelectionStrategy["PATTERN_MATCH"] = "pattern-match";
-    /**
-     * Return stacks matched by patterns.
-     * Throws an exception if the patterns don't match at least one stack in the assembly.
-     */
-    StackSelectionStrategy["PATTERN_MUST_MATCH"] = "pattern-must-match";
-    /**
-     * Returns if exactly one stack is matched by the pattern(s).
-     * Throws an exception if no stack, or more than exactly one stack are matched.
-     */
-    StackSelectionStrategy["PATTERN_MUST_MATCH_SINGLE"] = "pattern-must-match-single";
-})(StackSelectionStrategy || (exports.StackSelectionStrategy = StackSelectionStrategy = {}));
-/**
- * When selecting stacks, what other stacks to include because of dependencies
- */
-var ExpandStackSelection;
-(function (ExpandStackSelection) {
-    /**
-     * Don't select any extra stacks
-     */
-    ExpandStackSelection["NONE"] = "none";
-    /**
-     * Include stacks that this stack depends on
-     */
-    ExpandStackSelection["UPSTREAM"] = "upstream";
-    /**
-     * Include stacks that depend on this stack
-     */
-    ExpandStackSelection["DOWNSTREAM"] = "downstream";
-    /**
-     * @TODO
-     * Include both directions.
-     * I.e. stacks that this stack depends on, and stacks that depend on this stack.
-     */
-    // FULL = 'full',
-})(ExpandStackSelection || (exports.ExpandStackSelection = ExpandStackSelection = {}));
-//# sourceMappingURL=data:application/json;base64,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
+exports.StackSelectionStrategy = exports.ExpandStackSelection = void 0;
+var shared_public_1 = require("../shared-public");
+Object.defineProperty(exports, "ExpandStackSelection", { enumerable: true, get: function () { return shared_public_1.ExpandStackSelection; } });
+Object.defineProperty(exports, "StackSelectionStrategy", { enumerable: true, get: function () { return shared_public_1.StackSelectionStrategy; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RhY2stc2VsZWN0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJzdGFjay1zZWxlY3Rvci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFDQSxrREFBZ0Y7QUFBdkUscUhBQUEsb0JBQW9CLE9BQUE7QUFBRSx1SEFBQSxzQkFBc0IsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB0eXBlIHsgU3RhY2tTZWxlY3RvciB9IGZyb20gJy4uL3NoYXJlZC1wdWJsaWMnO1xuZXhwb3J0IHsgRXhwYW5kU3RhY2tTZWxlY3Rpb24sIFN0YWNrU2VsZWN0aW9uU3RyYXRlZ3kgfSBmcm9tICcuLi9zaGFyZWQtcHVibGljJztcbiJdfQ==

package/lib/api/io/private/index.d.ts

@@ -1,5 +1,3 @@
-export * from './codes';
-export * from './level-priority';
-export * from './logger';
-export * from './messages';
-export * from './timer';
+export { IO, SPAN } from '../../shared-private';
+export * from './io-host-wrappers';
+export * from './sdk-logger';

package/lib/api/io/private/index.js

@@ -14,9 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./codes"), exports);
-__exportStar(require("./level-priority"), exports);
-__exportStar(require("./logger"), exports);
-__exportStar(require("./messages"), exports);
-__exportStar(require("./timer"), exports);
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsMENBQXdCO0FBQ3hCLG1EQUFpQztBQUNqQywyQ0FBeUI7QUFDekIsNkNBQTJCO0FBQzNCLDBDQUF3QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vY29kZXMnO1xuZXhwb3J0ICogZnJvbSAnLi9sZXZlbC1wcmlvcml0eSc7XG5leHBvcnQgKiBmcm9tICcuL2xvZ2dlcic7XG5leHBvcnQgKiBmcm9tICcuL21lc3NhZ2VzJztcbmV4cG9ydCAqIGZyb20gJy4vdGltZXInO1xuIl19
+exports.SPAN = exports.IO = void 0;
+var shared_private_1 = require("../../shared-private");
+Object.defineProperty(exports, "IO", { enumerable: true, get: function () { return shared_private_1.IO; } });
+Object.defineProperty(exports, "SPAN", { enumerable: true, get: function () { return shared_private_1.SPAN; } });
+__exportStar(require("./io-host-wrappers"), exports);
+__exportStar(require("./sdk-logger"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyJpbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLHVEQUFnRDtBQUF2QyxvR0FBQSxFQUFFLE9BQUE7QUFBRSxzR0FBQSxJQUFJLE9BQUE7QUFDakIscURBQW1DO0FBQ25DLCtDQUE2QiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IElPLCBTUEFOIH0gZnJvbSAnLi4vLi4vc2hhcmVkLXByaXZhdGUnO1xuZXhwb3J0ICogZnJvbSAnLi9pby1ob3N0LXdyYXBwZXJzJztcbmV4cG9ydCAqIGZyb20gJy4vc2RrLWxvZ2dlcic7XG5cbiJdfQ==

package/lib/api/io/private/io-host-wrappers.d.ts

@@ -0,0 +1,17 @@
+import type { IIoHost } from '../';
+/**
+ * An IoHost wrapper that strips out ANSI colors and styles from the message before
+ * sending the message to the given IoHost
+ */
+export declare function withoutColor(ioHost: IIoHost): IIoHost;
+/**
+ * An IoHost wrapper that strips out emojis from the message before
+ * sending the message to the given IoHost
+ */
+export declare function withoutEmojis(ioHost: IIoHost): IIoHost;
+/**
+ * An IoHost wrapper that trims whitespace at the beginning and end of messages.
+ * This is required, since after removing emojis and ANSI colors,
+ * we might end up with floating whitespace at either end.
+ */
+export declare function withTrimmedWhitespace(ioHost: IIoHost): IIoHost;

package/lib/api/io/private/io-host-wrappers.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withoutColor = withoutColor;
+exports.withoutEmojis = withoutEmojis;
+exports.withTrimmedWhitespace = withTrimmedWhitespace;
+/**
+ * An IoHost wrapper that strips out ANSI colors and styles from the message before
+ * sending the message to the given IoHost
+ */
+function withoutColor(ioHost) {
+    return {
+        notify: async (msg) => {
+            await ioHost.notify({
+                ...msg,
+                message: stripColor(msg.message),
+            });
+        },
+        requestResponse: async (msg) => {
+            return ioHost.requestResponse({
+                ...msg,
+                message: stripColor(msg.message),
+            });
+        },
+    };
+}
+function stripColor(msg) {
+    return msg.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '');
+}
+/**
+ * An IoHost wrapper that strips out emojis from the message before
+ * sending the message to the given IoHost
+ */
+function withoutEmojis(ioHost) {
+    return {
+        notify: async (msg) => {
+            await ioHost.notify({
+                ...msg,
+                message: stripEmojis(msg.message),
+            });
+        },
+        requestResponse: async (msg) => {
+            return ioHost.requestResponse({
+                ...msg,
+                message: stripEmojis(msg.message),
+            });
+        },
+    };
+}
+function stripEmojis(msg) {
+    // https://www.unicode.org/reports/tr51/#def_emoji_presentation
+    return msg.replace(/\p{Emoji_Presentation}/gu, '');
+}
+/**
+ * An IoHost wrapper that trims whitespace at the beginning and end of messages.
+ * This is required, since after removing emojis and ANSI colors,
+ * we might end up with floating whitespace at either end.
+ */
+function withTrimmedWhitespace(ioHost) {
+    return {
+        notify: async (msg) => {
+            await ioHost.notify({
+                ...msg,
+                message: msg.message.trim(),
+            });
+        },
+        requestResponse: async (msg) => {
+            return ioHost.requestResponse({
+                ...msg,
+                message: msg.message.trim(),
+            });
+        },
+    };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/api/io/private/sdk-logger.d.ts

@@ -0,0 +1,3 @@
+import type { Logger } from '@smithy/types';
+import type { IoHelper } from '../../shared-private';
+export declare function asSdkLogger(ioHost: IoHelper): Logger;

package/lib/api/io/private/sdk-logger.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asSdkLogger = asSdkLogger;
+const util_1 = require("util");
+const util_2 = require("../../../private/util");
+const shared_private_1 = require("../../shared-private");
+function asSdkLogger(ioHost) {
+    return new class {
+        // This is too much detail for our logs
+        trace(..._content) {
+        }
+        debug(..._content) {
+        }
+        /**
+         * Info is called mostly (exclusively?) for successful API calls
+         *
+         * Payload:
+         *
+         * (Note the input contains entire CFN templates, for example)
+         *
+         * ```
+         * {
+         *   clientName: 'S3Client',
+         *   commandName: 'GetBucketLocationCommand',
+         *   input: {
+         *     Bucket: '.....',
+         *     ExpectedBucketOwner: undefined
+         *   },
+         *   output: { LocationConstraint: 'eu-central-1' },
+         *   metadata: {
+         *     httpStatusCode: 200,
+         *     requestId: '....',
+         *     extendedRequestId: '...',
+         *     cfId: undefined,
+         *     attempts: 1,
+         *     totalRetryDelay: 0
+         *   }
+         * }
+         * ```
+         */
+        info(...content) {
+            void ioHost.notify(shared_private_1.IO.CDK_SDK_I0100.msg(`[sdk info] ${formatSdkLoggerContent(content)}`, {
+                sdkLevel: 'info',
+                content,
+            }));
+        }
+        warn(...content) {
+            void ioHost.notify(shared_private_1.IO.CDK_SDK_I0100.msg(`[sdk warn] ${formatSdkLoggerContent(content)}`, {
+                sdkLevel: 'warn',
+                content,
+            }));
+        }
+        /**
+         * Error is called mostly (exclusively?) for failing API calls
+         *
+         * Payload (input would be the entire API call arguments).
+         *
+         * ```
+         * {
+         *   clientName: 'STSClient',
+         *   commandName: 'GetCallerIdentityCommand',
+         *   input: {},
+         *   error: AggregateError [ECONNREFUSED]:
+         *       at internalConnectMultiple (node:net:1121:18)
+         *       at afterConnectMultiple (node:net:1688:7) {
+         *     code: 'ECONNREFUSED',
+         *     '$metadata': { attempts: 3, totalRetryDelay: 600 },
+         *     [errors]: [ [Error], [Error] ]
+         *   },
+         *   metadata: { attempts: 3, totalRetryDelay: 600 }
+         * }
+         * ```
+         */
+        error(...content) {
+            void ioHost.notify(shared_private_1.IO.CDK_SDK_I0100.msg(`[sdk error] ${formatSdkLoggerContent(content)}`, {
+                sdkLevel: 'error',
+                content,
+            }));
+        }
+    };
+}
+/**
+ * This can be anything.
+ *
+ * For debug, it seems to be mostly strings.
+ * For info, it seems to be objects.
+ *
+ * Stringify and join without separator.
+ */
+function formatSdkLoggerContent(content) {
+    if (content.length === 1) {
+        const apiFmt = formatApiCall(content[0]);
+        if (apiFmt) {
+            return apiFmt;
+        }
+    }
+    return content.map((x) => typeof x === 'string' ? x : (0, util_1.inspect)(x)).join('');
+}
+function formatApiCall(content) {
+    if (!isSdkApiCallSuccess(content) && !isSdkApiCallError(content)) {
+        return undefined;
+    }
+    const service = content.clientName.replace(/Client$/, '');
+    const api = content.commandName.replace(/Command$/, '');
+    const parts = [];
+    if ((content.metadata?.attempts ?? 0) > 1) {
+        parts.push(`[${content.metadata?.attempts} attempts, ${content.metadata?.totalRetryDelay}ms retry]`);
+    }
+    parts.push(`${service}.${api}(${JSON.stringify(content.input, util_2.replacerBufferWithInfo)})`);
+    if (isSdkApiCallSuccess(content)) {
+        parts.push('-> OK');
+    }
+    else {
+        parts.push(`-> ${content.error}`);
+    }
+    return parts.join(' ');
+}
+function isSdkApiCallSuccess(x) {
+    return x && typeof x === 'object' && x.commandName && x.output;
+}
+function isSdkApiCallError(x) {
+    return x && typeof x === 'object' && x.commandName && x.error;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"sdk-logger.js","sourceRoot":"","sources":["sdk-logger.ts"],"names":[],"mappings":"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","sourcesContent":["\nimport { inspect } from 'util';\nimport type { Logger } from '@smithy/types';\nimport { replacerBufferWithInfo } from '../../../private/util';\nimport type { IoHelper } from '../../shared-private';\nimport { IO } from '../../shared-private';\n\nexport function asSdkLogger(ioHost: IoHelper): Logger {\n  return new class implements Logger {\n    // This is too much detail for our logs\n    public trace(..._content: any[]) {\n    }\n    public debug(..._content: any[]) {\n    }\n\n    /**\n     * Info is called mostly (exclusively?) for successful API calls\n     *\n     * Payload:\n     *\n     * (Note the input contains entire CFN templates, for example)\n     *\n     * ```\n     * {\n     *   clientName: 'S3Client',\n     *   commandName: 'GetBucketLocationCommand',\n     *   input: {\n     *     Bucket: '.....',\n     *     ExpectedBucketOwner: undefined\n     *   },\n     *   output: { LocationConstraint: 'eu-central-1' },\n     *   metadata: {\n     *     httpStatusCode: 200,\n     *     requestId: '....',\n     *     extendedRequestId: '...',\n     *     cfId: undefined,\n     *     attempts: 1,\n     *     totalRetryDelay: 0\n     *   }\n     * }\n     * ```\n     */\n    public info(...content: any[]) {\n      void ioHost.notify(IO.CDK_SDK_I0100.msg(`[sdk info] ${formatSdkLoggerContent(content)}`, {\n        sdkLevel: 'info',\n        content,\n      }));\n    }\n\n    public warn(...content: any[]) {\n      void ioHost.notify(IO.CDK_SDK_I0100.msg(`[sdk warn] ${formatSdkLoggerContent(content)}`, {\n        sdkLevel: 'warn',\n        content,\n      }));\n    }\n\n    /**\n     * Error is called mostly (exclusively?) for failing API calls\n     *\n     * Payload (input would be the entire API call arguments).\n     *\n     * ```\n     * {\n     *   clientName: 'STSClient',\n     *   commandName: 'GetCallerIdentityCommand',\n     *   input: {},\n     *   error: AggregateError [ECONNREFUSED]:\n     *       at internalConnectMultiple (node:net:1121:18)\n     *       at afterConnectMultiple (node:net:1688:7) {\n     *     code: 'ECONNREFUSED',\n     *     '$metadata': { attempts: 3, totalRetryDelay: 600 },\n     *     [errors]: [ [Error], [Error] ]\n     *   },\n     *   metadata: { attempts: 3, totalRetryDelay: 600 }\n     * }\n     * ```\n     */\n    public error(...content: any[]) {\n      void ioHost.notify(IO.CDK_SDK_I0100.msg(`[sdk error] ${formatSdkLoggerContent(content)}`, {\n        sdkLevel: 'error',\n        content,\n      }));\n    }\n  };\n}\n\n/**\n * This can be anything.\n *\n * For debug, it seems to be mostly strings.\n * For info, it seems to be objects.\n *\n * Stringify and join without separator.\n */\nfunction formatSdkLoggerContent(content: any[]) {\n  if (content.length === 1) {\n    const apiFmt = formatApiCall(content[0]);\n    if (apiFmt) {\n      return apiFmt;\n    }\n  }\n  return content.map((x) => typeof x === 'string' ? x : inspect(x)).join('');\n}\n\nfunction formatApiCall(content: any): string | undefined {\n  if (!isSdkApiCallSuccess(content) && !isSdkApiCallError(content)) {\n    return undefined;\n  }\n\n  const service = content.clientName.replace(/Client$/, '');\n  const api = content.commandName.replace(/Command$/, '');\n\n  const parts = [];\n  if ((content.metadata?.attempts ?? 0) > 1) {\n    parts.push(`[${content.metadata?.attempts} attempts, ${content.metadata?.totalRetryDelay}ms retry]`);\n  }\n\n  parts.push(`${service}.${api}(${JSON.stringify(content.input, replacerBufferWithInfo)})`);\n\n  if (isSdkApiCallSuccess(content)) {\n    parts.push('-> OK');\n  } else {\n    parts.push(`-> ${content.error}`);\n  }\n\n  return parts.join(' ');\n}\n\ninterface SdkApiCallBase {\n  clientName: string;\n  commandName: string;\n  input: Record<string, unknown>;\n  metadata?: {\n    httpStatusCode?: number;\n    requestId?: string;\n    extendedRequestId?: string;\n    cfId?: string;\n    attempts?: number;\n    totalRetryDelay?: number;\n  };\n}\n\ntype SdkApiCallSuccess = SdkApiCallBase & { output: Record<string, unknown> };\ntype SdkApiCallError = SdkApiCallBase & { error: Error };\n\nfunction isSdkApiCallSuccess(x: any): x is SdkApiCallSuccess {\n  return x && typeof x === 'object' && x.commandName && x.output;\n}\n\nfunction isSdkApiCallError(x: any): x is SdkApiCallError {\n  return x && typeof x === 'object' && x.commandName && x.error;\n}\n"]}