@aws-sdk/client-datazone 3.425.0

package/dist-es/commands/CreateAssetTypeCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { CreateAssetTypeInputFilterSensitiveLog, CreateAssetTypeOutputFilterSensitiveLog, } from "../models/models_0";
+import { de_CreateAssetTypeCommand, se_CreateAssetTypeCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateAssetTypeCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateAssetTypeCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "DataZoneClient";
+        const commandName = "CreateAssetTypeCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateAssetTypeInputFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateAssetTypeOutputFilterSensitiveLog,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "DataZone",
+                operation: "CreateAssetType",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateAssetTypeCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateAssetTypeCommand(output, context);
+    }
+}

package/dist-es/commands/CreateDataSourceCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { CreateDataSourceInputFilterSensitiveLog, CreateDataSourceOutputFilterSensitiveLog, } from "../models/models_0";
+import { de_CreateDataSourceCommand, se_CreateDataSourceCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateDataSourceCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateDataSourceCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "DataZoneClient";
+        const commandName = "CreateDataSourceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateDataSourceInputFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateDataSourceOutputFilterSensitiveLog,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "DataZone",
+                operation: "CreateDataSource",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateDataSourceCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateDataSourceCommand(output, context);
+    }
+}

package/dist-es/commands/CreateDomainCommand.js

@@ -0,0 +1,46 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_CreateDomainCommand, se_CreateDomainCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateDomainCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateDomainCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "DataZoneClient";
+        const commandName = "CreateDomainCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "DataZone",
+                operation: "CreateDomain",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateDomainCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateDomainCommand(output, context);
+    }
+}

package/dist-es/commands/CreateEnvironmentCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { CreateEnvironmentOutputFilterSensitiveLog, } from "../models/models_0";
+import { de_CreateEnvironmentCommand, se_CreateEnvironmentCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateEnvironmentCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateEnvironmentCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "DataZoneClient";
+        const commandName = "CreateEnvironmentCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: CreateEnvironmentOutputFilterSensitiveLog,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "DataZone",
+                operation: "CreateEnvironment",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateEnvironmentCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateEnvironmentCommand(output, context);
+    }
+}

package/dist-es/commands/CreateEnvironmentProfileCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { CreateEnvironmentProfileInputFilterSensitiveLog, CreateEnvironmentProfileOutputFilterSensitiveLog, } from "../models/models_0";
+import { de_CreateEnvironmentProfileCommand, se_CreateEnvironmentProfileCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateEnvironmentProfileCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateEnvironmentProfileCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "DataZoneClient";
+        const commandName = "CreateEnvironmentProfileCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateEnvironmentProfileInputFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateEnvironmentProfileOutputFilterSensitiveLog,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "DataZone",
+                operation: "CreateEnvironmentProfile",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateEnvironmentProfileCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateEnvironmentProfileCommand(output, context);
+    }
+}

package/dist-es/commands/CreateFormTypeCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { CreateFormTypeInputFilterSensitiveLog, CreateFormTypeOutputFilterSensitiveLog, } from "../models/models_0";
+import { de_CreateFormTypeCommand, se_CreateFormTypeCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateFormTypeCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateFormTypeCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "DataZoneClient";
+        const commandName = "CreateFormTypeCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateFormTypeInputFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateFormTypeOutputFilterSensitiveLog,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "DataZone",
+                operation: "CreateFormType",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateFormTypeCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateFormTypeCommand(output, context);
+    }
+}

package/dist-es/commands/CreateGlossaryCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { CreateGlossaryInputFilterSensitiveLog, CreateGlossaryOutputFilterSensitiveLog, } from "../models/models_0";
+import { de_CreateGlossaryCommand, se_CreateGlossaryCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateGlossaryCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateGlossaryCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "DataZoneClient";
+        const commandName = "CreateGlossaryCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateGlossaryInputFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateGlossaryOutputFilterSensitiveLog,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "DataZone",
+                operation: "CreateGlossary",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateGlossaryCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateGlossaryCommand(output, context);
+    }
+}

package/dist-es/commands/CreateGlossaryTermCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { CreateGlossaryTermInputFilterSensitiveLog, CreateGlossaryTermOutputFilterSensitiveLog, } from "../models/models_0";
+import { de_CreateGlossaryTermCommand, se_CreateGlossaryTermCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateGlossaryTermCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateGlossaryTermCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "DataZoneClient";
+        const commandName = "CreateGlossaryTermCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateGlossaryTermInputFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateGlossaryTermOutputFilterSensitiveLog,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "DataZone",
+                operation: "CreateGlossaryTerm",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateGlossaryTermCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateGlossaryTermCommand(output, context);
+    }
+}

package/dist-es/commands/CreateGroupProfileCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { CreateGroupProfileOutputFilterSensitiveLog, } from "../models/models_0";
+import { de_CreateGroupProfileCommand, se_CreateGroupProfileCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateGroupProfileCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateGroupProfileCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "DataZoneClient";
+        const commandName = "CreateGroupProfileCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: CreateGroupProfileOutputFilterSensitiveLog,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "DataZone",
+                operation: "CreateGroupProfile",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateGroupProfileCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateGroupProfileCommand(output, context);
+    }
+}

package/dist-es/commands/CreateListingChangeSetCommand.js

@@ -0,0 +1,46 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_CreateListingChangeSetCommand, se_CreateListingChangeSetCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateListingChangeSetCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateListingChangeSetCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "DataZoneClient";
+        const commandName = "CreateListingChangeSetCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "DataZone",
+                operation: "CreateListingChangeSet",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateListingChangeSetCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateListingChangeSetCommand(output, context);
+    }
+}

package/dist-es/commands/CreateProjectCommand.js

@@ -0,0 +1,47 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { CreateProjectInputFilterSensitiveLog, CreateProjectOutputFilterSensitiveLog, } from "../models/models_0";
+import { de_CreateProjectCommand, se_CreateProjectCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateProjectCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateProjectCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "DataZoneClient";
+        const commandName = "CreateProjectCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateProjectInputFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateProjectOutputFilterSensitiveLog,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "DataZone",
+                operation: "CreateProject",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateProjectCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateProjectCommand(output, context);
+    }
+}

package/dist-es/commands/CreateProjectMembershipCommand.js

@@ -0,0 +1,46 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_CreateProjectMembershipCommand, se_CreateProjectMembershipCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateProjectMembershipCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateProjectMembershipCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "DataZoneClient";
+        const commandName = "CreateProjectMembershipCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "DataZone",
+                operation: "CreateProjectMembership",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateProjectMembershipCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateProjectMembershipCommand(output, context);
+    }
+}

package/dist-es/commands/CreateSubscriptionGrantCommand.js

@@ -0,0 +1,46 @@
+import { getEndpointPlugin } from "@smithy/middleware-endpoint";
+import { getSerdePlugin } from "@smithy/middleware-serde";
+import { Command as $Command } from "@smithy/smithy-client";
+import { SMITHY_CONTEXT_KEY, } from "@smithy/types";
+import { de_CreateSubscriptionGrantCommand, se_CreateSubscriptionGrantCommand } from "../protocols/Aws_restJson1";
+export { $Command };
+export class CreateSubscriptionGrantCommand extends $Command {
+    static getEndpointParameterInstructions() {
+        return {
+            UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
+            Endpoint: { type: "builtInParams", name: "endpoint" },
+            Region: { type: "builtInParams", name: "region" },
+        };
+    }
+    constructor(input) {
+        super();
+        this.input = input;
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateSubscriptionGrantCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "DataZoneClient";
+        const commandName = "CreateSubscriptionGrantCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: (_) => _,
+            outputFilterSensitiveLog: (_) => _,
+            [SMITHY_CONTEXT_KEY]: {
+                service: "DataZone",
+                operation: "CreateSubscriptionGrant",
+            },
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return se_CreateSubscriptionGrantCommand(input, context);
+    }
+    deserialize(output, context) {
+        return de_CreateSubscriptionGrantCommand(output, context);
+    }
+}