@wildix/wim-tools-client 0.0.19 → 0.0.21

package/dist-cjs/models/models_0.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ToolExecutionServerException = exports.ToolExecutionException = exports.ToolVariableType = exports.ToolHandler = exports.ToolEmailHandler = exports.ToolStringValue = exports.ValidationException = exports.NotFoundException = exports.AlreadyExistException = void 0;
+exports.ToolExecutionServerException = exports.ToolExecutionException = exports.ToolVariableType = exports.ToolHandler = exports.ToolWebhookMethod = exports.ToolWebhookBody = exports.ToolWebhookAuth = exports.ToolEmailHandler = exports.ToolStringValue = exports.ValidationException = exports.NotFoundException = exports.AlreadyExistException = void 0;
 const ToolsServiceException_1 = require("./ToolsServiceException");
 class AlreadyExistException extends ToolsServiceException_1.ToolsServiceException {
     name = "AlreadyExistException";
@@ -63,11 +63,42 @@ var ToolEmailHandler;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(ToolEmailHandler || (exports.ToolEmailHandler = ToolEmailHandler = {}));
+var ToolWebhookAuth;
+(function (ToolWebhookAuth) {
+    ToolWebhookAuth.visit = (value, visitor) => {
+        if (value.basic !== undefined)
+            return visitor.basic(value.basic);
+        if (value.bearer !== undefined)
+            return visitor.bearer(value.bearer);
+        if (value.customHeader !== undefined)
+            return visitor.customHeader(value.customHeader);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ToolWebhookAuth || (exports.ToolWebhookAuth = ToolWebhookAuth = {}));
+var ToolWebhookBody;
+(function (ToolWebhookBody) {
+    ToolWebhookBody.visit = (value, visitor) => {
+        if (value.staticJson !== undefined)
+            return visitor.staticJson(value.staticJson);
+        if (value.template !== undefined)
+            return visitor.template(value.template);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ToolWebhookBody || (exports.ToolWebhookBody = ToolWebhookBody = {}));
+exports.ToolWebhookMethod = {
+    DELETE: "DELETE",
+    GET: "GET",
+    PATCH: "PATCH",
+    POST: "POST",
+    PUT: "PUT",
+};
 var ToolHandler;
 (function (ToolHandler) {
     ToolHandler.visit = (value, visitor) => {
         if (value.email !== undefined)
             return visitor.email(value.email);
+        if (value.webhook !== undefined)
+            return visitor.webhook(value.webhook);
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(ToolHandler || (exports.ToolHandler = ToolHandler = {}));

package/dist-cjs/protocols/Aws_restJson1.js

@@ -19,7 +19,7 @@ const se_CreateToolCommand = async (input, context) => {
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         'category': [],
         'description': [],
-        'handler': _ => (0, smithy_client_1._json)(_),
+        'handler': _ => se_ToolHandler(_, context),
         'input': _ => (0, smithy_client_1._json)(_),
         'name': [],
     }));
@@ -134,7 +134,7 @@ const se_UpdateToolCommand = async (input, context) => {
     body = JSON.stringify((0, smithy_client_1.take)(input, {
         'category': [],
         'description': [],
-        'handler': _ => (0, smithy_client_1._json)(_),
+        'handler': _ => se_ToolHandler(_, context),
         'input': _ => (0, smithy_client_1._json)(_),
         'name': [],
     }));
@@ -154,7 +154,7 @@ const de_CreateToolCommand = async (output, context) => {
     });
     const data = (0, smithy_client_1.expectNonNull)(((0, smithy_client_1.expectObject)(await (0, core_1.parseJsonBody)(output.body, context))), "body");
     const doc = (0, smithy_client_1.take)(data, {
-        'tool': smithy_client_1._json,
+        'tool': _ => de_Tool(_, context),
     });
     Object.assign(contents, doc);
     return contents;
@@ -210,7 +210,7 @@ const de_GetToolCommand = async (output, context) => {
     });
     const data = (0, smithy_client_1.expectNonNull)(((0, smithy_client_1.expectObject)(await (0, core_1.parseJsonBody)(output.body, context))), "body");
     const doc = (0, smithy_client_1.take)(data, {
-        'tool': smithy_client_1._json,
+        'tool': _ => de_Tool(_, context),
     });
     Object.assign(contents, doc);
     return contents;
@@ -225,7 +225,7 @@ const de_ListToolsCommand = async (output, context) => {
     });
     const data = (0, smithy_client_1.expectNonNull)(((0, smithy_client_1.expectObject)(await (0, core_1.parseJsonBody)(output.body, context))), "body");
     const doc = (0, smithy_client_1.take)(data, {
-        'tools': smithy_client_1._json,
+        'tools': _ => de_ToolsList(_, context),
     });
     Object.assign(contents, doc);
     return contents;
@@ -240,7 +240,7 @@ const de_UpdateToolCommand = async (output, context) => {
     });
     const data = (0, smithy_client_1.expectNonNull)(((0, smithy_client_1.expectObject)(await (0, core_1.parseJsonBody)(output.body, context))), "body");
     const doc = (0, smithy_client_1.take)(data, {
-        'tool': smithy_client_1._json,
+        'tool': _ => de_Tool(_, context),
     });
     Object.assign(contents, doc);
     return contents;
@@ -348,9 +348,44 @@ const de_ToolExecutionServerExceptionRes = async (parsedOutput, context) => {
 const se_Document = (input, context) => {
     return input;
 };
+const se_ToolHandler = (input, context) => {
+    return models_0_1.ToolHandler.visit(input, {
+        email: value => ({ "email": (0, smithy_client_1._json)(value) }),
+        webhook: value => ({ "webhook": se_ToolWebhookConfig(value, context) }),
+        _: (name, value) => ({ [name]: value })
+    });
+};
+const se_ToolWebhookBody = (input, context) => {
+    return models_0_1.ToolWebhookBody.visit(input, {
+        staticJson: value => ({ "staticJson": se_Document(value, context) }),
+        template: value => ({ "template": value }),
+        _: (name, value) => ({ [name]: value })
+    });
+};
+const se_ToolWebhookConfig = (input, context) => {
+    return (0, smithy_client_1.take)(input, {
+        'auth': smithy_client_1._json,
+        'body': _ => se_ToolWebhookBody(_, context),
+        'headers': smithy_client_1._json,
+        'method': [],
+        'queryParams': smithy_client_1._json,
+        'url': smithy_client_1._json,
+    });
+};
 const de_Document = (output, context) => {
     return output;
 };
+const de_Tool = (output, context) => {
+    return (0, smithy_client_1.take)(output, {
+        'category': smithy_client_1.expectString,
+        'companyId': smithy_client_1.expectString,
+        'description': smithy_client_1.expectString,
+        'handler': (_) => de_ToolHandler((0, core_1.awsExpectUnion)(_), context),
+        'id': smithy_client_1.expectString,
+        'input': smithy_client_1._json,
+        'name': smithy_client_1.expectString,
+    });
+};
 const de_ToolExecutionResult = (output, context) => {
     return (0, smithy_client_1.take)(output, {
         'error': smithy_client_1._json,
@@ -358,6 +393,46 @@ const de_ToolExecutionResult = (output, context) => {
         'statusCode': smithy_client_1.expectInt32,
     });
 };
+const de_ToolHandler = (output, context) => {
+    if (output.email != null) {
+        return {
+            email: (0, smithy_client_1._json)((0, core_1.awsExpectUnion)(output.email))
+        };
+    }
+    if (output.webhook != null) {
+        return {
+            webhook: de_ToolWebhookConfig(output.webhook, context)
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const de_ToolsList = (output, context) => {
+    const retVal = (output || []).filter((e) => e != null).map((entry) => {
+        return de_Tool(entry, context);
+    });
+    return retVal;
+};
+const de_ToolWebhookBody = (output, context) => {
+    if (output.staticJson != null) {
+        return {
+            staticJson: de_Document(output.staticJson, context)
+        };
+    }
+    if ((0, smithy_client_1.expectString)(output.template) !== undefined) {
+        return { template: (0, smithy_client_1.expectString)(output.template) };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const de_ToolWebhookConfig = (output, context) => {
+    return (0, smithy_client_1.take)(output, {
+        'auth': (_) => (0, smithy_client_1._json)((0, core_1.awsExpectUnion)(_)),
+        'body': (_) => de_ToolWebhookBody((0, core_1.awsExpectUnion)(_), context),
+        'headers': smithy_client_1._json,
+        'method': smithy_client_1.expectString,
+        'queryParams': smithy_client_1._json,
+        'url': (_) => (0, smithy_client_1._json)((0, core_1.awsExpectUnion)(_)),
+    });
+};
 const deserializeMetadata = (output) => ({
     httpStatusCode: output.statusCode,
     requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],

package/dist-es/models/models_0.js

@@ -57,11 +57,42 @@ export var ToolEmailHandler;
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(ToolEmailHandler || (ToolEmailHandler = {}));
+export var ToolWebhookAuth;
+(function (ToolWebhookAuth) {
+    ToolWebhookAuth.visit = (value, visitor) => {
+        if (value.basic !== undefined)
+            return visitor.basic(value.basic);
+        if (value.bearer !== undefined)
+            return visitor.bearer(value.bearer);
+        if (value.customHeader !== undefined)
+            return visitor.customHeader(value.customHeader);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ToolWebhookAuth || (ToolWebhookAuth = {}));
+export var ToolWebhookBody;
+(function (ToolWebhookBody) {
+    ToolWebhookBody.visit = (value, visitor) => {
+        if (value.staticJson !== undefined)
+            return visitor.staticJson(value.staticJson);
+        if (value.template !== undefined)
+            return visitor.template(value.template);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ToolWebhookBody || (ToolWebhookBody = {}));
+export const ToolWebhookMethod = {
+    DELETE: "DELETE",
+    GET: "GET",
+    PATCH: "PATCH",
+    POST: "POST",
+    PUT: "PUT",
+};
 export var ToolHandler;
 (function (ToolHandler) {
     ToolHandler.visit = (value, visitor) => {
         if (value.email !== undefined)
             return visitor.email(value.email);
+        if (value.webhook !== undefined)
+            return visitor.webhook(value.webhook);
         return visitor._(value.$unknown[0], value.$unknown[1]);
     };
 })(ToolHandler || (ToolHandler = {}));

package/dist-es/protocols/Aws_restJson1.js

@@ -1,6 +1,6 @@
 import { ToolsServiceException as __BaseException } from "../models/ToolsServiceException";
-import { AlreadyExistException, NotFoundException, ToolExecutionException, ToolExecutionServerException, ValidationException, } from "../models/models_0";
-import { loadRestJsonErrorCode, parseJsonBody as parseBody, parseJsonErrorBody as parseErrorBody, } from "@aws-sdk/core";
+import { AlreadyExistException, NotFoundException, ToolExecutionException, ToolExecutionServerException, ToolHandler, ToolWebhookBody, ValidationException, } from "../models/models_0";
+import { awsExpectUnion as __expectUnion, loadRestJsonErrorCode, parseJsonBody as parseBody, parseJsonErrorBody as parseErrorBody, } from "@aws-sdk/core";
 import { requestBuilder as rb } from "@smithy/core";
 import { decorateServiceException as __decorateServiceException, expectInt32 as __expectInt32, expectNonNull as __expectNonNull, expectObject as __expectObject, expectString as __expectString, _json, collectBody, map, take, withBaseException, } from "@smithy/smithy-client";
 export const se_CreateToolCommand = async (input, context) => {
@@ -16,7 +16,7 @@ export const se_CreateToolCommand = async (input, context) => {
     body = JSON.stringify(take(input, {
         'category': [],
         'description': [],
-        'handler': _ => _json(_),
+        'handler': _ => se_ToolHandler(_, context),
         'input': _ => _json(_),
         'name': [],
     }));
@@ -125,7 +125,7 @@ export const se_UpdateToolCommand = async (input, context) => {
     body = JSON.stringify(take(input, {
         'category': [],
         'description': [],
-        'handler': _ => _json(_),
+        'handler': _ => se_ToolHandler(_, context),
         'input': _ => _json(_),
         'name': [],
     }));
@@ -144,7 +144,7 @@ export const de_CreateToolCommand = async (output, context) => {
     });
     const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
     const doc = take(data, {
-        'tool': _json,
+        'tool': _ => de_Tool(_, context),
     });
     Object.assign(contents, doc);
     return contents;
@@ -196,7 +196,7 @@ export const de_GetToolCommand = async (output, context) => {
     });
     const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
     const doc = take(data, {
-        'tool': _json,
+        'tool': _ => de_Tool(_, context),
     });
     Object.assign(contents, doc);
     return contents;
@@ -210,7 +210,7 @@ export const de_ListToolsCommand = async (output, context) => {
     });
     const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
     const doc = take(data, {
-        'tools': _json,
+        'tools': _ => de_ToolsList(_, context),
     });
     Object.assign(contents, doc);
     return contents;
@@ -224,7 +224,7 @@ export const de_UpdateToolCommand = async (output, context) => {
     });
     const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
     const doc = take(data, {
-        'tool': _json,
+        'tool': _ => de_Tool(_, context),
     });
     Object.assign(contents, doc);
     return contents;
@@ -331,9 +331,44 @@ const de_ToolExecutionServerExceptionRes = async (parsedOutput, context) => {
 const se_Document = (input, context) => {
     return input;
 };
+const se_ToolHandler = (input, context) => {
+    return ToolHandler.visit(input, {
+        email: value => ({ "email": _json(value) }),
+        webhook: value => ({ "webhook": se_ToolWebhookConfig(value, context) }),
+        _: (name, value) => ({ [name]: value })
+    });
+};
+const se_ToolWebhookBody = (input, context) => {
+    return ToolWebhookBody.visit(input, {
+        staticJson: value => ({ "staticJson": se_Document(value, context) }),
+        template: value => ({ "template": value }),
+        _: (name, value) => ({ [name]: value })
+    });
+};
+const se_ToolWebhookConfig = (input, context) => {
+    return take(input, {
+        'auth': _json,
+        'body': _ => se_ToolWebhookBody(_, context),
+        'headers': _json,
+        'method': [],
+        'queryParams': _json,
+        'url': _json,
+    });
+};
 const de_Document = (output, context) => {
     return output;
 };
+const de_Tool = (output, context) => {
+    return take(output, {
+        'category': __expectString,
+        'companyId': __expectString,
+        'description': __expectString,
+        'handler': (_) => de_ToolHandler(__expectUnion(_), context),
+        'id': __expectString,
+        'input': _json,
+        'name': __expectString,
+    });
+};
 const de_ToolExecutionResult = (output, context) => {
     return take(output, {
         'error': _json,
@@ -341,6 +376,46 @@ const de_ToolExecutionResult = (output, context) => {
         'statusCode': __expectInt32,
     });
 };
+const de_ToolHandler = (output, context) => {
+    if (output.email != null) {
+        return {
+            email: _json(__expectUnion(output.email))
+        };
+    }
+    if (output.webhook != null) {
+        return {
+            webhook: de_ToolWebhookConfig(output.webhook, context)
+        };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const de_ToolsList = (output, context) => {
+    const retVal = (output || []).filter((e) => e != null).map((entry) => {
+        return de_Tool(entry, context);
+    });
+    return retVal;
+};
+const de_ToolWebhookBody = (output, context) => {
+    if (output.staticJson != null) {
+        return {
+            staticJson: de_Document(output.staticJson, context)
+        };
+    }
+    if (__expectString(output.template) !== undefined) {
+        return { template: __expectString(output.template) };
+    }
+    return { $unknown: Object.entries(output)[0] };
+};
+const de_ToolWebhookConfig = (output, context) => {
+    return take(output, {
+        'auth': (_) => _json(__expectUnion(_)),
+        'body': (_) => de_ToolWebhookBody(__expectUnion(_), context),
+        'headers': _json,
+        'method': __expectString,
+        'queryParams': _json,
+        'url': (_) => _json(__expectUnion(_)),
+    });
+};
 const deserializeMetadata = (output) => ({
     httpStatusCode: output.statusCode,
     requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],

package/dist-types/commands/CreateToolCommand.d.ts

@@ -86,12 +86,45 @@ declare const CreateToolCommand_base: {
  *         },
  *         subject: "<ToolStringValue>", // required
  *         text: "<ToolStringValue>", // required
- *         html: "<ToolStringValue>", // required
+ *         html: "<ToolStringValue>",
  *         cc: "<ToolStringValue>",
  *         bcc: "<ToolStringValue>",
  *         replyTo: "<ToolStringValue>",
  *       },
  *     },
+ *     webhook: { // ToolWebhookConfig
+ *       method: "GET" || "POST" || "PUT" || "DELETE" || "PATCH", // required
+ *       url: "<ToolStringValue>", // required
+ *       queryParams: [ // ToolWebhookQueryParamsList
+ *         { // ToolWebhookQueryParam
+ *           name: "STRING_VALUE", // required
+ *           value: "<ToolStringValue>", // required
+ *         },
+ *       ],
+ *       headers: [ // ToolWebhookHeadersList
+ *         { // ToolWebhookHeader
+ *           name: "STRING_VALUE", // required
+ *           value: "<ToolStringValue>", // required
+ *         },
+ *       ],
+ *       body: { // ToolWebhookBody Union: only one key present
+ *         staticJson: "DOCUMENT_VALUE",
+ *         template: "STRING_VALUE",
+ *       },
+ *       auth: { // ToolWebhookAuth Union: only one key present
+ *         basic: { // ToolWebhookAuthBasic
+ *           username: "<ToolStringValue>", // required
+ *           password: "<ToolStringValue>", // required
+ *         },
+ *         bearer: { // ToolWebhookAuthBearer
+ *           token: "<ToolStringValue>", // required
+ *         },
+ *         customHeader: { // ToolWebhookAuthCustomHeader
+ *           headerName: "STRING_VALUE", // required
+ *           headerValue: "<ToolStringValue>", // required
+ *         },
+ *       },
+ *     },
  *   },
  * };
  * const command = new CreateToolCommand(input);
@@ -150,12 +183,45 @@ declare const CreateToolCommand_base: {
  * //           },
  * //           subject: "<ToolStringValue>", // required
  * //           text: "<ToolStringValue>", // required
- * //           html: "<ToolStringValue>", // required
+ * //           html: "<ToolStringValue>",
  * //           cc: "<ToolStringValue>",
  * //           bcc: "<ToolStringValue>",
  * //           replyTo: "<ToolStringValue>",
  * //         },
  * //       },
+ * //       webhook: { // ToolWebhookConfig
+ * //         method: "GET" || "POST" || "PUT" || "DELETE" || "PATCH", // required
+ * //         url: "<ToolStringValue>", // required
+ * //         queryParams: [ // ToolWebhookQueryParamsList
+ * //           { // ToolWebhookQueryParam
+ * //             name: "STRING_VALUE", // required
+ * //             value: "<ToolStringValue>", // required
+ * //           },
+ * //         ],
+ * //         headers: [ // ToolWebhookHeadersList
+ * //           { // ToolWebhookHeader
+ * //             name: "STRING_VALUE", // required
+ * //             value: "<ToolStringValue>", // required
+ * //           },
+ * //         ],
+ * //         body: { // ToolWebhookBody Union: only one key present
+ * //           staticJson: "DOCUMENT_VALUE",
+ * //           template: "STRING_VALUE",
+ * //         },
+ * //         auth: { // ToolWebhookAuth Union: only one key present
+ * //           basic: { // ToolWebhookAuthBasic
+ * //             username: "<ToolStringValue>", // required
+ * //             password: "<ToolStringValue>", // required
+ * //           },
+ * //           bearer: { // ToolWebhookAuthBearer
+ * //             token: "<ToolStringValue>", // required
+ * //           },
+ * //           customHeader: { // ToolWebhookAuthCustomHeader
+ * //             headerName: "STRING_VALUE", // required
+ * //             headerValue: "<ToolStringValue>", // required
+ * //           },
+ * //         },
+ * //       },
  * //     },
  * //   },
  * // };

package/dist-types/commands/GetToolCommand.d.ts

@@ -94,12 +94,45 @@ declare const GetToolCommand_base: {
  * //           },
  * //           subject: "<ToolStringValue>", // required
  * //           text: "<ToolStringValue>", // required
- * //           html: "<ToolStringValue>", // required
+ * //           html: "<ToolStringValue>",
  * //           cc: "<ToolStringValue>",
  * //           bcc: "<ToolStringValue>",
  * //           replyTo: "<ToolStringValue>",
  * //         },
  * //       },
+ * //       webhook: { // ToolWebhookConfig
+ * //         method: "GET" || "POST" || "PUT" || "DELETE" || "PATCH", // required
+ * //         url: "<ToolStringValue>", // required
+ * //         queryParams: [ // ToolWebhookQueryParamsList
+ * //           { // ToolWebhookQueryParam
+ * //             name: "STRING_VALUE", // required
+ * //             value: "<ToolStringValue>", // required
+ * //           },
+ * //         ],
+ * //         headers: [ // ToolWebhookHeadersList
+ * //           { // ToolWebhookHeader
+ * //             name: "STRING_VALUE", // required
+ * //             value: "<ToolStringValue>", // required
+ * //           },
+ * //         ],
+ * //         body: { // ToolWebhookBody Union: only one key present
+ * //           staticJson: "DOCUMENT_VALUE",
+ * //           template: "STRING_VALUE",
+ * //         },
+ * //         auth: { // ToolWebhookAuth Union: only one key present
+ * //           basic: { // ToolWebhookAuthBasic
+ * //             username: "<ToolStringValue>", // required
+ * //             password: "<ToolStringValue>", // required
+ * //           },
+ * //           bearer: { // ToolWebhookAuthBearer
+ * //             token: "<ToolStringValue>", // required
+ * //           },
+ * //           customHeader: { // ToolWebhookAuthCustomHeader
+ * //             headerName: "STRING_VALUE", // required
+ * //             headerValue: "<ToolStringValue>", // required
+ * //           },
+ * //         },
+ * //       },
  * //     },
  * //   },
  * // };

package/dist-types/commands/ListToolsCommand.d.ts

@@ -94,12 +94,45 @@ declare const ListToolsCommand_base: {
  * //             },
  * //             subject: "<ToolStringValue>", // required
  * //             text: "<ToolStringValue>", // required
- * //             html: "<ToolStringValue>", // required
+ * //             html: "<ToolStringValue>",
  * //             cc: "<ToolStringValue>",
  * //             bcc: "<ToolStringValue>",
  * //             replyTo: "<ToolStringValue>",
  * //           },
  * //         },
+ * //         webhook: { // ToolWebhookConfig
+ * //           method: "GET" || "POST" || "PUT" || "DELETE" || "PATCH", // required
+ * //           url: "<ToolStringValue>", // required
+ * //           queryParams: [ // ToolWebhookQueryParamsList
+ * //             { // ToolWebhookQueryParam
+ * //               name: "STRING_VALUE", // required
+ * //               value: "<ToolStringValue>", // required
+ * //             },
+ * //           ],
+ * //           headers: [ // ToolWebhookHeadersList
+ * //             { // ToolWebhookHeader
+ * //               name: "STRING_VALUE", // required
+ * //               value: "<ToolStringValue>", // required
+ * //             },
+ * //           ],
+ * //           body: { // ToolWebhookBody Union: only one key present
+ * //             staticJson: "DOCUMENT_VALUE",
+ * //             template: "STRING_VALUE",
+ * //           },
+ * //           auth: { // ToolWebhookAuth Union: only one key present
+ * //             basic: { // ToolWebhookAuthBasic
+ * //               username: "<ToolStringValue>", // required
+ * //               password: "<ToolStringValue>", // required
+ * //             },
+ * //             bearer: { // ToolWebhookAuthBearer
+ * //               token: "<ToolStringValue>", // required
+ * //             },
+ * //             customHeader: { // ToolWebhookAuthCustomHeader
+ * //               headerName: "STRING_VALUE", // required
+ * //               headerValue: "<ToolStringValue>", // required
+ * //             },
+ * //           },
+ * //         },
  * //       },
  * //     },
  * //   ],

package/dist-types/commands/UpdateToolCommand.d.ts

@@ -87,12 +87,45 @@ declare const UpdateToolCommand_base: {
  *         },
  *         subject: "<ToolStringValue>", // required
  *         text: "<ToolStringValue>", // required
- *         html: "<ToolStringValue>", // required
+ *         html: "<ToolStringValue>",
  *         cc: "<ToolStringValue>",
  *         bcc: "<ToolStringValue>",
  *         replyTo: "<ToolStringValue>",
  *       },
  *     },
+ *     webhook: { // ToolWebhookConfig
+ *       method: "GET" || "POST" || "PUT" || "DELETE" || "PATCH", // required
+ *       url: "<ToolStringValue>", // required
+ *       queryParams: [ // ToolWebhookQueryParamsList
+ *         { // ToolWebhookQueryParam
+ *           name: "STRING_VALUE", // required
+ *           value: "<ToolStringValue>", // required
+ *         },
+ *       ],
+ *       headers: [ // ToolWebhookHeadersList
+ *         { // ToolWebhookHeader
+ *           name: "STRING_VALUE", // required
+ *           value: "<ToolStringValue>", // required
+ *         },
+ *       ],
+ *       body: { // ToolWebhookBody Union: only one key present
+ *         staticJson: "DOCUMENT_VALUE",
+ *         template: "STRING_VALUE",
+ *       },
+ *       auth: { // ToolWebhookAuth Union: only one key present
+ *         basic: { // ToolWebhookAuthBasic
+ *           username: "<ToolStringValue>", // required
+ *           password: "<ToolStringValue>", // required
+ *         },
+ *         bearer: { // ToolWebhookAuthBearer
+ *           token: "<ToolStringValue>", // required
+ *         },
+ *         customHeader: { // ToolWebhookAuthCustomHeader
+ *           headerName: "STRING_VALUE", // required
+ *           headerValue: "<ToolStringValue>", // required
+ *         },
+ *       },
+ *     },
  *   },
  * };
  * const command = new UpdateToolCommand(input);
@@ -151,12 +184,45 @@ declare const UpdateToolCommand_base: {
  * //           },
  * //           subject: "<ToolStringValue>", // required
  * //           text: "<ToolStringValue>", // required
- * //           html: "<ToolStringValue>", // required
+ * //           html: "<ToolStringValue>",
  * //           cc: "<ToolStringValue>",
  * //           bcc: "<ToolStringValue>",
  * //           replyTo: "<ToolStringValue>",
  * //         },
  * //       },
+ * //       webhook: { // ToolWebhookConfig
+ * //         method: "GET" || "POST" || "PUT" || "DELETE" || "PATCH", // required
+ * //         url: "<ToolStringValue>", // required
+ * //         queryParams: [ // ToolWebhookQueryParamsList
+ * //           { // ToolWebhookQueryParam
+ * //             name: "STRING_VALUE", // required
+ * //             value: "<ToolStringValue>", // required
+ * //           },
+ * //         ],
+ * //         headers: [ // ToolWebhookHeadersList
+ * //           { // ToolWebhookHeader
+ * //             name: "STRING_VALUE", // required
+ * //             value: "<ToolStringValue>", // required
+ * //           },
+ * //         ],
+ * //         body: { // ToolWebhookBody Union: only one key present
+ * //           staticJson: "DOCUMENT_VALUE",
+ * //           template: "STRING_VALUE",
+ * //         },
+ * //         auth: { // ToolWebhookAuth Union: only one key present
+ * //           basic: { // ToolWebhookAuthBasic
+ * //             username: "<ToolStringValue>", // required
+ * //             password: "<ToolStringValue>", // required
+ * //           },
+ * //           bearer: { // ToolWebhookAuthBearer
+ * //             token: "<ToolStringValue>", // required
+ * //           },
+ * //           customHeader: { // ToolWebhookAuthCustomHeader
+ * //             headerName: "STRING_VALUE", // required
+ * //             headerValue: "<ToolStringValue>", // required
+ * //           },
+ * //         },
+ * //       },
  * //     },
  * //   },
  * // };

package/dist-types/models/models_0.d.ts

@@ -99,7 +99,7 @@ export interface ToolSmtpConfig {
      */
     host: string;
     /**
-     * SMTP server port, e.g.: '587'
+     * SMTP server port, e.g.: 587
      * @public
      */
     port: number;
@@ -152,7 +152,7 @@ export interface ToolCustomEmailConfig {
      * HTML content of the email
      * @public
      */
-    html: ToolStringValue;
+    html?: ToolStringValue | undefined;
     /**
      * CC email addresses
      * @public
@@ -233,7 +233,223 @@ export declare namespace ToolEmailHandler {
 /**
  * @public
  */
-export type ToolHandler = ToolHandler.EmailMember | ToolHandler.$UnknownMember;
+export interface ToolWebhookAuthBasic {
+    /**
+     * Username for basic authentication
+     * @public
+     */
+    username: ToolStringValue;
+    /**
+     * Password for basic authentication
+     * @public
+     */
+    password: ToolStringValue;
+}
+/**
+ * @public
+ */
+export interface ToolWebhookAuthBearer {
+    /**
+     * Bearer token value, supports static, variable, or template syntax
+     * @public
+     */
+    token: ToolStringValue;
+}
+/**
+ * @public
+ */
+export interface ToolWebhookAuthCustomHeader {
+    /**
+     * Header name for custom authentication, e.g.: 'X-API-Key'
+     * @public
+     */
+    headerName: string;
+    /**
+     * Header value, supports static, variable, or template syntax
+     * @public
+     */
+    headerValue: ToolStringValue;
+}
+/**
+ * @public
+ */
+export type ToolWebhookAuth = ToolWebhookAuth.BasicMember | ToolWebhookAuth.BearerMember | ToolWebhookAuth.CustomHeaderMember | ToolWebhookAuth.$UnknownMember;
+/**
+ * @public
+ */
+export declare namespace ToolWebhookAuth {
+    /**
+     * HTTP Basic Authentication
+     * @public
+     */
+    interface BasicMember {
+        basic: ToolWebhookAuthBasic;
+        bearer?: never;
+        customHeader?: never;
+        $unknown?: never;
+    }
+    /**
+     * HTTP Bearer Token Authentication
+     * @public
+     */
+    interface BearerMember {
+        basic?: never;
+        bearer: ToolWebhookAuthBearer;
+        customHeader?: never;
+        $unknown?: never;
+    }
+    /**
+     * Custom Header Authentication
+     * @public
+     */
+    interface CustomHeaderMember {
+        basic?: never;
+        bearer?: never;
+        customHeader: ToolWebhookAuthCustomHeader;
+        $unknown?: never;
+    }
+    /**
+     * @public
+     */
+    interface $UnknownMember {
+        basic?: never;
+        bearer?: never;
+        customHeader?: never;
+        $unknown: [string, any];
+    }
+    interface Visitor<T> {
+        basic: (value: ToolWebhookAuthBasic) => T;
+        bearer: (value: ToolWebhookAuthBearer) => T;
+        customHeader: (value: ToolWebhookAuthCustomHeader) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: ToolWebhookAuth, visitor: Visitor<T>) => T;
+}
+/**
+ * @public
+ */
+export type ToolWebhookBody = ToolWebhookBody.StaticJsonMember | ToolWebhookBody.TemplateMember | ToolWebhookBody.$UnknownMember;
+/**
+ * @public
+ */
+export declare namespace ToolWebhookBody {
+    /**
+     * Static JSON document body
+     * @public
+     */
+    interface StaticJsonMember {
+        staticJson: __DocumentType;
+        template?: never;
+        $unknown?: never;
+    }
+    /**
+     * Template string body that supports variables and static values
+     * @public
+     */
+    interface TemplateMember {
+        staticJson?: never;
+        template: string;
+        $unknown?: never;
+    }
+    /**
+     * @public
+     */
+    interface $UnknownMember {
+        staticJson?: never;
+        template?: never;
+        $unknown: [string, any];
+    }
+    interface Visitor<T> {
+        staticJson: (value: __DocumentType) => T;
+        template: (value: string) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: ToolWebhookBody, visitor: Visitor<T>) => T;
+}
+/**
+ * @public
+ */
+export interface ToolWebhookHeader {
+    /**
+     * Header name, e.g.: 'X-Custom-Header'
+     * @public
+     */
+    name: string;
+    /**
+     * Header value, supports static, variable, or template syntax
+     * @public
+     */
+    value: ToolStringValue;
+}
+/**
+ * @public
+ * @enum
+ */
+export declare const ToolWebhookMethod: {
+    readonly DELETE: "DELETE";
+    readonly GET: "GET";
+    readonly PATCH: "PATCH";
+    readonly POST: "POST";
+    readonly PUT: "PUT";
+};
+/**
+ * @public
+ */
+export type ToolWebhookMethod = typeof ToolWebhookMethod[keyof typeof ToolWebhookMethod];
+/**
+ * @public
+ */
+export interface ToolWebhookQueryParam {
+    /**
+     * Query parameter name, e.g.: 'filter'
+     * @public
+     */
+    name: string;
+    /**
+     * Query parameter value, supports static, variable, or template syntax
+     * @public
+     */
+    value: ToolStringValue;
+}
+/**
+ * @public
+ */
+export interface ToolWebhookConfig {
+    /**
+     * HTTP method for the webhook request, e.g.: 'POST'
+     * @public
+     */
+    method: ToolWebhookMethod;
+    /**
+     * URL endpoint for the webhook, supports variables in path using \{\{variable_name\}\}
+     * @public
+     */
+    url: ToolStringValue;
+    /**
+     * Query parameters for the webhook request
+     * @public
+     */
+    queryParams?: (ToolWebhookQueryParam)[] | undefined;
+    /**
+     * HTTP headers for the webhook request
+     * @public
+     */
+    headers?: (ToolWebhookHeader)[] | undefined;
+    /**
+     * Request body for POST, PUT, or PATCH requests
+     * @public
+     */
+    body?: ToolWebhookBody | undefined;
+    /**
+     * Authentication configuration for the webhook request
+     * @public
+     */
+    auth?: ToolWebhookAuth | undefined;
+}
+/**
+ * @public
+ */
+export type ToolHandler = ToolHandler.EmailMember | ToolHandler.WebhookMember | ToolHandler.$UnknownMember;
 /**
  * @public
  */
@@ -244,6 +460,16 @@ export declare namespace ToolHandler {
      */
     interface EmailMember {
         email: ToolEmailHandler;
+        webhook?: never;
+        $unknown?: never;
+    }
+    /**
+     * Webhook handler of the tool.
+     * @public
+     */
+    interface WebhookMember {
+        email?: never;
+        webhook: ToolWebhookConfig;
         $unknown?: never;
     }
     /**
@@ -251,10 +477,12 @@ export declare namespace ToolHandler {
      */
     interface $UnknownMember {
         email?: never;
+        webhook?: never;
         $unknown: [string, any];
     }
     interface Visitor<T> {
         email: (value: ToolEmailHandler) => T;
+        webhook: (value: ToolWebhookConfig) => T;
         _: (name: string, value: any) => T;
     }
     const visit: <T>(value: ToolHandler, visitor: Visitor<T>) => T;

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@wildix/wim-tools-client",
     "description": "@wildix/wim-tools-client client",
-    "version": "0.0.19",
+    "version": "0.0.21",
     "scripts": {
         "build": "concurrently 'yarn:build:cjs' 'yarn:build:es' 'yarn:build:types'",
         "build:cjs": "tsc -p tsconfig.cjs.json",