@aws-sdk/client-codecatalyst 3.222.0

package/dist-types/commands/GetSpaceCommand.d.ts

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CodeCatalystClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CodeCatalystClient";
+import { GetSpaceRequest, GetSpaceResponse } from "../models/models_0";
+export interface GetSpaceCommandInput extends GetSpaceRequest {
+}
+export interface GetSpaceCommandOutput extends GetSpaceResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns information about an space.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CodeCatalystClient, GetSpaceCommand } from "@aws-sdk/client-codecatalyst"; // ES Modules import
+ * // const { CodeCatalystClient, GetSpaceCommand } = require("@aws-sdk/client-codecatalyst"); // CommonJS import
+ * const client = new CodeCatalystClient(config);
+ * const command = new GetSpaceCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSpaceCommandInput} for command's `input` shape.
+ * @see {@link GetSpaceCommandOutput} for command's `response` shape.
+ * @see {@link CodeCatalystClientResolvedConfig | config} for CodeCatalystClient's `config` shape.
+ *
+ */
+export declare class GetSpaceCommand extends $Command<GetSpaceCommandInput, GetSpaceCommandOutput, CodeCatalystClientResolvedConfig> {
+    readonly input: GetSpaceCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetSpaceCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeCatalystClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSpaceCommandInput, GetSpaceCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetSubscriptionCommand.d.ts

@@ -0,0 +1,38 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CodeCatalystClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CodeCatalystClient";
+import { GetSubscriptionRequest, GetSubscriptionResponse } from "../models/models_0";
+export interface GetSubscriptionCommandInput extends GetSubscriptionRequest {
+}
+export interface GetSubscriptionCommandOutput extends GetSubscriptionResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns information about the Amazon Web Services account used for billing purposes
+ *       and the billing plan for the space.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CodeCatalystClient, GetSubscriptionCommand } from "@aws-sdk/client-codecatalyst"; // ES Modules import
+ * // const { CodeCatalystClient, GetSubscriptionCommand } = require("@aws-sdk/client-codecatalyst"); // CommonJS import
+ * const client = new CodeCatalystClient(config);
+ * const command = new GetSubscriptionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSubscriptionCommandInput} for command's `input` shape.
+ * @see {@link GetSubscriptionCommandOutput} for command's `response` shape.
+ * @see {@link CodeCatalystClientResolvedConfig | config} for CodeCatalystClient's `config` shape.
+ *
+ */
+export declare class GetSubscriptionCommand extends $Command<GetSubscriptionCommandInput, GetSubscriptionCommandOutput, CodeCatalystClientResolvedConfig> {
+    readonly input: GetSubscriptionCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetSubscriptionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeCatalystClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSubscriptionCommandInput, GetSubscriptionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetUserDetailsCommand.d.ts

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CodeCatalystClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CodeCatalystClient";
+import { GetUserDetailsRequest, GetUserDetailsResponse } from "../models/models_0";
+export interface GetUserDetailsCommandInput extends GetUserDetailsRequest {
+}
+export interface GetUserDetailsCommandOutput extends GetUserDetailsResponse, __MetadataBearer {
+}
+/**
+ * <p>Returns information about a user. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CodeCatalystClient, GetUserDetailsCommand } from "@aws-sdk/client-codecatalyst"; // ES Modules import
+ * // const { CodeCatalystClient, GetUserDetailsCommand } = require("@aws-sdk/client-codecatalyst"); // CommonJS import
+ * const client = new CodeCatalystClient(config);
+ * const command = new GetUserDetailsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetUserDetailsCommandInput} for command's `input` shape.
+ * @see {@link GetUserDetailsCommandOutput} for command's `response` shape.
+ * @see {@link CodeCatalystClientResolvedConfig | config} for CodeCatalystClient's `config` shape.
+ *
+ */
+export declare class GetUserDetailsCommand extends $Command<GetUserDetailsCommandInput, GetUserDetailsCommandOutput, CodeCatalystClientResolvedConfig> {
+    readonly input: GetUserDetailsCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: GetUserDetailsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeCatalystClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetUserDetailsCommandInput, GetUserDetailsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListAccessTokensCommand.d.ts

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CodeCatalystClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CodeCatalystClient";
+import { ListAccessTokensRequest, ListAccessTokensResponse } from "../models/models_0";
+export interface ListAccessTokensCommandInput extends ListAccessTokensRequest {
+}
+export interface ListAccessTokensCommandOutput extends ListAccessTokensResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists all personal access tokens (PATs) associated with the user who calls the API. You can only list PATs associated with your user account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CodeCatalystClient, ListAccessTokensCommand } from "@aws-sdk/client-codecatalyst"; // ES Modules import
+ * // const { CodeCatalystClient, ListAccessTokensCommand } = require("@aws-sdk/client-codecatalyst"); // CommonJS import
+ * const client = new CodeCatalystClient(config);
+ * const command = new ListAccessTokensCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListAccessTokensCommandInput} for command's `input` shape.
+ * @see {@link ListAccessTokensCommandOutput} for command's `response` shape.
+ * @see {@link CodeCatalystClientResolvedConfig | config} for CodeCatalystClient's `config` shape.
+ *
+ */
+export declare class ListAccessTokensCommand extends $Command<ListAccessTokensCommandInput, ListAccessTokensCommandOutput, CodeCatalystClientResolvedConfig> {
+    readonly input: ListAccessTokensCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: ListAccessTokensCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeCatalystClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListAccessTokensCommandInput, ListAccessTokensCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListDevEnvironmentsCommand.d.ts

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CodeCatalystClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CodeCatalystClient";
+import { ListDevEnvironmentsRequest, ListDevEnvironmentsResponse } from "../models/models_0";
+export interface ListDevEnvironmentsCommandInput extends ListDevEnvironmentsRequest {
+}
+export interface ListDevEnvironmentsCommandOutput extends ListDevEnvironmentsResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrives a list of Dev Environments in a project.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CodeCatalystClient, ListDevEnvironmentsCommand } from "@aws-sdk/client-codecatalyst"; // ES Modules import
+ * // const { CodeCatalystClient, ListDevEnvironmentsCommand } = require("@aws-sdk/client-codecatalyst"); // CommonJS import
+ * const client = new CodeCatalystClient(config);
+ * const command = new ListDevEnvironmentsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListDevEnvironmentsCommandInput} for command's `input` shape.
+ * @see {@link ListDevEnvironmentsCommandOutput} for command's `response` shape.
+ * @see {@link CodeCatalystClientResolvedConfig | config} for CodeCatalystClient's `config` shape.
+ *
+ */
+export declare class ListDevEnvironmentsCommand extends $Command<ListDevEnvironmentsCommandInput, ListDevEnvironmentsCommandOutput, CodeCatalystClientResolvedConfig> {
+    readonly input: ListDevEnvironmentsCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: ListDevEnvironmentsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeCatalystClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListDevEnvironmentsCommandInput, ListDevEnvironmentsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListEventLogsCommand.d.ts

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CodeCatalystClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CodeCatalystClient";
+import { ListEventLogsRequest, ListEventLogsResponse } from "../models/models_0";
+export interface ListEventLogsCommandInput extends ListEventLogsRequest {
+}
+export interface ListEventLogsCommandOutput extends ListEventLogsResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves a list of events that occurred during a specified time period in a space. You can use these events to audit user and system activity in a space.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CodeCatalystClient, ListEventLogsCommand } from "@aws-sdk/client-codecatalyst"; // ES Modules import
+ * // const { CodeCatalystClient, ListEventLogsCommand } = require("@aws-sdk/client-codecatalyst"); // CommonJS import
+ * const client = new CodeCatalystClient(config);
+ * const command = new ListEventLogsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListEventLogsCommandInput} for command's `input` shape.
+ * @see {@link ListEventLogsCommandOutput} for command's `response` shape.
+ * @see {@link CodeCatalystClientResolvedConfig | config} for CodeCatalystClient's `config` shape.
+ *
+ */
+export declare class ListEventLogsCommand extends $Command<ListEventLogsCommandInput, ListEventLogsCommandOutput, CodeCatalystClientResolvedConfig> {
+    readonly input: ListEventLogsCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: ListEventLogsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeCatalystClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListEventLogsCommandInput, ListEventLogsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListProjectsCommand.d.ts

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CodeCatalystClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CodeCatalystClient";
+import { ListProjectsRequest, ListProjectsResponse } from "../models/models_0";
+export interface ListProjectsCommandInput extends ListProjectsRequest {
+}
+export interface ListProjectsCommandOutput extends ListProjectsResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves a list of projects.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CodeCatalystClient, ListProjectsCommand } from "@aws-sdk/client-codecatalyst"; // ES Modules import
+ * // const { CodeCatalystClient, ListProjectsCommand } = require("@aws-sdk/client-codecatalyst"); // CommonJS import
+ * const client = new CodeCatalystClient(config);
+ * const command = new ListProjectsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListProjectsCommandInput} for command's `input` shape.
+ * @see {@link ListProjectsCommandOutput} for command's `response` shape.
+ * @see {@link CodeCatalystClientResolvedConfig | config} for CodeCatalystClient's `config` shape.
+ *
+ */
+export declare class ListProjectsCommand extends $Command<ListProjectsCommandInput, ListProjectsCommandOutput, CodeCatalystClientResolvedConfig> {
+    readonly input: ListProjectsCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: ListProjectsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeCatalystClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListProjectsCommandInput, ListProjectsCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListSourceRepositoriesCommand.d.ts

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CodeCatalystClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CodeCatalystClient";
+import { ListSourceRepositoriesRequest, ListSourceRepositoriesResponse } from "../models/models_0";
+export interface ListSourceRepositoriesCommandInput extends ListSourceRepositoriesRequest {
+}
+export interface ListSourceRepositoriesCommandOutput extends ListSourceRepositoriesResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves a list of source repositories in a project.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CodeCatalystClient, ListSourceRepositoriesCommand } from "@aws-sdk/client-codecatalyst"; // ES Modules import
+ * // const { CodeCatalystClient, ListSourceRepositoriesCommand } = require("@aws-sdk/client-codecatalyst"); // CommonJS import
+ * const client = new CodeCatalystClient(config);
+ * const command = new ListSourceRepositoriesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListSourceRepositoriesCommandInput} for command's `input` shape.
+ * @see {@link ListSourceRepositoriesCommandOutput} for command's `response` shape.
+ * @see {@link CodeCatalystClientResolvedConfig | config} for CodeCatalystClient's `config` shape.
+ *
+ */
+export declare class ListSourceRepositoriesCommand extends $Command<ListSourceRepositoriesCommandInput, ListSourceRepositoriesCommandOutput, CodeCatalystClientResolvedConfig> {
+    readonly input: ListSourceRepositoriesCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: ListSourceRepositoriesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeCatalystClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSourceRepositoriesCommandInput, ListSourceRepositoriesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListSourceRepositoryBranchesCommand.d.ts

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CodeCatalystClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CodeCatalystClient";
+import { ListSourceRepositoryBranchesRequest, ListSourceRepositoryBranchesResponse } from "../models/models_0";
+export interface ListSourceRepositoryBranchesCommandInput extends ListSourceRepositoryBranchesRequest {
+}
+export interface ListSourceRepositoryBranchesCommandOutput extends ListSourceRepositoryBranchesResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves a list of branches in a specified source repository.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CodeCatalystClient, ListSourceRepositoryBranchesCommand } from "@aws-sdk/client-codecatalyst"; // ES Modules import
+ * // const { CodeCatalystClient, ListSourceRepositoryBranchesCommand } = require("@aws-sdk/client-codecatalyst"); // CommonJS import
+ * const client = new CodeCatalystClient(config);
+ * const command = new ListSourceRepositoryBranchesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListSourceRepositoryBranchesCommandInput} for command's `input` shape.
+ * @see {@link ListSourceRepositoryBranchesCommandOutput} for command's `response` shape.
+ * @see {@link CodeCatalystClientResolvedConfig | config} for CodeCatalystClient's `config` shape.
+ *
+ */
+export declare class ListSourceRepositoryBranchesCommand extends $Command<ListSourceRepositoryBranchesCommandInput, ListSourceRepositoryBranchesCommandOutput, CodeCatalystClientResolvedConfig> {
+    readonly input: ListSourceRepositoryBranchesCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: ListSourceRepositoryBranchesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeCatalystClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSourceRepositoryBranchesCommandInput, ListSourceRepositoryBranchesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListSpacesCommand.d.ts

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CodeCatalystClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CodeCatalystClient";
+import { ListSpacesRequest, ListSpacesResponse } from "../models/models_0";
+export interface ListSpacesCommandInput extends ListSpacesRequest {
+}
+export interface ListSpacesCommandOutput extends ListSpacesResponse, __MetadataBearer {
+}
+/**
+ * <p>Retrieves a list of spaces.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CodeCatalystClient, ListSpacesCommand } from "@aws-sdk/client-codecatalyst"; // ES Modules import
+ * // const { CodeCatalystClient, ListSpacesCommand } = require("@aws-sdk/client-codecatalyst"); // CommonJS import
+ * const client = new CodeCatalystClient(config);
+ * const command = new ListSpacesCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListSpacesCommandInput} for command's `input` shape.
+ * @see {@link ListSpacesCommandOutput} for command's `response` shape.
+ * @see {@link CodeCatalystClientResolvedConfig | config} for CodeCatalystClient's `config` shape.
+ *
+ */
+export declare class ListSpacesCommand extends $Command<ListSpacesCommandInput, ListSpacesCommandOutput, CodeCatalystClientResolvedConfig> {
+    readonly input: ListSpacesCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: ListSpacesCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeCatalystClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListSpacesCommandInput, ListSpacesCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/StartDevEnvironmentCommand.d.ts

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CodeCatalystClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CodeCatalystClient";
+import { StartDevEnvironmentRequest, StartDevEnvironmentResponse } from "../models/models_0";
+export interface StartDevEnvironmentCommandInput extends StartDevEnvironmentRequest {
+}
+export interface StartDevEnvironmentCommandOutput extends StartDevEnvironmentResponse, __MetadataBearer {
+}
+/**
+ * <p>Starts a specified Dev Environment and puts it into an active state. </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CodeCatalystClient, StartDevEnvironmentCommand } from "@aws-sdk/client-codecatalyst"; // ES Modules import
+ * // const { CodeCatalystClient, StartDevEnvironmentCommand } = require("@aws-sdk/client-codecatalyst"); // CommonJS import
+ * const client = new CodeCatalystClient(config);
+ * const command = new StartDevEnvironmentCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StartDevEnvironmentCommandInput} for command's `input` shape.
+ * @see {@link StartDevEnvironmentCommandOutput} for command's `response` shape.
+ * @see {@link CodeCatalystClientResolvedConfig | config} for CodeCatalystClient's `config` shape.
+ *
+ */
+export declare class StartDevEnvironmentCommand extends $Command<StartDevEnvironmentCommandInput, StartDevEnvironmentCommandOutput, CodeCatalystClientResolvedConfig> {
+    readonly input: StartDevEnvironmentCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: StartDevEnvironmentCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeCatalystClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartDevEnvironmentCommandInput, StartDevEnvironmentCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/StartDevEnvironmentSessionCommand.d.ts

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CodeCatalystClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CodeCatalystClient";
+import { StartDevEnvironmentSessionRequest, StartDevEnvironmentSessionResponse } from "../models/models_0";
+export interface StartDevEnvironmentSessionCommandInput extends StartDevEnvironmentSessionRequest {
+}
+export interface StartDevEnvironmentSessionCommandOutput extends StartDevEnvironmentSessionResponse, __MetadataBearer {
+}
+/**
+ * <p>Starts a session for a specified Dev Environment.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CodeCatalystClient, StartDevEnvironmentSessionCommand } from "@aws-sdk/client-codecatalyst"; // ES Modules import
+ * // const { CodeCatalystClient, StartDevEnvironmentSessionCommand } = require("@aws-sdk/client-codecatalyst"); // CommonJS import
+ * const client = new CodeCatalystClient(config);
+ * const command = new StartDevEnvironmentSessionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StartDevEnvironmentSessionCommandInput} for command's `input` shape.
+ * @see {@link StartDevEnvironmentSessionCommandOutput} for command's `response` shape.
+ * @see {@link CodeCatalystClientResolvedConfig | config} for CodeCatalystClient's `config` shape.
+ *
+ */
+export declare class StartDevEnvironmentSessionCommand extends $Command<StartDevEnvironmentSessionCommandInput, StartDevEnvironmentSessionCommandOutput, CodeCatalystClientResolvedConfig> {
+    readonly input: StartDevEnvironmentSessionCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: StartDevEnvironmentSessionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeCatalystClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StartDevEnvironmentSessionCommandInput, StartDevEnvironmentSessionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/StopDevEnvironmentCommand.d.ts

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CodeCatalystClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CodeCatalystClient";
+import { StopDevEnvironmentRequest, StopDevEnvironmentResponse } from "../models/models_0";
+export interface StopDevEnvironmentCommandInput extends StopDevEnvironmentRequest {
+}
+export interface StopDevEnvironmentCommandOutput extends StopDevEnvironmentResponse, __MetadataBearer {
+}
+/**
+ * <p>Pauses a specified Dev Environment and places it in a non-running state. Stopped Dev Environments do not consume compute minutes.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CodeCatalystClient, StopDevEnvironmentCommand } from "@aws-sdk/client-codecatalyst"; // ES Modules import
+ * // const { CodeCatalystClient, StopDevEnvironmentCommand } = require("@aws-sdk/client-codecatalyst"); // CommonJS import
+ * const client = new CodeCatalystClient(config);
+ * const command = new StopDevEnvironmentCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link StopDevEnvironmentCommandInput} for command's `input` shape.
+ * @see {@link StopDevEnvironmentCommandOutput} for command's `response` shape.
+ * @see {@link CodeCatalystClientResolvedConfig | config} for CodeCatalystClient's `config` shape.
+ *
+ */
+export declare class StopDevEnvironmentCommand extends $Command<StopDevEnvironmentCommandInput, StopDevEnvironmentCommandOutput, CodeCatalystClientResolvedConfig> {
+    readonly input: StopDevEnvironmentCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: StopDevEnvironmentCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeCatalystClientResolvedConfig, options?: __HttpHandlerOptions): Handler<StopDevEnvironmentCommandInput, StopDevEnvironmentCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/UpdateDevEnvironmentCommand.d.ts

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CodeCatalystClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CodeCatalystClient";
+import { UpdateDevEnvironmentRequest, UpdateDevEnvironmentResponse } from "../models/models_0";
+export interface UpdateDevEnvironmentCommandInput extends UpdateDevEnvironmentRequest {
+}
+export interface UpdateDevEnvironmentCommandOutput extends UpdateDevEnvironmentResponse, __MetadataBearer {
+}
+/**
+ * <p>Changes one or more values for a Dev Environment. Updating certain values of the Dev Environment will cause a restart.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CodeCatalystClient, UpdateDevEnvironmentCommand } from "@aws-sdk/client-codecatalyst"; // ES Modules import
+ * // const { CodeCatalystClient, UpdateDevEnvironmentCommand } = require("@aws-sdk/client-codecatalyst"); // CommonJS import
+ * const client = new CodeCatalystClient(config);
+ * const command = new UpdateDevEnvironmentCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link UpdateDevEnvironmentCommandInput} for command's `input` shape.
+ * @see {@link UpdateDevEnvironmentCommandOutput} for command's `response` shape.
+ * @see {@link CodeCatalystClientResolvedConfig | config} for CodeCatalystClient's `config` shape.
+ *
+ */
+export declare class UpdateDevEnvironmentCommand extends $Command<UpdateDevEnvironmentCommandInput, UpdateDevEnvironmentCommandOutput, CodeCatalystClientResolvedConfig> {
+    readonly input: UpdateDevEnvironmentCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: UpdateDevEnvironmentCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeCatalystClientResolvedConfig, options?: __HttpHandlerOptions): Handler<UpdateDevEnvironmentCommandInput, UpdateDevEnvironmentCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/VerifySessionCommand.d.ts

@@ -0,0 +1,37 @@
+import { EndpointParameterInstructions } from "@aws-sdk/middleware-endpoint";
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CodeCatalystClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../CodeCatalystClient";
+import { VerifySessionResponse } from "../models/models_0";
+export interface VerifySessionCommandInput {
+}
+export interface VerifySessionCommandOutput extends VerifySessionResponse, __MetadataBearer {
+}
+/**
+ * <p>Verifies whether the calling user has a valid Amazon CodeCatalyst login and session.  If successful, this returns the ID of the user in Amazon CodeCatalyst.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { CodeCatalystClient, VerifySessionCommand } from "@aws-sdk/client-codecatalyst"; // ES Modules import
+ * // const { CodeCatalystClient, VerifySessionCommand } = require("@aws-sdk/client-codecatalyst"); // CommonJS import
+ * const client = new CodeCatalystClient(config);
+ * const command = new VerifySessionCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link VerifySessionCommandInput} for command's `input` shape.
+ * @see {@link VerifySessionCommandOutput} for command's `response` shape.
+ * @see {@link CodeCatalystClientResolvedConfig | config} for CodeCatalystClient's `config` shape.
+ *
+ */
+export declare class VerifySessionCommand extends $Command<VerifySessionCommandInput, VerifySessionCommandOutput, CodeCatalystClientResolvedConfig> {
+    readonly input: VerifySessionCommandInput;
+    static getEndpointParameterInstructions(): EndpointParameterInstructions;
+    constructor(input: VerifySessionCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: CodeCatalystClientResolvedConfig, options?: __HttpHandlerOptions): Handler<VerifySessionCommandInput, VerifySessionCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/index.d.ts

@@ -0,0 +1,24 @@
+export * from "./CreateAccessTokenCommand";
+export * from "./CreateDevEnvironmentCommand";
+export * from "./CreateProjectCommand";
+export * from "./CreateSourceRepositoryBranchCommand";
+export * from "./DeleteAccessTokenCommand";
+export * from "./DeleteDevEnvironmentCommand";
+export * from "./GetDevEnvironmentCommand";
+export * from "./GetProjectCommand";
+export * from "./GetSourceRepositoryCloneUrlsCommand";
+export * from "./GetSpaceCommand";
+export * from "./GetSubscriptionCommand";
+export * from "./GetUserDetailsCommand";
+export * from "./ListAccessTokensCommand";
+export * from "./ListDevEnvironmentsCommand";
+export * from "./ListEventLogsCommand";
+export * from "./ListProjectsCommand";
+export * from "./ListSourceRepositoriesCommand";
+export * from "./ListSourceRepositoryBranchesCommand";
+export * from "./ListSpacesCommand";
+export * from "./StartDevEnvironmentCommand";
+export * from "./StartDevEnvironmentSessionCommand";
+export * from "./StopDevEnvironmentCommand";
+export * from "./UpdateDevEnvironmentCommand";
+export * from "./VerifySessionCommand";

package/dist-types/endpoint/EndpointParameters.d.ts

@@ -0,0 +1,17 @@
+import { Endpoint, EndpointParameters as __EndpointParameters, EndpointV2, Provider } from "@aws-sdk/types";
+export interface ClientInputEndpointParameters {
+    useFipsEndpoint?: boolean | Provider<boolean>;
+    region?: string | Provider<string>;
+    endpoint?: string | Provider<string> | Endpoint | Provider<Endpoint> | EndpointV2 | Provider<EndpointV2>;
+}
+export declare type ClientResolvedEndpointParameters = ClientInputEndpointParameters & {
+    defaultSigningName: string;
+};
+export declare const resolveClientEndpointParameters: <T>(options: T & ClientInputEndpointParameters) => T & ClientInputEndpointParameters & {
+    defaultSigningName: string;
+};
+export interface EndpointParameters extends __EndpointParameters {
+    UseFIPS?: boolean;
+    Region?: string;
+    Endpoint?: string;
+}

package/dist-types/endpoint/endpointResolver.d.ts

@@ -0,0 +1,5 @@
+import { EndpointV2, Logger } from "@aws-sdk/types";
+import { EndpointParameters } from "./EndpointParameters";
+export declare const defaultEndpointResolver: (endpointParams: EndpointParameters, context?: {
+    logger?: Logger;
+}) => EndpointV2;

package/dist-types/endpoint/ruleset.d.ts

@@ -0,0 +1,2 @@
+import { RuleSetObject } from "@aws-sdk/util-endpoints";
+export declare const ruleSet: RuleSetObject;

package/dist-types/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./CodeCatalyst";
+export * from "./CodeCatalystClient";
+export * from "./commands";
+export * from "./models";
+export * from "./pagination";
+export { CodeCatalystServiceException } from "./models/CodeCatalystServiceException";