@aws-sdk/client-tnb 3.276.0

package/dist-es/commands/UpdateSolNetworkPackageCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { UpdateSolNetworkPackageInputFilterSensitiveLog, UpdateSolNetworkPackageOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1UpdateSolNetworkPackageCommand, serializeAws_restJson1UpdateSolNetworkPackageCommand, } from "../protocols/Aws_restJson1";
+export class UpdateSolNetworkPackageCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, UpdateSolNetworkPackageCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "TnbClient";
+        const commandName = "UpdateSolNetworkPackageCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: UpdateSolNetworkPackageInputFilterSensitiveLog,
+            outputFilterSensitiveLog: UpdateSolNetworkPackageOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1UpdateSolNetworkPackageCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1UpdateSolNetworkPackageCommand(output, context);
+    }
+}

package/dist-es/commands/ValidateSolFunctionPackageContentCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ValidateSolFunctionPackageContentInputFilterSensitiveLog, ValidateSolFunctionPackageContentOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ValidateSolFunctionPackageContentCommand, serializeAws_restJson1ValidateSolFunctionPackageContentCommand, } from "../protocols/Aws_restJson1";
+export class ValidateSolFunctionPackageContentCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ValidateSolFunctionPackageContentCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "TnbClient";
+        const commandName = "ValidateSolFunctionPackageContentCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ValidateSolFunctionPackageContentInputFilterSensitiveLog,
+            outputFilterSensitiveLog: ValidateSolFunctionPackageContentOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ValidateSolFunctionPackageContentCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ValidateSolFunctionPackageContentCommand(output, context);
+    }
+}

package/dist-es/commands/ValidateSolNetworkPackageContentCommand.js

@@ -0,0 +1,42 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ValidateSolNetworkPackageContentInputFilterSensitiveLog, ValidateSolNetworkPackageContentOutputFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ValidateSolNetworkPackageContentCommand, serializeAws_restJson1ValidateSolNetworkPackageContentCommand, } from "../protocols/Aws_restJson1";
+export class ValidateSolNetworkPackageContentCommand extends $Command {
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+            UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ValidateSolNetworkPackageContentCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "TnbClient";
+        const commandName = "ValidateSolNetworkPackageContentCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ValidateSolNetworkPackageContentInputFilterSensitiveLog,
+            outputFilterSensitiveLog: ValidateSolNetworkPackageContentOutputFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ValidateSolNetworkPackageContentCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ValidateSolNetworkPackageContentCommand(output, context);
+    }
+}

package/dist-es/commands/index.js

@@ -0,0 +1,33 @@
+export * from "./CancelSolNetworkOperationCommand";
+export * from "./CreateSolFunctionPackageCommand";
+export * from "./CreateSolNetworkInstanceCommand";
+export * from "./CreateSolNetworkPackageCommand";
+export * from "./DeleteSolFunctionPackageCommand";
+export * from "./DeleteSolNetworkInstanceCommand";
+export * from "./DeleteSolNetworkPackageCommand";
+export * from "./GetSolFunctionInstanceCommand";
+export * from "./GetSolFunctionPackageCommand";
+export * from "./GetSolFunctionPackageContentCommand";
+export * from "./GetSolFunctionPackageDescriptorCommand";
+export * from "./GetSolNetworkInstanceCommand";
+export * from "./GetSolNetworkOperationCommand";
+export * from "./GetSolNetworkPackageCommand";
+export * from "./GetSolNetworkPackageContentCommand";
+export * from "./GetSolNetworkPackageDescriptorCommand";
+export * from "./InstantiateSolNetworkInstanceCommand";
+export * from "./ListSolFunctionInstancesCommand";
+export * from "./ListSolFunctionPackagesCommand";
+export * from "./ListSolNetworkInstancesCommand";
+export * from "./ListSolNetworkOperationsCommand";
+export * from "./ListSolNetworkPackagesCommand";
+export * from "./ListTagsForResourceCommand";
+export * from "./PutSolFunctionPackageContentCommand";
+export * from "./PutSolNetworkPackageContentCommand";
+export * from "./TagResourceCommand";
+export * from "./TerminateSolNetworkInstanceCommand";
+export * from "./UntagResourceCommand";
+export * from "./UpdateSolFunctionPackageCommand";
+export * from "./UpdateSolNetworkInstanceCommand";
+export * from "./UpdateSolNetworkPackageCommand";
+export * from "./ValidateSolFunctionPackageContentCommand";
+export * from "./ValidateSolNetworkPackageContentCommand";

package/dist-es/endpoint/EndpointParameters.js

@@ -0,0 +1,8 @@
+export const resolveClientEndpointParameters = (options) => {
+    return {
+        ...options,
+        useDualstackEndpoint: options.useDualstackEndpoint ?? false,
+        useFipsEndpoint: options.useFipsEndpoint ?? false,
+        defaultSigningName: "tnb",
+    };
+};

package/dist-es/endpoint/endpointResolver.js

@@ -0,0 +1,8 @@
+import { resolveEndpoint } from "@aws-sdk/util-endpoints";
+import { ruleSet } from "./ruleset";
+export const defaultEndpointResolver = (endpointParams, context = {}) => {
+    return resolveEndpoint(ruleSet, {
+        endpointParams: endpointParams,
+        logger: context.logger,
+    });
+};

package/dist-es/endpoint/ruleset.js

@@ -0,0 +1,4 @@
+const q = "required", r = "fn", s = "argv", t = "ref";
+const a = "isSet", b = "tree", c = "error", d = "endpoint", e = "PartitionResult", f = { [q]: false, "type": "String" }, g = { [q]: true, "default": false, "type": "Boolean" }, h = { [t]: "Endpoint" }, i = { [r]: "booleanEquals", [s]: [{ [t]: "UseFIPS" }, true] }, j = { [r]: "booleanEquals", [s]: [{ [t]: "UseDualStack" }, true] }, k = {}, l = { [r]: "booleanEquals", [s]: [true, { [r]: "getAttr", [s]: [{ [t]: e }, "supportsFIPS"] }] }, m = { [r]: "booleanEquals", [s]: [true, { [r]: "getAttr", [s]: [{ [t]: e }, "supportsDualStack"] }] }, n = [i], o = [j], p = [{ [t]: "Region" }];
+const _data = { version: "1.0", parameters: { Region: f, UseDualStack: g, UseFIPS: g, Endpoint: f }, rules: [{ conditions: [{ [r]: a, [s]: [h] }], type: b, rules: [{ conditions: n, error: "Invalid Configuration: FIPS and custom endpoint are not supported", type: c }, { type: b, rules: [{ conditions: o, error: "Invalid Configuration: Dualstack and custom endpoint are not supported", type: c }, { endpoint: { url: h, properties: k, headers: k }, type: d }] }] }, { type: b, rules: [{ conditions: [{ [r]: a, [s]: p }], type: b, rules: [{ conditions: [{ [r]: "aws.partition", [s]: p, assign: e }], type: b, rules: [{ conditions: [i, j], type: b, rules: [{ conditions: [l, m], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://tnb-fips.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "FIPS and DualStack are enabled, but this partition does not support one or both", type: c }] }, { conditions: n, type: b, rules: [{ conditions: [l], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://tnb-fips.{Region}.{PartitionResult#dnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "FIPS is enabled but this partition does not support FIPS", type: c }] }, { conditions: o, type: b, rules: [{ conditions: [m], type: b, rules: [{ type: b, rules: [{ endpoint: { url: "https://tnb.{Region}.{PartitionResult#dualStackDnsSuffix}", properties: k, headers: k }, type: d }] }] }, { error: "DualStack is enabled but this partition does not support DualStack", type: c }] }, { type: b, rules: [{ endpoint: { url: "https://tnb.{Region}.{PartitionResult#dnsSuffix}", properties: k, headers: k }, type: d }] }] }] }, { error: "Invalid Configuration: Missing Region", type: c }] }] };
+export const ruleSet = _data;

package/dist-es/index.js

@@ -0,0 +1,6 @@
+export * from "./Tnb";
+export * from "./TnbClient";
+export * from "./commands";
+export * from "./models";
+export * from "./pagination";
+export { TnbServiceException } from "./models/TnbServiceException";

package/dist-es/models/TnbServiceException.js

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

package/dist-es/models/index.js

@@ -0,0 +1 @@
+export * from "./models_0";

package/dist-es/models/models_0.js

@@ -0,0 +1,455 @@
+import { SENSITIVE_STRING } from "@aws-sdk/smithy-client";
+import { TnbServiceException as __BaseException } from "./TnbServiceException";
+export class AccessDeniedException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "AccessDeniedException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "AccessDeniedException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, AccessDeniedException.prototype);
+    }
+}
+export class InternalServerException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "InternalServerException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "InternalServerException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, InternalServerException.prototype);
+    }
+}
+export class ResourceNotFoundException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ResourceNotFoundException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+    }
+}
+export class ThrottlingException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ThrottlingException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ThrottlingException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ThrottlingException.prototype);
+    }
+}
+export class ValidationException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ValidationException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ValidationException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ValidationException.prototype);
+    }
+}
+export var OnboardingState;
+(function (OnboardingState) {
+    OnboardingState["CREATED"] = "CREATED";
+    OnboardingState["ERROR"] = "ERROR";
+    OnboardingState["ONBOARDED"] = "ONBOARDED";
+})(OnboardingState || (OnboardingState = {}));
+export var OperationalState;
+(function (OperationalState) {
+    OperationalState["DISABLED"] = "DISABLED";
+    OperationalState["ENABLED"] = "ENABLED";
+})(OperationalState || (OperationalState = {}));
+export var UsageState;
+(function (UsageState) {
+    UsageState["IN_USE"] = "IN_USE";
+    UsageState["NOT_IN_USE"] = "NOT_IN_USE";
+})(UsageState || (UsageState = {}));
+export class ServiceQuotaExceededException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ServiceQuotaExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ServiceQuotaExceededException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
+    }
+}
+export var NsdOnboardingState;
+(function (NsdOnboardingState) {
+    NsdOnboardingState["CREATED"] = "CREATED";
+    NsdOnboardingState["ERROR"] = "ERROR";
+    NsdOnboardingState["ONBOARDED"] = "ONBOARDED";
+})(NsdOnboardingState || (NsdOnboardingState = {}));
+export var NsdOperationalState;
+(function (NsdOperationalState) {
+    NsdOperationalState["DISABLED"] = "DISABLED";
+    NsdOperationalState["ENABLED"] = "ENABLED";
+})(NsdOperationalState || (NsdOperationalState = {}));
+export var NsdUsageState;
+(function (NsdUsageState) {
+    NsdUsageState["IN_USE"] = "IN_USE";
+    NsdUsageState["NOT_IN_USE"] = "NOT_IN_USE";
+})(NsdUsageState || (NsdUsageState = {}));
+export var DescriptorContentType;
+(function (DescriptorContentType) {
+    DescriptorContentType["TEXT_PLAIN"] = "text/plain";
+})(DescriptorContentType || (DescriptorContentType = {}));
+export var VnfOperationalState;
+(function (VnfOperationalState) {
+    VnfOperationalState["STARTED"] = "STARTED";
+    VnfOperationalState["STOPPED"] = "STOPPED";
+})(VnfOperationalState || (VnfOperationalState = {}));
+export var VnfInstantiationState;
+(function (VnfInstantiationState) {
+    VnfInstantiationState["INSTANTIATED"] = "INSTANTIATED";
+    VnfInstantiationState["NOT_INSTANTIATED"] = "NOT_INSTANTIATED";
+})(VnfInstantiationState || (VnfInstantiationState = {}));
+export var PackageContentType;
+(function (PackageContentType) {
+    PackageContentType["APPLICATION_ZIP"] = "application/zip";
+})(PackageContentType || (PackageContentType = {}));
+export var NsState;
+(function (NsState) {
+    NsState["DELETED"] = "DELETED";
+    NsState["IMPAIRED"] = "IMPAIRED";
+    NsState["INSTANTIATED"] = "INSTANTIATED";
+    NsState["INSTANTIATE_IN_PROGRESS"] = "INSTANTIATE_IN_PROGRESS";
+    NsState["NOT_INSTANTIATED"] = "NOT_INSTANTIATED";
+    NsState["STOPPED"] = "STOPPED";
+    NsState["TERMINATE_IN_PROGRESS"] = "TERMINATE_IN_PROGRESS";
+    NsState["UPDATE_IN_PROGRESS"] = "UPDATE_IN_PROGRESS";
+})(NsState || (NsState = {}));
+export var LcmOperationType;
+(function (LcmOperationType) {
+    LcmOperationType["INSTANTIATE"] = "INSTANTIATE";
+    LcmOperationType["TERMINATE"] = "TERMINATE";
+    LcmOperationType["UPDATE"] = "UPDATE";
+})(LcmOperationType || (LcmOperationType = {}));
+export var NsLcmOperationState;
+(function (NsLcmOperationState) {
+    NsLcmOperationState["CANCELLED"] = "CANCELLED";
+    NsLcmOperationState["CANCELLING"] = "CANCELLING";
+    NsLcmOperationState["COMPLETED"] = "COMPLETED";
+    NsLcmOperationState["FAILED"] = "FAILED";
+    NsLcmOperationState["PROCESSING"] = "PROCESSING";
+})(NsLcmOperationState || (NsLcmOperationState = {}));
+export var TaskStatus;
+(function (TaskStatus) {
+    TaskStatus["CANCELLED"] = "CANCELLED";
+    TaskStatus["COMPLETED"] = "COMPLETED";
+    TaskStatus["ERROR"] = "ERROR";
+    TaskStatus["IN_PROGRESS"] = "IN_PROGRESS";
+    TaskStatus["SCHEDULED"] = "SCHEDULED";
+    TaskStatus["SKIPPED"] = "SKIPPED";
+    TaskStatus["STARTED"] = "STARTED";
+})(TaskStatus || (TaskStatus = {}));
+export var UpdateSolNetworkType;
+(function (UpdateSolNetworkType) {
+    UpdateSolNetworkType["MODIFY_VNF_INFORMATION"] = "MODIFY_VNF_INFORMATION";
+})(UpdateSolNetworkType || (UpdateSolNetworkType = {}));
+export const CancelSolNetworkOperationInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateSolFunctionPackageInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.tags && { tags: SENSITIVE_STRING }),
+});
+export const CreateSolFunctionPackageOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.tags && { tags: SENSITIVE_STRING }),
+});
+export const CreateSolNetworkInstanceInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.tags && { tags: SENSITIVE_STRING }),
+});
+export const CreateSolNetworkInstanceOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.tags && { tags: SENSITIVE_STRING }),
+});
+export const CreateSolNetworkPackageInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.tags && { tags: SENSITIVE_STRING }),
+});
+export const CreateSolNetworkPackageOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.tags && { tags: SENSITIVE_STRING }),
+});
+export const DeleteSolFunctionPackageInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteSolNetworkInstanceInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteSolNetworkPackageInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ErrorInfoFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ToscaOverrideFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const FunctionArtifactMetaFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSolFunctionInstanceInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSolVnfcResourceInfoMetadataFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSolVnfcResourceInfoFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSolVnfInfoFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSolFunctionInstanceMetadataFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSolFunctionInstanceOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.tags && { tags: SENSITIVE_STRING }),
+});
+export const GetSolFunctionPackageInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSolFunctionPackageMetadataFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSolFunctionPackageOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.tags && { tags: SENSITIVE_STRING }),
+});
+export const GetSolFunctionPackageContentInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSolFunctionPackageContentOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSolFunctionPackageDescriptorInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSolFunctionPackageDescriptorOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSolInstantiatedVnfInfoFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSolNetworkInstanceInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const LcmOperationInfoFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSolNetworkInstanceMetadataFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSolNetworkInstanceOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.tags && { tags: SENSITIVE_STRING }),
+});
+export const GetSolNetworkOperationInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ProblemDetailsFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSolNetworkOperationMetadataFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSolNetworkOperationTaskDetailsFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSolNetworkOperationOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.tags && { tags: SENSITIVE_STRING }),
+});
+export const GetSolNetworkPackageInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const NetworkArtifactMetaFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSolNetworkPackageMetadataFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSolNetworkPackageOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.tags && { tags: SENSITIVE_STRING }),
+});
+export const GetSolNetworkPackageContentInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSolNetworkPackageContentOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSolNetworkPackageDescriptorInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSolNetworkPackageDescriptorOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const InstantiateSolNetworkInstanceInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const InstantiateSolNetworkInstanceOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSolFunctionInstanceMetadataFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSolFunctionInstanceInfoFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSolFunctionInstancesInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSolFunctionInstancesOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSolFunctionPackageMetadataFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSolFunctionPackageInfoFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSolFunctionPackagesInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSolFunctionPackagesOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSolNetworkInstanceMetadataFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSolNetworkInstanceInfoFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSolNetworkInstancesInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSolNetworkInstancesOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSolNetworkOperationsInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSolNetworkOperationsMetadataFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSolNetworkOperationsInfoFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSolNetworkOperationsOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSolNetworkPackageMetadataFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSolNetworkPackageInfoFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSolNetworkPackagesInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSolNetworkPackagesOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListTagsForResourceInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListTagsForResourceOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.tags && { tags: SENSITIVE_STRING }),
+});
+export const PutSolFunctionPackageContentInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const PutSolFunctionPackageContentMetadataFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const PutSolFunctionPackageContentOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const PutSolNetworkPackageContentInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const PutSolNetworkPackageContentMetadataFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const PutSolNetworkPackageContentOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const TagResourceInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.tags && { tags: SENSITIVE_STRING }),
+});
+export const TagResourceOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const TerminateSolNetworkInstanceInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const TerminateSolNetworkInstanceOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UntagResourceInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UntagResourceOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateSolFunctionPackageInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateSolFunctionPackageOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateSolNetworkModifyFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateSolNetworkInstanceInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateSolNetworkInstanceOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateSolNetworkPackageInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateSolNetworkPackageOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ValidateSolFunctionPackageContentInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ValidateSolFunctionPackageContentMetadataFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ValidateSolFunctionPackageContentOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ValidateSolNetworkPackageContentInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ValidateSolNetworkPackageContentMetadataFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ValidateSolNetworkPackageContentOutputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});

package/dist-es/pagination/Interfaces.js

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