@aws-sdk/client-codecatalyst 3.222.0

package/dist-es/models/models_0.js

@@ -0,0 +1,337 @@
+import { SENSITIVE_STRING } from "@aws-sdk/smithy-client";
+import { CodeCatalystServiceException as __BaseException } from "./CodeCatalystServiceException";
+export class AccessDeniedException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "AccessDeniedException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "AccessDeniedException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, AccessDeniedException.prototype);
+    }
+}
+export class ConflictException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ConflictException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ConflictException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ConflictException.prototype);
+    }
+}
+export class ResourceNotFoundException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ResourceNotFoundException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+    }
+}
+export class ServiceQuotaExceededException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ServiceQuotaExceededException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ServiceQuotaExceededException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ServiceQuotaExceededException.prototype);
+    }
+}
+export class ThrottlingException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ThrottlingException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ThrottlingException";
+        this.$fault = "client";
+        this.$retryable = {};
+        Object.setPrototypeOf(this, ThrottlingException.prototype);
+    }
+}
+export class ValidationException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ValidationException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ValidationException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ValidationException.prototype);
+    }
+}
+export var CatalogActionVersionFileRecordType;
+(function (CatalogActionVersionFileRecordType) {
+    CatalogActionVersionFileRecordType["LICENSE"] = "LICENSE";
+    CatalogActionVersionFileRecordType["README"] = "README";
+})(CatalogActionVersionFileRecordType || (CatalogActionVersionFileRecordType = {}));
+export var OperationType;
+(function (OperationType) {
+    OperationType["MUTATION"] = "MUTATION";
+    OperationType["READONLY"] = "READONLY";
+})(OperationType || (OperationType = {}));
+export var UserType;
+(function (UserType) {
+    UserType["AWS_ACCOUNT"] = "AWS_ACCOUNT";
+    UserType["UNKNOWN"] = "UNKNOWN";
+    UserType["USER"] = "USER";
+})(UserType || (UserType = {}));
+export var _InstanceType;
+(function (_InstanceType) {
+    _InstanceType["DEV_STANDARD1_LARGE"] = "dev.standard1.large";
+    _InstanceType["DEV_STANDARD1_MEDIUM"] = "dev.standard1.medium";
+    _InstanceType["DEV_STANDARD1_SMALL"] = "dev.standard1.small";
+    _InstanceType["DEV_STANDARD1_XLARGE"] = "dev.standard1.xlarge";
+})(_InstanceType || (_InstanceType = {}));
+export var DevEnvironmentStatus;
+(function (DevEnvironmentStatus) {
+    DevEnvironmentStatus["DELETED"] = "DELETED";
+    DevEnvironmentStatus["DELETING"] = "DELETING";
+    DevEnvironmentStatus["FAILED"] = "FAILED";
+    DevEnvironmentStatus["PENDING"] = "PENDING";
+    DevEnvironmentStatus["RUNNING"] = "RUNNING";
+    DevEnvironmentStatus["STARTING"] = "STARTING";
+    DevEnvironmentStatus["STOPPED"] = "STOPPED";
+    DevEnvironmentStatus["STOPPING"] = "STOPPING";
+})(DevEnvironmentStatus || (DevEnvironmentStatus = {}));
+export var DevEnvironmentSessionType;
+(function (DevEnvironmentSessionType) {
+    DevEnvironmentSessionType["SSH"] = "SSH";
+    DevEnvironmentSessionType["SSM"] = "SSM";
+})(DevEnvironmentSessionType || (DevEnvironmentSessionType = {}));
+export var ComparisonOperator;
+(function (ComparisonOperator) {
+    ComparisonOperator["EQUALS"] = "EQ";
+    ComparisonOperator["GREATER_THAN"] = "GT";
+    ComparisonOperator["GREATER_THAN_OR_EQUALS"] = "GE";
+    ComparisonOperator["LESS_THAN"] = "LT";
+    ComparisonOperator["LESS_THAN_OR_EQUALS"] = "LE";
+})(ComparisonOperator || (ComparisonOperator = {}));
+export var FilterKey;
+(function (FilterKey) {
+    FilterKey["HAS_ACCESS_TO"] = "hasAccessTo";
+})(FilterKey || (FilterKey = {}));
+export const CreateAccessTokenRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateAccessTokenResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.secret && { secret: SENSITIVE_STRING }),
+});
+export const DeleteAccessTokenRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteAccessTokenResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListAccessTokensRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const AccessTokenSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListAccessTokensResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetUserDetailsRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const EmailAddressFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetUserDetailsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListEventLogsRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ProjectInformationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const EventPayloadFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UserIdentityFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const EventLogEntryFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListEventLogsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSpaceRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSpaceResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSpacesRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const SpaceSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSpacesResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateProjectRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateProjectResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const IdeConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const PersistentStorageConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const RepositoryInputFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateDevEnvironmentRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateDevEnvironmentResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteDevEnvironmentRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DeleteDevEnvironmentResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetDevEnvironmentRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const IdeFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const PersistentStorageFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DevEnvironmentRepositorySummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetDevEnvironmentResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const FilterFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListDevEnvironmentsRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DevEnvironmentSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListDevEnvironmentsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const StartDevEnvironmentRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const StartDevEnvironmentResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ExecuteCommandSessionConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DevEnvironmentSessionConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const StartDevEnvironmentSessionRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const DevEnvironmentAccessDetailsFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.streamUrl && { streamUrl: SENSITIVE_STRING }),
+    ...(obj.tokenValue && { tokenValue: SENSITIVE_STRING }),
+});
+export const StartDevEnvironmentSessionResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.accessDetails && { accessDetails: SENSITIVE_STRING }),
+});
+export const StopDevEnvironmentRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const StopDevEnvironmentResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateDevEnvironmentRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const UpdateDevEnvironmentResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetProjectRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetProjectResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ProjectListFilterFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListProjectsRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ProjectSummaryFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListProjectsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSourceRepositoryCloneUrlsRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSourceRepositoryCloneUrlsResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSourceRepositoriesRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSourceRepositoriesItemFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSourceRepositoriesResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateSourceRepositoryBranchRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const CreateSourceRepositoryBranchResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSourceRepositoryBranchesRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSourceRepositoryBranchesItemFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const ListSourceRepositoryBranchesResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSubscriptionRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const GetSubscriptionResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const VerifySessionResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+});

package/dist-es/pagination/Interfaces.js

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

package/dist-es/pagination/ListAccessTokensPaginator.js

@@ -0,0 +1,32 @@
+import { CodeCatalyst } from "../CodeCatalyst";
+import { CodeCatalystClient } from "../CodeCatalystClient";
+import { ListAccessTokensCommand, } from "../commands/ListAccessTokensCommand";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListAccessTokensCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listAccessTokens(input, ...args);
+};
+export async function* paginateListAccessTokens(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof CodeCatalyst) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof CodeCatalystClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected CodeCatalyst | CodeCatalystClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListDevEnvironmentsPaginator.js

@@ -0,0 +1,32 @@
+import { CodeCatalyst } from "../CodeCatalyst";
+import { CodeCatalystClient } from "../CodeCatalystClient";
+import { ListDevEnvironmentsCommand, } from "../commands/ListDevEnvironmentsCommand";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListDevEnvironmentsCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listDevEnvironments(input, ...args);
+};
+export async function* paginateListDevEnvironments(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof CodeCatalyst) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof CodeCatalystClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected CodeCatalyst | CodeCatalystClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListEventLogsPaginator.js

@@ -0,0 +1,32 @@
+import { CodeCatalyst } from "../CodeCatalyst";
+import { CodeCatalystClient } from "../CodeCatalystClient";
+import { ListEventLogsCommand, } from "../commands/ListEventLogsCommand";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListEventLogsCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listEventLogs(input, ...args);
+};
+export async function* paginateListEventLogs(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof CodeCatalyst) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof CodeCatalystClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected CodeCatalyst | CodeCatalystClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListProjectsPaginator.js

@@ -0,0 +1,32 @@
+import { CodeCatalyst } from "../CodeCatalyst";
+import { CodeCatalystClient } from "../CodeCatalystClient";
+import { ListProjectsCommand, } from "../commands/ListProjectsCommand";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListProjectsCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listProjects(input, ...args);
+};
+export async function* paginateListProjects(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof CodeCatalyst) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof CodeCatalystClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected CodeCatalyst | CodeCatalystClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListSourceRepositoriesPaginator.js

@@ -0,0 +1,32 @@
+import { CodeCatalyst } from "../CodeCatalyst";
+import { CodeCatalystClient } from "../CodeCatalystClient";
+import { ListSourceRepositoriesCommand, } from "../commands/ListSourceRepositoriesCommand";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListSourceRepositoriesCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listSourceRepositories(input, ...args);
+};
+export async function* paginateListSourceRepositories(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof CodeCatalyst) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof CodeCatalystClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected CodeCatalyst | CodeCatalystClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListSourceRepositoryBranchesPaginator.js

@@ -0,0 +1,32 @@
+import { CodeCatalyst } from "../CodeCatalyst";
+import { CodeCatalystClient } from "../CodeCatalystClient";
+import { ListSourceRepositoryBranchesCommand, } from "../commands/ListSourceRepositoryBranchesCommand";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListSourceRepositoryBranchesCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listSourceRepositoryBranches(input, ...args);
+};
+export async function* paginateListSourceRepositoryBranches(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        input["maxResults"] = config.pageSize;
+        if (config.client instanceof CodeCatalyst) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof CodeCatalystClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected CodeCatalyst | CodeCatalystClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListSpacesPaginator.js

@@ -0,0 +1,31 @@
+import { CodeCatalyst } from "../CodeCatalyst";
+import { CodeCatalystClient } from "../CodeCatalystClient";
+import { ListSpacesCommand } from "../commands/ListSpacesCommand";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListSpacesCommand(input), ...args);
+};
+const makePagedRequest = async (client, input, ...args) => {
+    return await client.listSpaces(input, ...args);
+};
+export async function* paginateListSpaces(config, input, ...additionalArguments) {
+    let token = config.startingToken || undefined;
+    let hasNext = true;
+    let page;
+    while (hasNext) {
+        input.nextToken = token;
+        if (config.client instanceof CodeCatalyst) {
+            page = await makePagedRequest(config.client, input, ...additionalArguments);
+        }
+        else if (config.client instanceof CodeCatalystClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected CodeCatalyst | CodeCatalystClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/index.js

@@ -0,0 +1,8 @@
+export * from "./Interfaces";
+export * from "./ListAccessTokensPaginator";
+export * from "./ListDevEnvironmentsPaginator";
+export * from "./ListEventLogsPaginator";
+export * from "./ListProjectsPaginator";
+export * from "./ListSourceRepositoriesPaginator";
+export * from "./ListSourceRepositoryBranchesPaginator";
+export * from "./ListSpacesPaginator";