@aws-sdk/client-bedrock-agent 3.461.0

package/dist-es/models/models_0.js

@@ -0,0 +1,267 @@
+import { SENSITIVE_STRING } from "@smithy/smithy-client";
+import { BedrockAgentServiceException as __BaseException } from "./BedrockAgentServiceException";
+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 var ActionGroupExecutor;
+(function (ActionGroupExecutor) {
+    ActionGroupExecutor.visit = (value, visitor) => {
+        if (value.lambda !== undefined)
+            return visitor.lambda(value.lambda);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(ActionGroupExecutor || (ActionGroupExecutor = {}));
+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 const ActionGroupState = {
+    DISABLED: "DISABLED",
+    ENABLED: "ENABLED",
+};
+export var APISchema;
+(function (APISchema) {
+    APISchema.visit = (value, visitor) => {
+        if (value.s3 !== undefined)
+            return visitor.s3(value.s3);
+        if (value.payload !== undefined)
+            return visitor.payload(value.payload);
+        return visitor._(value.$unknown[0], value.$unknown[1]);
+    };
+})(APISchema || (APISchema = {}));
+export const ActionGroupSignature = {
+    AMAZON_USERINPUT: "AMAZON.UserInput",
+};
+export class InternalServerException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "InternalServerException",
+            $fault: "server",
+            ...opts,
+        });
+        this.name = "InternalServerException";
+        this.$fault = "server";
+        Object.setPrototypeOf(this, InternalServerException.prototype);
+    }
+}
+export class ResourceNotFoundException extends __BaseException {
+    constructor(opts) {
+        super({
+            name: "ResourceNotFoundException",
+            $fault: "client",
+            ...opts,
+        });
+        this.name = "ResourceNotFoundException";
+        this.$fault = "client";
+        Object.setPrototypeOf(this, ResourceNotFoundException.prototype);
+    }
+}
+export class 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";
+        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);
+        this.fieldList = opts.fieldList;
+    }
+}
+export const AgentStatus = {
+    CREATING: "CREATING",
+    DELETING: "DELETING",
+    FAILED: "FAILED",
+    NOT_PREPARED: "NOT_PREPARED",
+    PREPARED: "PREPARED",
+    PREPARING: "PREPARING",
+    UPDATING: "UPDATING",
+    VERSIONING: "VERSIONING",
+};
+export const CreationMode = {
+    DEFAULT: "DEFAULT",
+    OVERRIDDEN: "OVERRIDDEN",
+};
+export const PromptState = {
+    DISABLED: "DISABLED",
+    ENABLED: "ENABLED",
+};
+export const PromptType = {
+    KNOWLEDGE_BASE_RESPONSE_GENERATION: "KNOWLEDGE_BASE_RESPONSE_GENERATION",
+    ORCHESTRATION: "ORCHESTRATION",
+    POST_PROCESSING: "POST_PROCESSING",
+    PRE_PROCESSING: "PRE_PROCESSING",
+};
+export const AgentAliasStatus = {
+    CREATING: "CREATING",
+    DELETING: "DELETING",
+    FAILED: "FAILED",
+    PREPARED: "PREPARED",
+    UPDATING: "UPDATING",
+};
+export const KnowledgeBaseState = {
+    DISABLED: "DISABLED",
+    ENABLED: "ENABLED",
+};
+export const DataSourceType = {
+    S3: "S3",
+};
+export const ChunkingStrategy = {
+    FIXED_SIZE: "FIXED_SIZE",
+    NONE: "NONE",
+};
+export const DataSourceStatus = {
+    AVAILABLE: "AVAILABLE",
+    DELETING: "DELETING",
+};
+export const IngestionJobStatus = {
+    COMPLETE: "COMPLETE",
+    FAILED: "FAILED",
+    IN_PROGRESS: "IN_PROGRESS",
+    STARTING: "STARTING",
+};
+export const IngestionJobFilterAttribute = {
+    STATUS: "STATUS",
+};
+export const IngestionJobFilterOperator = {
+    EQ: "EQ",
+};
+export const IngestionJobSortByAttribute = {
+    STARTED_AT: "STARTED_AT",
+    STATUS: "STATUS",
+};
+export const SortOrder = {
+    ASCENDING: "ASCENDING",
+    DESCENDING: "DESCENDING",
+};
+export const KnowledgeBaseType = {
+    VECTOR: "VECTOR",
+};
+export const KnowledgeBaseStorageType = {
+    OPENSEARCH_SERVERLESS: "OPENSEARCH_SERVERLESS",
+    PINECONE: "PINECONE",
+    REDIS_ENTERPRISE_CLOUD: "REDIS_ENTERPRISE_CLOUD",
+};
+export const KnowledgeBaseStatus = {
+    ACTIVE: "ACTIVE",
+    CREATING: "CREATING",
+    DELETING: "DELETING",
+    FAILED: "FAILED",
+    UPDATING: "UPDATING",
+};
+export const APISchemaFilterSensitiveLog = (obj) => {
+    if (obj.s3 !== undefined)
+        return { s3: obj.s3 };
+    if (obj.payload !== undefined)
+        return { payload: SENSITIVE_STRING };
+    if (obj.$unknown !== undefined)
+        return { [obj.$unknown[0]]: "UNKNOWN" };
+};
+export const CreateAgentActionGroupRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.actionGroupExecutor && { actionGroupExecutor: obj.actionGroupExecutor }),
+    ...(obj.apiSchema && { apiSchema: APISchemaFilterSensitiveLog(obj.apiSchema) }),
+});
+export const AgentActionGroupFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.actionGroupExecutor && { actionGroupExecutor: obj.actionGroupExecutor }),
+    ...(obj.apiSchema && { apiSchema: APISchemaFilterSensitiveLog(obj.apiSchema) }),
+});
+export const CreateAgentActionGroupResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.agentActionGroup && { agentActionGroup: AgentActionGroupFilterSensitiveLog(obj.agentActionGroup) }),
+});
+export const GetAgentActionGroupResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.agentActionGroup && { agentActionGroup: AgentActionGroupFilterSensitiveLog(obj.agentActionGroup) }),
+});
+export const UpdateAgentActionGroupRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.actionGroupExecutor && { actionGroupExecutor: obj.actionGroupExecutor }),
+    ...(obj.apiSchema && { apiSchema: APISchemaFilterSensitiveLog(obj.apiSchema) }),
+});
+export const UpdateAgentActionGroupResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.agentActionGroup && { agentActionGroup: AgentActionGroupFilterSensitiveLog(obj.agentActionGroup) }),
+});
+export const PromptOverrideConfigurationFilterSensitiveLog = (obj) => ({
+    ...obj,
+});
+export const AgentFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.instruction && { instruction: SENSITIVE_STRING }),
+    ...(obj.promptOverrideConfiguration && { promptOverrideConfiguration: SENSITIVE_STRING }),
+});
+export const CreateAgentRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.instruction && { instruction: SENSITIVE_STRING }),
+    ...(obj.promptOverrideConfiguration && { promptOverrideConfiguration: SENSITIVE_STRING }),
+});
+export const CreateAgentResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.agent && { agent: AgentFilterSensitiveLog(obj.agent) }),
+});
+export const GetAgentResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.agent && { agent: AgentFilterSensitiveLog(obj.agent) }),
+});
+export const UpdateAgentRequestFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.instruction && { instruction: SENSITIVE_STRING }),
+    ...(obj.promptOverrideConfiguration && { promptOverrideConfiguration: SENSITIVE_STRING }),
+});
+export const UpdateAgentResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.agent && { agent: AgentFilterSensitiveLog(obj.agent) }),
+});
+export const AgentVersionFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.instruction && { instruction: SENSITIVE_STRING }),
+    ...(obj.promptOverrideConfiguration && { promptOverrideConfiguration: SENSITIVE_STRING }),
+});
+export const GetAgentVersionResponseFilterSensitiveLog = (obj) => ({
+    ...obj,
+    ...(obj.agentVersion && { agentVersion: AgentVersionFilterSensitiveLog(obj.agentVersion) }),
+});

package/dist-es/pagination/Interfaces.js

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

package/dist-es/pagination/ListAgentActionGroupsPaginator.js

@@ -0,0 +1,25 @@
+import { BedrockAgentClient } from "../BedrockAgentClient";
+import { ListAgentActionGroupsCommand, } from "../commands/ListAgentActionGroupsCommand";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListAgentActionGroupsCommand(input), ...args);
+};
+export async function* paginateListAgentActionGroups(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 BedrockAgentClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected BedrockAgent | BedrockAgentClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListAgentAliasesPaginator.js

@@ -0,0 +1,25 @@
+import { BedrockAgentClient } from "../BedrockAgentClient";
+import { ListAgentAliasesCommand, } from "../commands/ListAgentAliasesCommand";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListAgentAliasesCommand(input), ...args);
+};
+export async function* paginateListAgentAliases(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 BedrockAgentClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected BedrockAgent | BedrockAgentClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListAgentKnowledgeBasesPaginator.js

@@ -0,0 +1,25 @@
+import { BedrockAgentClient } from "../BedrockAgentClient";
+import { ListAgentKnowledgeBasesCommand, } from "../commands/ListAgentKnowledgeBasesCommand";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListAgentKnowledgeBasesCommand(input), ...args);
+};
+export async function* paginateListAgentKnowledgeBases(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 BedrockAgentClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected BedrockAgent | BedrockAgentClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListAgentVersionsPaginator.js

@@ -0,0 +1,25 @@
+import { BedrockAgentClient } from "../BedrockAgentClient";
+import { ListAgentVersionsCommand, } from "../commands/ListAgentVersionsCommand";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListAgentVersionsCommand(input), ...args);
+};
+export async function* paginateListAgentVersions(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 BedrockAgentClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected BedrockAgent | BedrockAgentClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListAgentsPaginator.js

@@ -0,0 +1,25 @@
+import { BedrockAgentClient } from "../BedrockAgentClient";
+import { ListAgentsCommand } from "../commands/ListAgentsCommand";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListAgentsCommand(input), ...args);
+};
+export async function* paginateListAgents(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 BedrockAgentClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected BedrockAgent | BedrockAgentClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListDataSourcesPaginator.js

@@ -0,0 +1,25 @@
+import { BedrockAgentClient } from "../BedrockAgentClient";
+import { ListDataSourcesCommand, } from "../commands/ListDataSourcesCommand";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListDataSourcesCommand(input), ...args);
+};
+export async function* paginateListDataSources(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 BedrockAgentClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected BedrockAgent | BedrockAgentClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListIngestionJobsPaginator.js

@@ -0,0 +1,25 @@
+import { BedrockAgentClient } from "../BedrockAgentClient";
+import { ListIngestionJobsCommand, } from "../commands/ListIngestionJobsCommand";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListIngestionJobsCommand(input), ...args);
+};
+export async function* paginateListIngestionJobs(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 BedrockAgentClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected BedrockAgent | BedrockAgentClient");
+        }
+        yield page;
+        const prevToken = token;
+        token = page.nextToken;
+        hasNext = !!(token && (!config.stopOnSameToken || token !== prevToken));
+    }
+    return undefined;
+}

package/dist-es/pagination/ListKnowledgeBasesPaginator.js

@@ -0,0 +1,25 @@
+import { BedrockAgentClient } from "../BedrockAgentClient";
+import { ListKnowledgeBasesCommand, } from "../commands/ListKnowledgeBasesCommand";
+const makePagedClientRequest = async (client, input, ...args) => {
+    return await client.send(new ListKnowledgeBasesCommand(input), ...args);
+};
+export async function* paginateListKnowledgeBases(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 BedrockAgentClient) {
+            page = await makePagedClientRequest(config.client, input, ...additionalArguments);
+        }
+        else {
+            throw new Error("Invalid client, expected BedrockAgent | BedrockAgentClient");
+        }
+        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,9 @@
+export * from "./Interfaces";
+export * from "./ListAgentActionGroupsPaginator";
+export * from "./ListAgentAliasesPaginator";
+export * from "./ListAgentKnowledgeBasesPaginator";
+export * from "./ListAgentVersionsPaginator";
+export * from "./ListAgentsPaginator";
+export * from "./ListDataSourcesPaginator";
+export * from "./ListIngestionJobsPaginator";
+export * from "./ListKnowledgeBasesPaginator";