@aws-sdk/client-codecatalyst 3.222.0

package/dist-es/commands/CreateSourceRepositoryBranchCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { CreateSourceRepositoryBranchRequestFilterSensitiveLog, CreateSourceRepositoryBranchResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1CreateSourceRepositoryBranchCommand, serializeAws_restJson1CreateSourceRepositoryBranchCommand, } from "../protocols/Aws_restJson1";
+export class CreateSourceRepositoryBranchCommand 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" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, CreateSourceRepositoryBranchCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CodeCatalystClient";
+        const commandName = "CreateSourceRepositoryBranchCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: CreateSourceRepositoryBranchRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: CreateSourceRepositoryBranchResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1CreateSourceRepositoryBranchCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1CreateSourceRepositoryBranchCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteAccessTokenCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteAccessTokenRequestFilterSensitiveLog, DeleteAccessTokenResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1DeleteAccessTokenCommand, serializeAws_restJson1DeleteAccessTokenCommand, } from "../protocols/Aws_restJson1";
+export class DeleteAccessTokenCommand 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" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteAccessTokenCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CodeCatalystClient";
+        const commandName = "DeleteAccessTokenCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DeleteAccessTokenRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteAccessTokenResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1DeleteAccessTokenCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1DeleteAccessTokenCommand(output, context);
+    }
+}

package/dist-es/commands/DeleteDevEnvironmentCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { DeleteDevEnvironmentRequestFilterSensitiveLog, DeleteDevEnvironmentResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1DeleteDevEnvironmentCommand, serializeAws_restJson1DeleteDevEnvironmentCommand, } from "../protocols/Aws_restJson1";
+export class DeleteDevEnvironmentCommand 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" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, DeleteDevEnvironmentCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CodeCatalystClient";
+        const commandName = "DeleteDevEnvironmentCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: DeleteDevEnvironmentRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: DeleteDevEnvironmentResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1DeleteDevEnvironmentCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1DeleteDevEnvironmentCommand(output, context);
+    }
+}

package/dist-es/commands/GetDevEnvironmentCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetDevEnvironmentRequestFilterSensitiveLog, GetDevEnvironmentResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1GetDevEnvironmentCommand, serializeAws_restJson1GetDevEnvironmentCommand, } from "../protocols/Aws_restJson1";
+export class GetDevEnvironmentCommand 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" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetDevEnvironmentCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CodeCatalystClient";
+        const commandName = "GetDevEnvironmentCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetDevEnvironmentRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetDevEnvironmentResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1GetDevEnvironmentCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1GetDevEnvironmentCommand(output, context);
+    }
+}

package/dist-es/commands/GetProjectCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetProjectRequestFilterSensitiveLog, GetProjectResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1GetProjectCommand, serializeAws_restJson1GetProjectCommand, } from "../protocols/Aws_restJson1";
+export class GetProjectCommand 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" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetProjectCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CodeCatalystClient";
+        const commandName = "GetProjectCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetProjectRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetProjectResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1GetProjectCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1GetProjectCommand(output, context);
+    }
+}

package/dist-es/commands/GetSourceRepositoryCloneUrlsCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetSourceRepositoryCloneUrlsRequestFilterSensitiveLog, GetSourceRepositoryCloneUrlsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1GetSourceRepositoryCloneUrlsCommand, serializeAws_restJson1GetSourceRepositoryCloneUrlsCommand, } from "../protocols/Aws_restJson1";
+export class GetSourceRepositoryCloneUrlsCommand 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" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetSourceRepositoryCloneUrlsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CodeCatalystClient";
+        const commandName = "GetSourceRepositoryCloneUrlsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetSourceRepositoryCloneUrlsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetSourceRepositoryCloneUrlsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1GetSourceRepositoryCloneUrlsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1GetSourceRepositoryCloneUrlsCommand(output, context);
+    }
+}

package/dist-es/commands/GetSpaceCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetSpaceRequestFilterSensitiveLog, GetSpaceResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1GetSpaceCommand, serializeAws_restJson1GetSpaceCommand, } from "../protocols/Aws_restJson1";
+export class GetSpaceCommand 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" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetSpaceCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CodeCatalystClient";
+        const commandName = "GetSpaceCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetSpaceRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetSpaceResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1GetSpaceCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1GetSpaceCommand(output, context);
+    }
+}

package/dist-es/commands/GetSubscriptionCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetSubscriptionRequestFilterSensitiveLog, GetSubscriptionResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1GetSubscriptionCommand, serializeAws_restJson1GetSubscriptionCommand, } from "../protocols/Aws_restJson1";
+export class GetSubscriptionCommand 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" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetSubscriptionCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CodeCatalystClient";
+        const commandName = "GetSubscriptionCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetSubscriptionRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetSubscriptionResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1GetSubscriptionCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1GetSubscriptionCommand(output, context);
+    }
+}

package/dist-es/commands/GetUserDetailsCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { GetUserDetailsRequestFilterSensitiveLog, GetUserDetailsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1GetUserDetailsCommand, serializeAws_restJson1GetUserDetailsCommand, } from "../protocols/Aws_restJson1";
+export class GetUserDetailsCommand 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" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, GetUserDetailsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CodeCatalystClient";
+        const commandName = "GetUserDetailsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: GetUserDetailsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: GetUserDetailsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1GetUserDetailsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1GetUserDetailsCommand(output, context);
+    }
+}

package/dist-es/commands/ListAccessTokensCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListAccessTokensRequestFilterSensitiveLog, ListAccessTokensResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListAccessTokensCommand, serializeAws_restJson1ListAccessTokensCommand, } from "../protocols/Aws_restJson1";
+export class ListAccessTokensCommand 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" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListAccessTokensCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CodeCatalystClient";
+        const commandName = "ListAccessTokensCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListAccessTokensRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListAccessTokensResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListAccessTokensCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListAccessTokensCommand(output, context);
+    }
+}

package/dist-es/commands/ListDevEnvironmentsCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListDevEnvironmentsRequestFilterSensitiveLog, ListDevEnvironmentsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListDevEnvironmentsCommand, serializeAws_restJson1ListDevEnvironmentsCommand, } from "../protocols/Aws_restJson1";
+export class ListDevEnvironmentsCommand 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" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListDevEnvironmentsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CodeCatalystClient";
+        const commandName = "ListDevEnvironmentsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListDevEnvironmentsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListDevEnvironmentsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListDevEnvironmentsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListDevEnvironmentsCommand(output, context);
+    }
+}

package/dist-es/commands/ListEventLogsCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListEventLogsRequestFilterSensitiveLog, ListEventLogsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListEventLogsCommand, serializeAws_restJson1ListEventLogsCommand, } from "../protocols/Aws_restJson1";
+export class ListEventLogsCommand 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" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListEventLogsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CodeCatalystClient";
+        const commandName = "ListEventLogsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListEventLogsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListEventLogsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListEventLogsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListEventLogsCommand(output, context);
+    }
+}

package/dist-es/commands/ListProjectsCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListProjectsRequestFilterSensitiveLog, ListProjectsResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListProjectsCommand, serializeAws_restJson1ListProjectsCommand, } from "../protocols/Aws_restJson1";
+export class ListProjectsCommand 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" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListProjectsCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CodeCatalystClient";
+        const commandName = "ListProjectsCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListProjectsRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListProjectsResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListProjectsCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListProjectsCommand(output, context);
+    }
+}

package/dist-es/commands/ListSourceRepositoriesCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListSourceRepositoriesRequestFilterSensitiveLog, ListSourceRepositoriesResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListSourceRepositoriesCommand, serializeAws_restJson1ListSourceRepositoriesCommand, } from "../protocols/Aws_restJson1";
+export class ListSourceRepositoriesCommand 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" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListSourceRepositoriesCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CodeCatalystClient";
+        const commandName = "ListSourceRepositoriesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListSourceRepositoriesRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListSourceRepositoriesResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListSourceRepositoriesCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListSourceRepositoriesCommand(output, context);
+    }
+}

package/dist-es/commands/ListSourceRepositoryBranchesCommand.js

@@ -0,0 +1,41 @@
+import { getEndpointPlugin } from "@aws-sdk/middleware-endpoint";
+import { getSerdePlugin } from "@aws-sdk/middleware-serde";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { ListSourceRepositoryBranchesRequestFilterSensitiveLog, ListSourceRepositoryBranchesResponseFilterSensitiveLog, } from "../models/models_0";
+import { deserializeAws_restJson1ListSourceRepositoryBranchesCommand, serializeAws_restJson1ListSourceRepositoryBranchesCommand, } from "../protocols/Aws_restJson1";
+export class ListSourceRepositoryBranchesCommand 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" },
+        };
+    }
+    resolveMiddleware(clientStack, configuration, options) {
+        this.middlewareStack.use(getSerdePlugin(configuration, this.serialize, this.deserialize));
+        this.middlewareStack.use(getEndpointPlugin(configuration, ListSourceRepositoryBranchesCommand.getEndpointParameterInstructions()));
+        const stack = clientStack.concat(this.middlewareStack);
+        const { logger } = configuration;
+        const clientName = "CodeCatalystClient";
+        const commandName = "ListSourceRepositoryBranchesCommand";
+        const handlerExecutionContext = {
+            logger,
+            clientName,
+            commandName,
+            inputFilterSensitiveLog: ListSourceRepositoryBranchesRequestFilterSensitiveLog,
+            outputFilterSensitiveLog: ListSourceRepositoryBranchesResponseFilterSensitiveLog,
+        };
+        const { requestHandler } = configuration;
+        return stack.resolve((request) => requestHandler.handle(request.request, options || {}), handlerExecutionContext);
+    }
+    serialize(input, context) {
+        return serializeAws_restJson1ListSourceRepositoryBranchesCommand(input, context);
+    }
+    deserialize(output, context) {
+        return deserializeAws_restJson1ListSourceRepositoryBranchesCommand(output, context);
+    }
+}