@wildix/wilma-tools-client 1.0.1

package/dist-es/WilmaTools.js

@@ -0,0 +1,51 @@
+import { createAggregatedClient } from "@smithy/core/client";
+import { CreateConnectorCommand, } from "./commands/CreateConnectorCommand";
+import { CreateToolCommand, } from "./commands/CreateToolCommand";
+import { DeleteConnectorCommand, } from "./commands/DeleteConnectorCommand";
+import { DeleteToolCommand, } from "./commands/DeleteToolCommand";
+import { DescribeCapabilitiesCommand, } from "./commands/DescribeCapabilitiesCommand";
+import { DescribeConnectorsCommand, } from "./commands/DescribeConnectorsCommand";
+import { DescribeToolsCommand, } from "./commands/DescribeToolsCommand";
+import { DiscoverToolsCommand, } from "./commands/DiscoverToolsCommand";
+import { ExecuteConnectorCommand, } from "./commands/ExecuteConnectorCommand";
+import { ExecuteToolCommand, } from "./commands/ExecuteToolCommand";
+import { GetConnectorCommand, } from "./commands/GetConnectorCommand";
+import { GetConnectorDefinitionCommand, } from "./commands/GetConnectorDefinitionCommand";
+import { GetToolCommand } from "./commands/GetToolCommand";
+import { ListConnectorDefinitionsCommand, } from "./commands/ListConnectorDefinitionsCommand";
+import { ListConnectorsCommand, } from "./commands/ListConnectorsCommand";
+import { ListToolsCommand } from "./commands/ListToolsCommand";
+import { ResolveConnectorConfigurationCommand, } from "./commands/ResolveConnectorConfigurationCommand";
+import { UpdateConnectorCommand, } from "./commands/UpdateConnectorCommand";
+import { UpdateToolCommand, } from "./commands/UpdateToolCommand";
+import { paginateListConnectorDefinitions } from "./pagination/ListConnectorDefinitionsPaginator";
+import { paginateListConnectors } from "./pagination/ListConnectorsPaginator";
+import { WilmaToolsClient } from "./WilmaToolsClient";
+const commands = {
+    CreateConnectorCommand,
+    CreateToolCommand,
+    DeleteConnectorCommand,
+    DeleteToolCommand,
+    DescribeCapabilitiesCommand,
+    DescribeConnectorsCommand,
+    DescribeToolsCommand,
+    DiscoverToolsCommand,
+    ExecuteConnectorCommand,
+    ExecuteToolCommand,
+    GetConnectorCommand,
+    GetConnectorDefinitionCommand,
+    GetToolCommand,
+    ListConnectorDefinitionsCommand,
+    ListConnectorsCommand,
+    ListToolsCommand,
+    ResolveConnectorConfigurationCommand,
+    UpdateConnectorCommand,
+    UpdateToolCommand,
+};
+const paginators = {
+    paginateListConnectorDefinitions,
+    paginateListConnectors,
+};
+export class WilmaTools extends WilmaToolsClient {
+}
+createAggregatedClient(commands, WilmaTools, { paginators });

package/dist-es/WilmaToolsClient.js

@@ -0,0 +1,47 @@
+import { getHostHeaderPlugin, getLoggerPlugin, getRecursionDetectionPlugin, getUserAgentPlugin, resolveHostHeaderConfig, resolveUserAgentConfig, } from "@aws-sdk/core/client";
+import { DefaultIdentityProviderConfig, getHttpAuthSchemeEndpointRuleSetPlugin, getHttpSigningPlugin, } from "@smithy/core";
+import { Client as __Client, } from "@smithy/core/client";
+import { resolveEndpointConfig } from "@smithy/core/endpoints";
+import { getContentLengthPlugin } from "@smithy/core/protocols";
+import { getRetryPlugin, resolveRetryConfig, } from "@smithy/core/retry";
+import { getSchemaSerdePlugin } from "@smithy/core/schema";
+import { defaultWilmaToolsHttpAuthSchemeParametersProvider, resolveHttpAuthSchemeConfig, } from "./auth/httpAuthSchemeProvider";
+import { resolveClientEndpointParameters, } from "./endpoint/EndpointParameters";
+import { getRuntimeConfig as __getRuntimeConfig } from "./runtimeConfig";
+import { resolveRuntimeExtensions } from "./runtimeExtensions";
+export { __Client };
+export class WilmaToolsClient extends __Client {
+    config;
+    constructor(...[configuration]) {
+        const _config_0 = __getRuntimeConfig(configuration || {});
+        super(_config_0);
+        this.initConfig = _config_0;
+        const _config_1 = resolveClientEndpointParameters(_config_0);
+        const _config_2 = resolveUserAgentConfig(_config_1);
+        const _config_3 = resolveRetryConfig(_config_2);
+        const _config_4 = resolveHostHeaderConfig(_config_3);
+        const _config_5 = resolveEndpointConfig(_config_4);
+        const _config_6 = resolveHttpAuthSchemeConfig(_config_5);
+        const _config_7 = resolveRuntimeExtensions(_config_6, configuration?.extensions || []);
+        this.config = _config_7;
+        this.middlewareStack.use(getSchemaSerdePlugin(this.config));
+        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));
+        this.middlewareStack.use(getHttpAuthSchemeEndpointRuleSetPlugin(this.config, {
+            httpAuthSchemeParametersProvider: defaultWilmaToolsHttpAuthSchemeParametersProvider,
+            identityProviderConfigProvider: async (config) => new DefaultIdentityProviderConfig({
+                "smithy.api#httpBearerAuth": config.token,
+                "wildix.auth#pbx": config.token,
+                "wildix.auth#s2s": config.token,
+            }),
+        }));
+        this.middlewareStack.use(getHttpSigningPlugin(this.config));
+    }
+    destroy() {
+        super.destroy();
+    }
+}

package/dist-es/auth/httpAuthExtensionConfiguration.js

@@ -0,0 +1,38 @@
+export const getHttpAuthExtensionConfiguration = (runtimeConfig) => {
+    const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
+    let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
+    let _token = runtimeConfig.token;
+    return {
+        setHttpAuthScheme(httpAuthScheme) {
+            const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
+            if (index === -1) {
+                _httpAuthSchemes.push(httpAuthScheme);
+            }
+            else {
+                _httpAuthSchemes.splice(index, 1, httpAuthScheme);
+            }
+        },
+        httpAuthSchemes() {
+            return _httpAuthSchemes;
+        },
+        setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
+            _httpAuthSchemeProvider = httpAuthSchemeProvider;
+        },
+        httpAuthSchemeProvider() {
+            return _httpAuthSchemeProvider;
+        },
+        setToken(token) {
+            _token = token;
+        },
+        token() {
+            return _token;
+        },
+    };
+};
+export const resolveHttpAuthRuntimeConfig = (config) => {
+    return {
+        httpAuthSchemes: config.httpAuthSchemes(),
+        httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
+        token: config.token(),
+    };
+};

package/dist-es/auth/httpAuthSchemeProvider.js

@@ -0,0 +1,40 @@
+import { doesIdentityRequireRefresh, isIdentityExpired, memoizeIdentityProvider } from "@smithy/core";
+import { getSmithyContext, normalizeProvider } from "@smithy/core/client";
+export const defaultWilmaToolsHttpAuthSchemeParametersProvider = async (config, context, input) => {
+    return {
+        operation: getSmithyContext(context).operation,
+    };
+};
+function createSmithyApiHttpBearerAuthHttpAuthOption(authParameters) {
+    return {
+        schemeId: "smithy.api#httpBearerAuth",
+    };
+}
+function createWildixAuthPbxHttpAuthOption(authParameters) {
+    return {
+        schemeId: "wildix.auth#pbx",
+    };
+}
+function createWildixAuthS2sHttpAuthOption(authParameters) {
+    return {
+        schemeId: "wildix.auth#s2s",
+    };
+}
+export const defaultWilmaToolsHttpAuthSchemeProvider = (authParameters) => {
+    const options = [];
+    switch (authParameters.operation) {
+        default: {
+            options.push(createSmithyApiHttpBearerAuthHttpAuthOption(authParameters));
+            options.push(createWildixAuthS2sHttpAuthOption(authParameters));
+            options.push(createWildixAuthPbxHttpAuthOption(authParameters));
+        }
+    }
+    return options;
+};
+export const resolveHttpAuthSchemeConfig = (config) => {
+    const token = memoizeIdentityProvider(config.token, isIdentityExpired, doesIdentityRequireRefresh);
+    return Object.assign(config, {
+        authSchemePreference: normalizeProvider(config.authSchemePreference ?? []),
+        token,
+    });
+};

package/dist-es/commands/CreateConnectorCommand.js

@@ -0,0 +1,16 @@
+import { Command as $Command } from "@smithy/core/client";
+import { getEndpointPlugin } from "@smithy/core/endpoints";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { CreateConnector$ } from "../schemas/schemas_0";
+export { $Command };
+export class CreateConnectorCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("WilmaTools", "CreateConnector", {})
+    .n("WilmaToolsClient", "CreateConnectorCommand")
+    .sc(CreateConnector$)
+    .build() {
+}

package/dist-es/commands/CreateToolCommand.js

@@ -0,0 +1,16 @@
+import { Command as $Command } from "@smithy/core/client";
+import { getEndpointPlugin } from "@smithy/core/endpoints";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { CreateTool$ } from "../schemas/schemas_0";
+export { $Command };
+export class CreateToolCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("WilmaTools", "CreateTool", {})
+    .n("WilmaToolsClient", "CreateToolCommand")
+    .sc(CreateTool$)
+    .build() {
+}

package/dist-es/commands/DeleteConnectorCommand.js

@@ -0,0 +1,16 @@
+import { Command as $Command } from "@smithy/core/client";
+import { getEndpointPlugin } from "@smithy/core/endpoints";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { DeleteConnector$ } from "../schemas/schemas_0";
+export { $Command };
+export class DeleteConnectorCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("WilmaTools", "DeleteConnector", {})
+    .n("WilmaToolsClient", "DeleteConnectorCommand")
+    .sc(DeleteConnector$)
+    .build() {
+}

package/dist-es/commands/DeleteToolCommand.js

@@ -0,0 +1,16 @@
+import { Command as $Command } from "@smithy/core/client";
+import { getEndpointPlugin } from "@smithy/core/endpoints";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { DeleteTool$ } from "../schemas/schemas_0";
+export { $Command };
+export class DeleteToolCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("WilmaTools", "DeleteTool", {})
+    .n("WilmaToolsClient", "DeleteToolCommand")
+    .sc(DeleteTool$)
+    .build() {
+}

package/dist-es/commands/DescribeCapabilitiesCommand.js

@@ -0,0 +1,16 @@
+import { Command as $Command } from "@smithy/core/client";
+import { getEndpointPlugin } from "@smithy/core/endpoints";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { DescribeCapabilities$ } from "../schemas/schemas_0";
+export { $Command };
+export class DescribeCapabilitiesCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("WilmaTools", "DescribeCapabilities", {})
+    .n("WilmaToolsClient", "DescribeCapabilitiesCommand")
+    .sc(DescribeCapabilities$)
+    .build() {
+}

package/dist-es/commands/DescribeConnectorsCommand.js

@@ -0,0 +1,16 @@
+import { Command as $Command } from "@smithy/core/client";
+import { getEndpointPlugin } from "@smithy/core/endpoints";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { DescribeConnectors$ } from "../schemas/schemas_0";
+export { $Command };
+export class DescribeConnectorsCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("WilmaTools", "DescribeConnectors", {})
+    .n("WilmaToolsClient", "DescribeConnectorsCommand")
+    .sc(DescribeConnectors$)
+    .build() {
+}

package/dist-es/commands/DescribeToolsCommand.js

@@ -0,0 +1,16 @@
+import { Command as $Command } from "@smithy/core/client";
+import { getEndpointPlugin } from "@smithy/core/endpoints";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { DescribeTools$ } from "../schemas/schemas_0";
+export { $Command };
+export class DescribeToolsCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("WilmaTools", "DescribeTools", {})
+    .n("WilmaToolsClient", "DescribeToolsCommand")
+    .sc(DescribeTools$)
+    .build() {
+}

package/dist-es/commands/DiscoverToolsCommand.js

@@ -0,0 +1,16 @@
+import { Command as $Command } from "@smithy/core/client";
+import { getEndpointPlugin } from "@smithy/core/endpoints";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { DiscoverTools$ } from "../schemas/schemas_0";
+export { $Command };
+export class DiscoverToolsCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("WilmaTools", "DiscoverTools", {})
+    .n("WilmaToolsClient", "DiscoverToolsCommand")
+    .sc(DiscoverTools$)
+    .build() {
+}

package/dist-es/commands/ExecuteConnectorCommand.js

@@ -0,0 +1,16 @@
+import { Command as $Command } from "@smithy/core/client";
+import { getEndpointPlugin } from "@smithy/core/endpoints";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { ExecuteConnector$ } from "../schemas/schemas_0";
+export { $Command };
+export class ExecuteConnectorCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("WilmaTools", "ExecuteConnector", {})
+    .n("WilmaToolsClient", "ExecuteConnectorCommand")
+    .sc(ExecuteConnector$)
+    .build() {
+}

package/dist-es/commands/ExecuteToolCommand.js

@@ -0,0 +1,16 @@
+import { Command as $Command } from "@smithy/core/client";
+import { getEndpointPlugin } from "@smithy/core/endpoints";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { ExecuteTool$ } from "../schemas/schemas_0";
+export { $Command };
+export class ExecuteToolCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("WilmaTools", "ExecuteTool", {})
+    .n("WilmaToolsClient", "ExecuteToolCommand")
+    .sc(ExecuteTool$)
+    .build() {
+}

package/dist-es/commands/GetConnectorCommand.js

@@ -0,0 +1,16 @@
+import { Command as $Command } from "@smithy/core/client";
+import { getEndpointPlugin } from "@smithy/core/endpoints";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { GetConnector$ } from "../schemas/schemas_0";
+export { $Command };
+export class GetConnectorCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("WilmaTools", "GetConnector", {})
+    .n("WilmaToolsClient", "GetConnectorCommand")
+    .sc(GetConnector$)
+    .build() {
+}

package/dist-es/commands/GetConnectorDefinitionCommand.js

@@ -0,0 +1,16 @@
+import { Command as $Command } from "@smithy/core/client";
+import { getEndpointPlugin } from "@smithy/core/endpoints";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { GetConnectorDefinition$ } from "../schemas/schemas_0";
+export { $Command };
+export class GetConnectorDefinitionCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("WilmaTools", "GetConnectorDefinition", {})
+    .n("WilmaToolsClient", "GetConnectorDefinitionCommand")
+    .sc(GetConnectorDefinition$)
+    .build() {
+}

package/dist-es/commands/GetToolCommand.js

@@ -0,0 +1,16 @@
+import { Command as $Command } from "@smithy/core/client";
+import { getEndpointPlugin } from "@smithy/core/endpoints";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { GetTool$ } from "../schemas/schemas_0";
+export { $Command };
+export class GetToolCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("WilmaTools", "GetTool", {})
+    .n("WilmaToolsClient", "GetToolCommand")
+    .sc(GetTool$)
+    .build() {
+}

package/dist-es/commands/ListConnectorDefinitionsCommand.js

@@ -0,0 +1,16 @@
+import { Command as $Command } from "@smithy/core/client";
+import { getEndpointPlugin } from "@smithy/core/endpoints";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { ListConnectorDefinitions$ } from "../schemas/schemas_0";
+export { $Command };
+export class ListConnectorDefinitionsCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("WilmaTools", "ListConnectorDefinitions", {})
+    .n("WilmaToolsClient", "ListConnectorDefinitionsCommand")
+    .sc(ListConnectorDefinitions$)
+    .build() {
+}

package/dist-es/commands/ListConnectorsCommand.js

@@ -0,0 +1,16 @@
+import { Command as $Command } from "@smithy/core/client";
+import { getEndpointPlugin } from "@smithy/core/endpoints";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { ListConnectors$ } from "../schemas/schemas_0";
+export { $Command };
+export class ListConnectorsCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("WilmaTools", "ListConnectors", {})
+    .n("WilmaToolsClient", "ListConnectorsCommand")
+    .sc(ListConnectors$)
+    .build() {
+}

package/dist-es/commands/ListToolsCommand.js

@@ -0,0 +1,16 @@
+import { Command as $Command } from "@smithy/core/client";
+import { getEndpointPlugin } from "@smithy/core/endpoints";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { ListTools$ } from "../schemas/schemas_0";
+export { $Command };
+export class ListToolsCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("WilmaTools", "ListTools", {})
+    .n("WilmaToolsClient", "ListToolsCommand")
+    .sc(ListTools$)
+    .build() {
+}

package/dist-es/commands/ResolveConnectorConfigurationCommand.js

@@ -0,0 +1,16 @@
+import { Command as $Command } from "@smithy/core/client";
+import { getEndpointPlugin } from "@smithy/core/endpoints";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { ResolveConnectorConfiguration$ } from "../schemas/schemas_0";
+export { $Command };
+export class ResolveConnectorConfigurationCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("WilmaTools", "ResolveConnectorConfiguration", {})
+    .n("WilmaToolsClient", "ResolveConnectorConfigurationCommand")
+    .sc(ResolveConnectorConfiguration$)
+    .build() {
+}

package/dist-es/commands/UpdateConnectorCommand.js

@@ -0,0 +1,16 @@
+import { Command as $Command } from "@smithy/core/client";
+import { getEndpointPlugin } from "@smithy/core/endpoints";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { UpdateConnector$ } from "../schemas/schemas_0";
+export { $Command };
+export class UpdateConnectorCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("WilmaTools", "UpdateConnector", {})
+    .n("WilmaToolsClient", "UpdateConnectorCommand")
+    .sc(UpdateConnector$)
+    .build() {
+}

package/dist-es/commands/UpdateToolCommand.js

@@ -0,0 +1,16 @@
+import { Command as $Command } from "@smithy/core/client";
+import { getEndpointPlugin } from "@smithy/core/endpoints";
+import { commonParams } from "../endpoint/EndpointParameters";
+import { UpdateTool$ } from "../schemas/schemas_0";
+export { $Command };
+export class UpdateToolCommand extends $Command
+    .classBuilder()
+    .ep(commonParams)
+    .m(function (Command, cs, config, o) {
+    return [getEndpointPlugin(config, Command.getEndpointParameterInstructions())];
+})
+    .s("WilmaTools", "UpdateTool", {})
+    .n("WilmaToolsClient", "UpdateToolCommand")
+    .sc(UpdateTool$)
+    .build() {
+}

package/dist-es/commands/index.js

@@ -0,0 +1,19 @@
+export * from "./CreateConnectorCommand";
+export * from "./CreateToolCommand";
+export * from "./DeleteConnectorCommand";
+export * from "./DeleteToolCommand";
+export * from "./DescribeCapabilitiesCommand";
+export * from "./DescribeConnectorsCommand";
+export * from "./DescribeToolsCommand";
+export * from "./DiscoverToolsCommand";
+export * from "./ExecuteConnectorCommand";
+export * from "./ExecuteToolCommand";
+export * from "./GetConnectorCommand";
+export * from "./GetConnectorDefinitionCommand";
+export * from "./GetToolCommand";
+export * from "./ListConnectorDefinitionsCommand";
+export * from "./ListConnectorsCommand";
+export * from "./ListToolsCommand";
+export * from "./ResolveConnectorConfigurationCommand";
+export * from "./UpdateConnectorCommand";
+export * from "./UpdateToolCommand";

package/dist-es/endpoint/EndpointParameters.js

@@ -0,0 +1,12 @@
+const clientContextParamDefaults = {};
+export const resolveClientEndpointParameters = (options) => {
+    return Object.assign(options, {
+        env: options.env ?? "prod",
+        defaultSigningName: "",
+        clientContextParams: Object.assign(clientContextParamDefaults, options.clientContextParams),
+    });
+};
+export const commonParams = {
+    env: { type: "clientContextParams", name: "env" },
+    endpoint: { type: "builtInParams", name: "endpoint" },
+};

package/dist-es/endpoint/bdd.js

@@ -0,0 +1,25 @@
+import { BinaryDecisionDiagram } from "@smithy/core/endpoints";
+const a = "stringEquals", b = { "ref": "endpoint" }, c = { "ref": "env" };
+const _data = {
+    conditions: [
+        ["isSet", [b]],
+        [a, [c, "stable"]],
+        [a, [c, "stage"]]
+    ],
+    results: [
+        [-1],
+        [b, {}],
+        ["https://api-stable.wilma.wildix.com", {}],
+        ["https://api-stage.wilma.wildix.com", {}],
+        ["https://api.wilma.wildix.com", {}]
+    ]
+};
+const root = 2;
+const r = 100_000_000;
+const nodes = new Int32Array([
+    -1, 1, -1,
+    0, r + 1, 3,
+    1, r + 2, 4,
+    2, r + 3, r + 4,
+]);
+export const bdd = BinaryDecisionDiagram.from(nodes, root, _data.conditions, _data.results);

package/dist-es/endpoint/endpointResolver.js

@@ -0,0 +1,12 @@
+import { decideEndpoint, EndpointCache } from "@smithy/core/endpoints";
+import { bdd } from "./bdd";
+const cache = new EndpointCache({
+    size: 50,
+    params: ["endpoint", "env"],
+});
+export const defaultEndpointResolver = (endpointParams, context = {}) => {
+    return cache.get(endpointParams, () => decideEndpoint(bdd, {
+        endpointParams: endpointParams,
+        logger: context.logger,
+    }));
+};

package/dist-es/extensionConfiguration.js

@@ -0,0 +1 @@
+export {};

package/dist-es/index.js

@@ -0,0 +1,9 @@
+export * from "./WilmaToolsClient";
+export * from "./WilmaTools";
+export * from "./commands";
+export * from "./schemas/schemas_0";
+export * from "./pagination";
+export * from "./models/enums";
+export * from "./models/errors";
+export * from "./models/models_0";
+export { WilmaToolsServiceException } from "./models/WilmaToolsServiceException";

package/dist-es/models/WilmaToolsServiceException.js

@@ -0,0 +1,8 @@
+import { ServiceException as __ServiceException, } from "@smithy/core/client";
+export { __ServiceException };
+export class WilmaToolsServiceException extends __ServiceException {
+    constructor(options) {
+        super(options);
+        Object.setPrototypeOf(this, WilmaToolsServiceException.prototype);
+    }
+}

package/dist-es/models/enums.js

@@ -0,0 +1,9 @@
+export const ConnectorAuthorizationMode = {
+    SHARED: "shared",
+    USER: "user",
+};
+export const ConnectorToolAccess = {
+    DESTRUCTIVE: "destructive",
+    READ: "read",
+    WRITE: "write",
+};