@wildix/wim-tools-client 0.0.3 → 0.0.5

package/dist-es/ToolsClient.js

@@ -1,10 +1,13 @@
 import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
 import { resolveRuntimeExtensions, } from "./runtimeExtensions";
+import { getHostHeaderPlugin, resolveHostHeaderConfig, } from "@aws-sdk/middleware-host-header";
+import { getLoggerPlugin } from "@aws-sdk/middleware-logger";
+import { getRecursionDetectionPlugin } from "@aws-sdk/middleware-recursion-detection";
 import { getUserAgentPlugin, resolveUserAgentConfig, } from "@aws-sdk/middleware-user-agent";
+import { resolveCustomEndpointsConfig, resolveRegionConfig, } from "@smithy/config-resolver";
 import { getContentLengthPlugin } from "@smithy/middleware-content-length";
 import { getRetryPlugin, resolveRetryConfig, } from "@smithy/middleware-retry";
 import { Client as __Client, } from "@smithy/smithy-client";
-import { authorizationMiddleware } from '@wildix/smithy-utils';
 export { __Client };
 export class ToolsClient extends __Client {
     config;
@@ -13,23 +16,18 @@ export class ToolsClient extends __Client {
         super(_config_0);
         this.initConfig = _config_0;
         let _config_1 = resolveUserAgentConfig(_config_0);
-        let _config_2 = resolveRetryConfig(_config_1);
-        let _config_3 = resolveRuntimeExtensions(_config_2, configuration?.extensions || []);
-        const hostname = ['stable', 'stage'].includes(configuration.env || '') ? `tools.wim-${configuration.env}.wildix.com` : 'tools.wim.wildix.com';
-        const endpoint = () => {
-            return {
-                hostname,
-                protocol: "https",
-                port: '443',
-                path: ''
-            };
-        };
-        const config = { ..._config_3, endpoint };
-        this.config = config;
-        this.middlewareStack.add(authorizationMiddleware.bind(this, configuration.token), { step: "build" });
+        let _config_2 = resolveCustomEndpointsConfig(_config_1);
+        let _config_3 = resolveRetryConfig(_config_2);
+        let _config_4 = resolveRegionConfig(_config_3);
+        let _config_5 = resolveHostHeaderConfig(_config_4);
+        let _config_6 = resolveRuntimeExtensions(_config_5, configuration?.extensions || []);
+        this.config = _config_6;
         this.middlewareStack.use(getUserAgentPlugin(this.config));
         this.middlewareStack.use(getRetryPlugin(this.config));
         this.middlewareStack.use(getContentLengthPlugin(this.config));
+        this.middlewareStack.use(getHostHeaderPlugin(this.config));
+        this.middlewareStack.use(getLoggerPlugin(this.config));
+        this.middlewareStack.use(getRecursionDetectionPlugin(this.config));
     }
     destroy() {
         super.destroy();

package/dist-es/commands/AddToolCommand.js

@@ -0,0 +1,17 @@
+import { de_AddToolCommand, se_AddToolCommand, } from "../protocols/Aws_restJson1";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+export { $Command };
+export class AddToolCommand extends $Command.classBuilder()
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+    ];
+})
+    .s("Tools", "AddTool", {})
+    .n("ToolsClient", "AddToolCommand")
+    .f(void 0, void 0)
+    .ser(se_AddToolCommand)
+    .de(de_AddToolCommand)
+    .build() {
+}

package/dist-es/commands/DeleteToolCommand.js

@@ -0,0 +1,17 @@
+import { de_DeleteToolCommand, se_DeleteToolCommand, } from "../protocols/Aws_restJson1";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+export { $Command };
+export class DeleteToolCommand extends $Command.classBuilder()
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+    ];
+})
+    .s("Tools", "DeleteTool", {})
+    .n("ToolsClient", "DeleteToolCommand")
+    .f(void 0, void 0)
+    .ser(se_DeleteToolCommand)
+    .de(de_DeleteToolCommand)
+    .build() {
+}

package/dist-es/commands/ExecuteToolCommand.js

@@ -0,0 +1,17 @@
+import { de_ExecuteToolCommand, se_ExecuteToolCommand, } from "../protocols/Aws_restJson1";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+export { $Command };
+export class ExecuteToolCommand extends $Command.classBuilder()
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+    ];
+})
+    .s("Tools", "ExecuteTool", {})
+    .n("ToolsClient", "ExecuteToolCommand")
+    .f(void 0, void 0)
+    .ser(se_ExecuteToolCommand)
+    .de(de_ExecuteToolCommand)
+    .build() {
+}

package/dist-es/commands/GetToolCommand.js

@@ -0,0 +1,17 @@
+import { de_GetToolCommand, se_GetToolCommand, } from "../protocols/Aws_restJson1";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+export { $Command };
+export class GetToolCommand extends $Command.classBuilder()
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+    ];
+})
+    .s("Tools", "GetTool", {})
+    .n("ToolsClient", "GetToolCommand")
+    .f(void 0, void 0)
+    .ser(se_GetToolCommand)
+    .de(de_GetToolCommand)
+    .build() {
+}

package/dist-es/commands/ListToolsCommand.js

@@ -0,0 +1,17 @@
+import { de_ListToolsCommand, se_ListToolsCommand, } from "../protocols/Aws_restJson1";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+export { $Command };
+export class ListToolsCommand extends $Command.classBuilder()
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+    ];
+})
+    .s("Tools", "ListTools", {})
+    .n("ToolsClient", "ListToolsCommand")
+    .f(void 0, void 0)
+    .ser(se_ListToolsCommand)
+    .de(de_ListToolsCommand)
+    .build() {
+}

package/dist-es/commands/UpdateToolCommand.js

@@ -0,0 +1,17 @@
+import { de_UpdateToolCommand, se_UpdateToolCommand, } from "../protocols/Aws_restJson1";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+export { $Command };
+export class UpdateToolCommand extends $Command.classBuilder()
+    .m(function (Command, cs, config, o) {
+    return [
+        getSerdePlugin(config, this.serialize, this.deserialize),
+    ];
+})
+    .s("Tools", "UpdateTool", {})
+    .n("ToolsClient", "UpdateToolCommand")
+    .f(void 0, void 0)
+    .ser(se_UpdateToolCommand)
+    .de(de_UpdateToolCommand)
+    .build() {
+}

package/dist-es/commands/index.js

@@ -1 +1,7 @@
+export * from "./AddToolCommand";
+export * from "./DeleteToolCommand";
+export * from "./ExecuteToolCommand";
+export * from "./GetToolCommand";
+export * from "./ListToolsCommand";
 export * from "./TestEndpointCommand";
+export * from "./UpdateToolCommand";

package/dist-es/models/models_0.js

@@ -11,3 +11,44 @@ export class ValidationException extends __BaseException {
         Object.setPrototypeOf(this, ValidationException.prototype);
     }
 }
+export const ToolType = {
+    EMAIL: "EMAIL",
+};
+export class ToolAlreadyExistsException extends __BaseException {
+    name = "ToolAlreadyExistsException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ToolAlreadyExistsException",
+            $fault: "client",
+            ...opts
+        });
+        Object.setPrototypeOf(this, ToolAlreadyExistsException.prototype);
+    }
+}
+export class ToolExecutionException extends __BaseException {
+    name = "ToolExecutionException";
+    $fault = "server";
+    details;
+    constructor(opts) {
+        super({
+            name: "ToolExecutionException",
+            $fault: "server",
+            ...opts
+        });
+        Object.setPrototypeOf(this, ToolExecutionException.prototype);
+        this.details = opts.details;
+    }
+}
+export class ToolNotFoundException extends __BaseException {
+    name = "ToolNotFoundException";
+    $fault = "client";
+    constructor(opts) {
+        super({
+            name: "ToolNotFoundException",
+            $fault: "client",
+            ...opts
+        });
+        Object.setPrototypeOf(this, ToolNotFoundException.prototype);
+    }
+}

package/dist-es/protocols/Aws_restJson1.js

@@ -1,8 +1,89 @@
 import { ToolsServiceException as __BaseException } from "../models/ToolsServiceException";
-import { ValidationException } from "../models/models_0";
+import { ToolAlreadyExistsException, ToolExecutionException, ToolNotFoundException, ValidationException, } from "../models/models_0";
 import { loadRestJsonErrorCode, parseJsonBody as parseBody, parseJsonErrorBody as parseErrorBody, } from "@aws-sdk/core";
 import { requestBuilder as rb } from "@smithy/core";
-import { decorateServiceException as __decorateServiceException, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, parseEpochTimestamp as __parseEpochTimestamp, collectBody, map, take, withBaseException, } from "@smithy/smithy-client";
+import { decorateServiceException as __decorateServiceException, expectBoolean as __expectBoolean, expectNonNull as __expectNonNull, expectNumber as __expectNumber, expectObject as __expectObject, expectString as __expectString, parseEpochTimestamp as __parseEpochTimestamp, collectBody, isSerializableHeaderValue, map, take, withBaseException, } from "@smithy/smithy-client";
+export const se_AddToolCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        'content-type': 'application/json',
+        [_xci]: input[_c],
+    });
+    b.bp("/v1/tools");
+    let body;
+    body = JSON.stringify(take(input, {
+        'config': _ => se_Document(_, context),
+        'description': [],
+        'jsonSchema': _ => se_Document(_, context),
+        'name': [],
+        'type': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_DeleteToolCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        [_xci]: input[_c],
+    });
+    b.bp("/v1/tools/{toolId}");
+    b.p('toolId', () => input.toolId, '{toolId}', false);
+    let body;
+    b.m("DELETE")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_ExecuteToolCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        'content-type': 'application/json',
+        [_xci]: input[_c],
+    });
+    b.bp("/v1/tools/execute");
+    let body;
+    body = JSON.stringify(take(input, {
+        'context': _ => se_ExecutionContext(_, context),
+        'parameters': _ => se_Document(_, context),
+        'toolId': [],
+    }));
+    b.m("POST")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const se_GetToolCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/v1/tools/{toolId}");
+    b.p('toolId', () => input.toolId, '{toolId}', false);
+    const query = map({
+        [_c]: [, input[_c]],
+    });
+    let body;
+    b.m("GET")
+        .h(headers)
+        .q(query)
+        .b(body);
+    return b.build();
+};
+export const se_ListToolsCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = {};
+    b.bp("/v1/tools");
+    const query = map({
+        [_c]: [, input[_c]],
+        [_f]: [, input[_f]],
+    });
+    let body;
+    b.m("GET")
+        .h(headers)
+        .q(query)
+        .b(body);
+    return b.build();
+};
 export const se_TestEndpointCommand = async (input, context) => {
     const b = rb(input, context);
     const headers = {};
@@ -17,6 +98,93 @@ export const se_TestEndpointCommand = async (input, context) => {
         .b(body);
     return b.build();
 };
+export const se_UpdateToolCommand = async (input, context) => {
+    const b = rb(input, context);
+    const headers = map({}, isSerializableHeaderValue, {
+        'content-type': 'application/json',
+        [_xci]: input[_c],
+    });
+    b.bp("/v1/tools/{toolId}");
+    b.p('toolId', () => input.toolId, '{toolId}', false);
+    let body;
+    body = JSON.stringify(take(input, {
+        'config': _ => se_Document(_, context),
+        'description': [],
+        'jsonSchema': _ => se_Document(_, context),
+        'name': [],
+    }));
+    b.m("PUT")
+        .h(headers)
+        .b(body);
+    return b.build();
+};
+export const de_AddToolCommand = async (output, context) => {
+    if (output.statusCode !== 201 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'tool': _ => de_Tool(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_DeleteToolCommand = async (output, context) => {
+    if (output.statusCode !== 204 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    await collectBody(output.body, context);
+    return contents;
+};
+export const de_ExecuteToolCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'result': _ => de_ExecutionResult(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_GetToolCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'tool': _ => de_Tool(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
+export const de_ListToolsCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'llmTools': _ => de_LlmToolDefinitionsList(_, context),
+        'tools': _ => de_ToolsList(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 export const de_TestEndpointCommand = async (output, context) => {
     if (output.statusCode !== 200 && output.statusCode >= 300) {
         return de_CommandError(output, context);
@@ -32,6 +200,20 @@ export const de_TestEndpointCommand = async (output, context) => {
     Object.assign(contents, doc);
     return contents;
 };
+export const de_UpdateToolCommand = async (output, context) => {
+    if (output.statusCode !== 200 && output.statusCode >= 300) {
+        return de_CommandError(output, context);
+    }
+    const contents = map({
+        $metadata: deserializeMetadata(output),
+    });
+    const data = __expectNonNull((__expectObject(await parseBody(output.body, context))), "body");
+    const doc = take(data, {
+        'tool': _ => de_Tool(_, context),
+    });
+    Object.assign(contents, doc);
+    return contents;
+};
 const de_CommandError = async (output, context) => {
     const parsedOutput = {
         ...output,
@@ -39,6 +221,15 @@ const de_CommandError = async (output, context) => {
     };
     const errorCode = loadRestJsonErrorCode(output, parsedOutput.body);
     switch (errorCode) {
+        case "ToolAlreadyExistsException":
+        case "wildix.wim.tools#ToolAlreadyExistsException":
+            throw await de_ToolAlreadyExistsExceptionRes(parsedOutput, context);
+        case "ToolExecutionException":
+        case "wildix.wim.tools#ToolExecutionException":
+            throw await de_ToolExecutionExceptionRes(parsedOutput, context);
+        case "ToolNotFoundException":
+        case "wildix.wim.tools#ToolNotFoundException":
+            throw await de_ToolNotFoundExceptionRes(parsedOutput, context);
         case "ValidationException":
         case "smithy.framework#ValidationException":
             throw await de_ValidationExceptionRes(parsedOutput, context);
@@ -65,6 +256,106 @@ const de_ValidationExceptionRes = async (parsedOutput, context) => {
     });
     return __decorateServiceException(exception, parsedOutput.body);
 };
+const de_ToolAlreadyExistsExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        'message': __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ToolAlreadyExistsException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_ToolExecutionExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        'details': _ => de_Document(_, context),
+        'message': __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ToolExecutionException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const de_ToolNotFoundExceptionRes = async (parsedOutput, context) => {
+    const contents = map({});
+    const data = parsedOutput.body;
+    const doc = take(data, {
+        'message': __expectString,
+    });
+    Object.assign(contents, doc);
+    const exception = new ToolNotFoundException({
+        $metadata: deserializeMetadata(parsedOutput),
+        ...contents
+    });
+    return __decorateServiceException(exception, parsedOutput.body);
+};
+const se_Document = (input, context) => {
+    return input;
+};
+const se_ExecutionContext = (input, context) => {
+    return take(input, {
+        'company': [],
+        'metadata': _ => se_Document(_, context),
+        'sessionId': [],
+        'userId': [],
+    });
+};
+const de_Document = (output, context) => {
+    return output;
+};
+const de_ExecutionResult = (output, context) => {
+    return take(output, {
+        'error': __expectString,
+        'result': (_) => de_Document(_, context),
+        'success': __expectBoolean,
+        'traceId': __expectString,
+    });
+};
+const de_LlmFunctionDefinition = (output, context) => {
+    return take(output, {
+        'description': __expectString,
+        'name': __expectString,
+        'parameters': (_) => de_Document(_, context),
+    });
+};
+const de_LlmToolDefinition = (output, context) => {
+    return take(output, {
+        'function': (_) => de_LlmFunctionDefinition(_, context),
+        'type': __expectString,
+    });
+};
+const de_LlmToolDefinitionsList = (output, context) => {
+    const retVal = (output || []).filter((e) => e != null).map((entry) => {
+        return de_LlmToolDefinition(entry, context);
+    });
+    return retVal;
+};
+const de_Tool = (output, context) => {
+    return take(output, {
+        'company': __expectString,
+        'config': (_) => de_Document(_, context),
+        'createdAt': (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+        'description': __expectString,
+        'id': __expectString,
+        'jsonSchema': (_) => de_Document(_, context),
+        'name': __expectString,
+        'type': __expectString,
+        'updatedAt': (_) => __expectNonNull(__parseEpochTimestamp(__expectNumber(_))),
+    });
+};
+const de_ToolsList = (output, context) => {
+    const retVal = (output || []).filter((e) => e != null).map((entry) => {
+        return de_Tool(entry, context);
+    });
+    return retVal;
+};
 const deserializeMetadata = (output) => ({
     httpStatusCode: output.statusCode,
     requestId: output.headers["x-amzn-requestid"] ?? output.headers["x-amzn-request-id"] ?? output.headers["x-amz-request-id"],
@@ -73,3 +364,5 @@ const deserializeMetadata = (output) => ({
 });
 const collectBodyString = (streamBody, context) => collectBody(streamBody, context).then(body => context.utf8Encoder(body));
 const _c = "company";
+const _f = "format";
+const _xci = "x-company-id";

package/dist-types/Tools.d.ts

@@ -1,7 +1,44 @@
 import { ToolsClient } from "./ToolsClient";
+import { AddToolCommandInput, AddToolCommandOutput } from "./commands/AddToolCommand";
+import { DeleteToolCommandInput, DeleteToolCommandOutput } from "./commands/DeleteToolCommand";
+import { ExecuteToolCommandInput, ExecuteToolCommandOutput } from "./commands/ExecuteToolCommand";
+import { GetToolCommandInput, GetToolCommandOutput } from "./commands/GetToolCommand";
+import { ListToolsCommandInput, ListToolsCommandOutput } from "./commands/ListToolsCommand";
 import { TestEndpointCommandInput, TestEndpointCommandOutput } from "./commands/TestEndpointCommand";
+import { UpdateToolCommandInput, UpdateToolCommandOutput } from "./commands/UpdateToolCommand";
 import { HttpHandlerOptions as __HttpHandlerOptions } from "@smithy/types";
 export interface Tools {
+    /**
+     * @see {@link AddToolCommand}
+     */
+    addTool(args: AddToolCommandInput, options?: __HttpHandlerOptions): Promise<AddToolCommandOutput>;
+    addTool(args: AddToolCommandInput, cb: (err: any, data?: AddToolCommandOutput) => void): void;
+    addTool(args: AddToolCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: AddToolCommandOutput) => void): void;
+    /**
+     * @see {@link DeleteToolCommand}
+     */
+    deleteTool(args: DeleteToolCommandInput, options?: __HttpHandlerOptions): Promise<DeleteToolCommandOutput>;
+    deleteTool(args: DeleteToolCommandInput, cb: (err: any, data?: DeleteToolCommandOutput) => void): void;
+    deleteTool(args: DeleteToolCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: DeleteToolCommandOutput) => void): void;
+    /**
+     * @see {@link ExecuteToolCommand}
+     */
+    executeTool(args: ExecuteToolCommandInput, options?: __HttpHandlerOptions): Promise<ExecuteToolCommandOutput>;
+    executeTool(args: ExecuteToolCommandInput, cb: (err: any, data?: ExecuteToolCommandOutput) => void): void;
+    executeTool(args: ExecuteToolCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ExecuteToolCommandOutput) => void): void;
+    /**
+     * @see {@link GetToolCommand}
+     */
+    getTool(args: GetToolCommandInput, options?: __HttpHandlerOptions): Promise<GetToolCommandOutput>;
+    getTool(args: GetToolCommandInput, cb: (err: any, data?: GetToolCommandOutput) => void): void;
+    getTool(args: GetToolCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: GetToolCommandOutput) => void): void;
+    /**
+     * @see {@link ListToolsCommand}
+     */
+    listTools(): Promise<ListToolsCommandOutput>;
+    listTools(args: ListToolsCommandInput, options?: __HttpHandlerOptions): Promise<ListToolsCommandOutput>;
+    listTools(args: ListToolsCommandInput, cb: (err: any, data?: ListToolsCommandOutput) => void): void;
+    listTools(args: ListToolsCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: ListToolsCommandOutput) => void): void;
     /**
      * @see {@link TestEndpointCommand}
      */
@@ -9,6 +46,12 @@ export interface Tools {
     testEndpoint(args: TestEndpointCommandInput, options?: __HttpHandlerOptions): Promise<TestEndpointCommandOutput>;
     testEndpoint(args: TestEndpointCommandInput, cb: (err: any, data?: TestEndpointCommandOutput) => void): void;
     testEndpoint(args: TestEndpointCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: TestEndpointCommandOutput) => void): void;
+    /**
+     * @see {@link UpdateToolCommand}
+     */
+    updateTool(args: UpdateToolCommandInput, options?: __HttpHandlerOptions): Promise<UpdateToolCommandOutput>;
+    updateTool(args: UpdateToolCommandInput, cb: (err: any, data?: UpdateToolCommandOutput) => void): void;
+    updateTool(args: UpdateToolCommandInput, options: __HttpHandlerOptions, cb: (err: any, data?: UpdateToolCommandOutput) => void): void;
 }
 /**
  * @public

package/dist-types/ToolsClient.d.ts

@@ -1,20 +1,27 @@
+import { AddToolCommandInput, AddToolCommandOutput } from "./commands/AddToolCommand";
+import { DeleteToolCommandInput, DeleteToolCommandOutput } from "./commands/DeleteToolCommand";
+import { ExecuteToolCommandInput, ExecuteToolCommandOutput } from "./commands/ExecuteToolCommand";
+import { GetToolCommandInput, GetToolCommandOutput } from "./commands/GetToolCommand";
+import { ListToolsCommandInput, ListToolsCommandOutput } from "./commands/ListToolsCommand";
 import { TestEndpointCommandInput, TestEndpointCommandOutput } from "./commands/TestEndpointCommand";
+import { UpdateToolCommandInput, UpdateToolCommandOutput } from "./commands/UpdateToolCommand";
 import { RuntimeExtension, RuntimeExtensionsConfig } from "./runtimeExtensions";
+import { HostHeaderInputConfig, HostHeaderResolvedConfig } from "@aws-sdk/middleware-host-header";
 import { UserAgentInputConfig, UserAgentResolvedConfig } from "@aws-sdk/middleware-user-agent";
+import { CustomEndpointsInputConfig, CustomEndpointsResolvedConfig, RegionInputConfig, RegionResolvedConfig } from "@smithy/config-resolver";
 import { RetryInputConfig, RetryResolvedConfig } from "@smithy/middleware-retry";
 import { HttpHandlerUserInput as __HttpHandlerUserInput } from "@smithy/protocol-http";
 import { Client as __Client, DefaultsMode as __DefaultsMode, SmithyConfiguration as __SmithyConfiguration, SmithyResolvedConfiguration as __SmithyResolvedConfiguration } from "@smithy/smithy-client";
 import { Provider, BodyLengthCalculator as __BodyLengthCalculator, CheckOptionalClientConfig as __CheckOptionalClientConfig, ChecksumConstructor as __ChecksumConstructor, Decoder as __Decoder, Encoder as __Encoder, HashConstructor as __HashConstructor, HttpHandlerOptions as __HttpHandlerOptions, Logger as __Logger, Provider as __Provider, StreamCollector as __StreamCollector, UrlParser as __UrlParser, UserAgent as __UserAgent } from "@smithy/types";
-import { TokenProvider } from '@wildix/smithy-utils';
 export { __Client };
 /**
  * @public
  */
-export type ServiceInputTypes = TestEndpointCommandInput;
+export type ServiceInputTypes = AddToolCommandInput | DeleteToolCommandInput | ExecuteToolCommandInput | GetToolCommandInput | ListToolsCommandInput | TestEndpointCommandInput | UpdateToolCommandInput;
 /**
  * @public
  */
-export type ServiceOutputTypes = TestEndpointCommandOutput;
+export type ServiceOutputTypes = AddToolCommandOutput | DeleteToolCommandOutput | ExecuteToolCommandOutput | GetToolCommandOutput | ListToolsCommandOutput | TestEndpointCommandOutput | UpdateToolCommandOutput;
 /**
  * @public
  */
@@ -105,20 +112,18 @@ export interface ClientDefaults extends Partial<__SmithyConfiguration<__HttpHand
 /**
  * @public
  */
-export type ToolsClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerOptions>> & ClientDefaults & UserAgentInputConfig & RetryInputConfig;
+export type ToolsClientConfigType = Partial<__SmithyConfiguration<__HttpHandlerOptions>> & ClientDefaults & UserAgentInputConfig & CustomEndpointsInputConfig & RetryInputConfig & RegionInputConfig & HostHeaderInputConfig;
 /**
  * @public
  *
  *  The configuration interface of ToolsClient class constructor that set the region, credentials and other options.
  */
 export interface ToolsClientConfig extends ToolsClientConfigType {
-    env?: 'stage' | 'stable' | 'prod';
-    token: TokenProvider;
 }
 /**
  * @public
  */
-export type ToolsClientResolvedConfigType = __SmithyResolvedConfiguration<__HttpHandlerOptions> & Required<ClientDefaults> & RuntimeExtensionsConfig & UserAgentResolvedConfig & RetryResolvedConfig;
+export type ToolsClientResolvedConfigType = __SmithyResolvedConfiguration<__HttpHandlerOptions> & Required<ClientDefaults> & RuntimeExtensionsConfig & UserAgentResolvedConfig & CustomEndpointsResolvedConfig & RetryResolvedConfig & RegionResolvedConfig & HostHeaderResolvedConfig;
 /**
  * @public
  *