import * as HttpClient from "effect/unstable/http/HttpClient";
import * as redacted from "effect/Redacted";
import * as S from "effect/Schema";
import * as stream from "effect/Stream";
import * as API from "../client/api.ts";
import type { Credentials } from "../credentials.ts";
import type { CommonErrors } from "../errors.ts";
import type { Region } from "../region.ts";
export type AgentSpaceId = string;
export type ResourceId = string;
export type BacklogTaskTitle = string;
export type BacklogTaskDescription = string;
export type BackLogTimestamp = Date;
export type NextToken = string;
export type JournalTimestamp = Date;
export type TagKey = string;
export type TagValue = string;
export type MessageContent = string;
export type AgentSpaceName = string;
export type Description = string | redacted.Redacted<string>;
export type Locale = string;
export type KmsKeyArn = string;
export type RoleArn = string;
export type IdpClientId = string;
export type IdpClientSecret = string | redacted.Redacted<string>;
export type ServiceId = string;
export type EmailAddress = string | redacted.Redacted<string>;
export type AssociationId = string;
export type WebhookSecret = string | redacted.Redacted<string>;
export type ApiKeyValue = string | redacted.Redacted<string>;
export type PrivateConnectionName = string;
export type IpAddressOrDnsName = string;
export type VpcId = string;
export type SubnetId = string;
export type SecurityGroupId = string;
export type MaxIpv4AddressesPerEni = number;
export type PortRange = string;
export type CertificateString = string;
export type ResourceConfigurationArn = string;
export type ResourceGatewayArn = string;
export type ClientId = string | redacted.Redacted<string>;
export type ExchangeParameterValue = string | redacted.Redacted<string>;
export type ClientSecret = string | redacted.Redacted<string>;
export type ServiceNowInstanceUrl = string;
export type TokenValue = string | redacted.Redacted<string>;
export type Guid = string;
export type ServiceName = string;
export interface AllowVendedLogDeliveryForResourceInput {
    resourceArnBeingAuthorized: string;
    deliverySourceArn: string;
    logType?: string;
}
export declare const AllowVendedLogDeliveryForResourceInput: S.Schema<AllowVendedLogDeliveryForResourceInput>;
export interface AllowVendedLogDeliveryForResourceOutput {
    message?: string;
}
export declare const AllowVendedLogDeliveryForResourceOutput: S.Schema<AllowVendedLogDeliveryForResourceOutput>;
export interface ReferenceInput {
    system: string;
    title?: string;
    referenceId: string;
    referenceUrl: string;
    associationId: string;
}
export declare const ReferenceInput: S.Schema<ReferenceInput>;
export type TaskType = "INVESTIGATION" | "EVALUATION" | (string & {});
export declare const TaskType: S.String;
export type Priority = "CRITICAL" | "HIGH" | "MEDIUM" | "LOW" | "MINIMAL" | (string & {});
export declare const Priority: S.String;
export interface CreateBacklogTaskRequest {
    agentSpaceId: string;
    reference?: ReferenceInput;
    taskType: TaskType;
    title: string;
    description?: string;
    priority: Priority;
    clientToken?: string;
}
export declare const CreateBacklogTaskRequest: S.Schema<CreateBacklogTaskRequest>;
export interface ReferenceOutput {
    system: string;
    title?: string;
    referenceId: string;
    referenceUrl: string;
    associationId: string;
}
export declare const ReferenceOutput: S.Schema<ReferenceOutput>;
export type TaskStatus = "PENDING_TRIAGE" | "LINKED" | "PENDING_START" | "IN_PROGRESS" | "PENDING_CUSTOMER_APPROVAL" | "COMPLETED" | "FAILED" | "TIMED_OUT" | "CANCELED" | (string & {});
export declare const TaskStatus: S.String;
export interface Task {
    agentSpaceId: string;
    taskId: string;
    executionId?: string;
    title: string;
    description?: string;
    reference?: ReferenceOutput;
    taskType: TaskType;
    priority: Priority;
    status: TaskStatus;
    createdAt: Date;
    updatedAt: Date;
    version: number;
    supportMetadata?: any;
    metadata?: any;
    primaryTaskId?: string;
    statusReason?: string;
    hasLinkedTasks?: boolean;
}
export declare const Task: S.Schema<Task>;
export interface CreateBacklogTaskResponse {
    task: Task;
}
export declare const CreateBacklogTaskResponse: S.Schema<CreateBacklogTaskResponse>;
export interface ValidationExceptionField {
    path: string;
    message: string;
}
export declare const ValidationExceptionField: S.Schema<ValidationExceptionField>;
export type ValidationExceptionFieldList = ValidationExceptionField[];
export declare const ValidationExceptionFieldList: S.$Array<S.Schema<ValidationExceptionField>>;
export type UserType = "IAM" | "IDC" | "IDP" | (string & {});
export declare const UserType: S.String;
export interface CreateChatRequest {
    agentSpaceId: string;
    userId: string;
    userType?: UserType;
}
export declare const CreateChatRequest: S.Schema<CreateChatRequest>;
export interface CreateChatResponse {
    executionId: string;
    createdAt: Date;
}
export declare const CreateChatResponse: S.Schema<CreateChatResponse>;
export interface GetAccountUsageInput {
}
export declare const GetAccountUsageInput: S.Schema<GetAccountUsageInput>;
export interface UsageMetric {
    limit: number;
    usage: number;
}
export declare const UsageMetric: S.Schema<UsageMetric>;
export interface GetAccountUsageOutput {
    monthlyAccountInvestigationHours?: UsageMetric;
    monthlyAccountEvaluationHours?: UsageMetric;
    monthlyAccountSystemLearningHours?: UsageMetric;
    monthlyAccountOnDemandHours?: UsageMetric;
    usagePeriodStartTime: Date;
    usagePeriodEndTime: Date;
}
export declare const GetAccountUsageOutput: S.Schema<GetAccountUsageOutput>;
export interface GetBacklogTaskRequest {
    agentSpaceId: string;
    taskId: string;
}
export declare const GetBacklogTaskRequest: S.Schema<GetBacklogTaskRequest>;
export interface GetBacklogTaskResponse {
    task: Task;
}
export declare const GetBacklogTaskResponse: S.Schema<GetBacklogTaskResponse>;
export interface GetRecommendationRequest {
    agentSpaceId: string;
    recommendationId: string;
    recommendationVersion?: number;
}
export declare const GetRecommendationRequest: S.Schema<GetRecommendationRequest>;
export interface RecommendationContent {
    summary: string;
    spec?: string;
}
export declare const RecommendationContent: S.Schema<RecommendationContent>;
export type RecommendationStatus = "PROPOSED" | "ACCEPTED" | "REJECTED" | "CLOSED" | "COMPLETED" | "UPDATE_IN_PROGRESS" | (string & {});
export declare const RecommendationStatus: S.String;
export type RecommendationPriority = "HIGH" | "MEDIUM" | "LOW" | (string & {});
export declare const RecommendationPriority: S.String;
export interface Recommendation {
    agentSpaceArn: string;
    recommendationId: string;
    taskId: string;
    goalId?: string;
    title: string;
    content: RecommendationContent;
    status: RecommendationStatus;
    priority: RecommendationPriority;
    goalVersion?: number;
    additionalContext?: string;
    createdAt: Date;
    updatedAt: Date;
    version: number;
}
export declare const Recommendation: S.Schema<Recommendation>;
export interface GetRecommendationResponse {
    recommendation: Recommendation;
}
export declare const GetRecommendationResponse: S.Schema<GetRecommendationResponse>;
export type PriorityList = Priority[];
export declare const PriorityList: S.$Array<S.String>;
export type TaskStatusList = TaskStatus[];
export declare const TaskStatusList: S.$Array<S.String>;
export type TaskTypeList = TaskType[];
export declare const TaskTypeList: S.$Array<S.String>;
export interface TaskFilter {
    createdAfter?: Date;
    createdBefore?: Date;
    priority?: Priority[];
    status?: TaskStatus[];
    taskType?: TaskType[];
    primaryTaskId?: string;
}
export declare const TaskFilter: S.Schema<TaskFilter>;
export type TaskSortField = "CREATED_AT" | "PRIORITY" | (string & {});
export declare const TaskSortField: S.String;
export type TaskSortOrder = "ASC" | "DESC" | (string & {});
export declare const TaskSortOrder: S.String;
export interface ListBacklogTasksRequest {
    agentSpaceId: string;
    filter?: TaskFilter;
    limit?: number;
    nextToken?: string;
    sortField?: TaskSortField;
    order?: TaskSortOrder;
}
export declare const ListBacklogTasksRequest: S.Schema<ListBacklogTasksRequest>;
export type TaskList = Task[];
export declare const TaskList: S.$Array<S.Schema<Task>>;
export interface ListBacklogTasksResponse {
    tasks: Task[];
    nextToken?: string;
}
export declare const ListBacklogTasksResponse: S.Schema<ListBacklogTasksResponse>;
export interface ListChatsRequest {
    agentSpaceId: string;
    userId: string;
    maxResults?: number;
    nextToken?: string;
}
export declare const ListChatsRequest: S.Schema<ListChatsRequest>;
export interface ChatExecution {
    executionId: string;
    createdAt: Date;
    updatedAt?: Date;
    summary?: string;
}
export declare const ChatExecution: S.Schema<ChatExecution>;
export type ChatExecutionList = ChatExecution[];
export declare const ChatExecutionList: S.$Array<S.Schema<ChatExecution>>;
export interface ListChatsResponse {
    executions: ChatExecution[];
    nextToken?: string;
}
export declare const ListChatsResponse: S.Schema<ListChatsResponse>;
export interface ListExecutionsRequest {
    agentSpaceId: string;
    taskId: string;
    limit?: number;
    nextToken?: string;
}
export declare const ListExecutionsRequest: S.Schema<ListExecutionsRequest>;
export type ExecutionStatus = "FAILED" | "RUNNING" | "STOPPED" | "CANCELED" | "TIMED_OUT" | (string & {});
export declare const ExecutionStatus: S.String;
export interface Execution {
    agentSpaceId: string;
    executionId: string;
    parentExecutionId?: string;
    agentSubTask: string;
    createdAt: Date;
    updatedAt: Date;
    executionStatus: ExecutionStatus;
    agentType?: string;
    uid?: string;
}
export declare const Execution: S.Schema<Execution>;
export type ExecutionList = Execution[];
export declare const ExecutionList: S.$Array<S.Schema<Execution>>;
export interface ListExecutionsResponse {
    executions: Execution[];
    nextToken?: string;
}
export declare const ListExecutionsResponse: S.Schema<ListExecutionsResponse>;
export type GoalStatus = "ACTIVE" | "PAUSED" | "COMPLETE" | (string & {});
export declare const GoalStatus: S.String;
export type GoalType = "CUSTOMER_DEFINED" | "ONCALL_REPORT" | (string & {});
export declare const GoalType: S.String;
export interface ListGoalsRequest {
    agentSpaceId: string;
    status?: GoalStatus;
    goalType?: GoalType;
    limit?: number;
    nextToken?: string;
}
export declare const ListGoalsRequest: S.Schema<ListGoalsRequest>;
export interface GoalContent {
    description: string;
    objectives: string;
}
export declare const GoalContent: S.Schema<GoalContent>;
export type SchedulerState = "ENABLED" | "DISABLED" | (string & {});
export declare const SchedulerState: S.String;
export interface GoalSchedule {
    state: SchedulerState;
    expression?: string;
}
export declare const GoalSchedule: S.Schema<GoalSchedule>;
export interface Goal {
    agentSpaceArn: string;
    goalId: string;
    title: string;
    content: GoalContent;
    status: GoalStatus;
    goalType: GoalType;
    createdAt: Date;
    updatedAt: Date;
    lastEvaluatedAt?: Date;
    lastTaskId?: string;
    lastSuccessfulTaskId?: string;
    version: number;
    evaluationSchedule?: GoalSchedule;
}
export declare const Goal: S.Schema<Goal>;
export type GoalList = Goal[];
export declare const GoalList: S.$Array<S.Schema<Goal>>;
export interface ListGoalsResponse {
    goals: Goal[];
    nextToken?: string;
}
export declare const ListGoalsResponse: S.Schema<ListGoalsResponse>;
export type OrderType = "ASC" | "DESC" | (string & {});
export declare const OrderType: S.String;
export interface ListJournalRecordsRequest {
    agentSpaceId: string;
    executionId: string;
    limit?: number;
    nextToken?: string;
    recordType?: string;
    order?: OrderType;
}
export declare const ListJournalRecordsRequest: S.Schema<ListJournalRecordsRequest>;
export interface UserReference {
    userId: string;
    userType: UserType;
}
export declare const UserReference: S.Schema<UserReference>;
export interface JournalRecord {
    agentSpaceId: string;
    executionId: string;
    recordId: string;
    content: any;
    createdAt: Date;
    recordType: string;
    userReference?: UserReference;
}
export declare const JournalRecord: S.Schema<JournalRecord>;
export type JournalRecordList = JournalRecord[];
export declare const JournalRecordList: S.$Array<S.Schema<JournalRecord>>;
export interface ListJournalRecordsResponse {
    records: JournalRecord[];
    nextToken?: string;
}
export declare const ListJournalRecordsResponse: S.Schema<ListJournalRecordsResponse>;
export interface ListPendingMessagesRequest {
    agentSpaceId: string;
    executionId: string;
}
export declare const ListPendingMessagesRequest: S.Schema<ListPendingMessagesRequest>;
export type UserMessageBlock = {
    text: string;
    toolResult?: never;
} | {
    text?: never;
    toolResult: any;
};
export declare const UserMessageBlock: S.Union<readonly [S.Struct<{
    readonly text: S.String;
}>, S.Struct<{
    readonly toolResult: S.Any;
}>]>;
export type UserMessage = UserMessageBlock[];
export declare const UserMessage: S.$Array<S.Union<readonly [S.Struct<{
    readonly text: S.String;
}>, S.Struct<{
    readonly toolResult: S.Any;
}>]>>;
export type AssistantMessageBlock = {
    text: string;
    toolUse?: never;
} | {
    text?: never;
    toolUse: any;
};
export declare const AssistantMessageBlock: S.Union<readonly [S.Struct<{
    readonly text: S.String;
}>, S.Struct<{
    readonly toolUse: S.Any;
}>]>;
export type AssistantMessage = AssistantMessageBlock[];
export declare const AssistantMessage: S.$Array<S.Union<readonly [S.Struct<{
    readonly text: S.String;
}>, S.Struct<{
    readonly toolUse: S.Any;
}>]>>;
export type Message = {
    userMessage: UserMessageBlock[];
    assistantMessage?: never;
} | {
    userMessage?: never;
    assistantMessage: AssistantMessageBlock[];
};
export declare const Message: S.Union<readonly [S.Struct<{
    readonly userMessage: S.$Array<S.Union<readonly [S.Struct<{
        readonly text: S.String;
    }>, S.Struct<{
        readonly toolResult: S.Any;
    }>]>>;
}>, S.Struct<{
    readonly assistantMessage: S.$Array<S.Union<readonly [S.Struct<{
        readonly text: S.String;
    }>, S.Struct<{
        readonly toolUse: S.Any;
    }>]>>;
}>]>;
export interface PendingMessage {
    messageId: string;
    message: Message;
}
export declare const PendingMessage: S.Schema<PendingMessage>;
export type PendingMessages = PendingMessage[];
export declare const PendingMessages: S.$Array<S.Schema<PendingMessage>>;
export interface ListPendingMessagesResponse {
    agentSpaceId: string;
    executionId: string;
    messages: PendingMessage[];
    createdAt: Date;
}
export declare const ListPendingMessagesResponse: S.Schema<ListPendingMessagesResponse>;
export interface ListRecommendationsRequest {
    agentSpaceId: string;
    taskId?: string;
    goalId?: string;
    status?: RecommendationStatus;
    priority?: RecommendationPriority;
    limit?: number;
    nextToken?: string;
}
export declare const ListRecommendationsRequest: S.Schema<ListRecommendationsRequest>;
export type RecommendationList = Recommendation[];
export declare const RecommendationList: S.$Array<S.Schema<Recommendation>>;
export interface ListRecommendationsResponse {
    recommendations: Recommendation[];
    nextToken?: string;
}
export declare const ListRecommendationsResponse: S.Schema<ListRecommendationsResponse>;
export interface ListTagsForResourceRequest {
    resourceArn: string;
}
export declare const ListTagsForResourceRequest: S.Schema<ListTagsForResourceRequest>;
export type Tags = {
    [key: string]: string | undefined;
};
export declare const Tags: S.$Record<S.String, S.optional<S.String>>;
export interface ListTagsForResourceResponse {
    tags: {
        [key: string]: string | undefined;
    };
}
export declare const ListTagsForResourceResponse: S.Schema<ListTagsForResourceResponse>;
export interface SendMessageContext {
    currentPage?: string;
    lastMessage?: string;
    userActionResponse?: string;
}
export declare const SendMessageContext: S.Schema<SendMessageContext>;
export interface SendMessageRequest {
    agentSpaceId: string;
    executionId: string;
    content: string;
    context?: SendMessageContext;
    userId: string;
}
export declare const SendMessageRequest: S.Schema<SendMessageRequest>;
export interface SendMessageResponseCreatedEvent {
    responseId?: string;
    sequenceNumber?: number;
}
export declare const SendMessageResponseCreatedEvent: S.Schema<SendMessageResponseCreatedEvent>;
export interface SendMessageResponseInProgressEvent {
    responseId?: string;
    sequenceNumber?: number;
}
export declare const SendMessageResponseInProgressEvent: S.Schema<SendMessageResponseInProgressEvent>;
export interface SendMessageUsageInfo {
    inputTokens?: number;
    outputTokens?: number;
    totalTokens?: number;
}
export declare const SendMessageUsageInfo: S.Schema<SendMessageUsageInfo>;
export interface SendMessageResponseCompletedEvent {
    responseId?: string;
    usage?: SendMessageUsageInfo;
    sequenceNumber?: number;
}
export declare const SendMessageResponseCompletedEvent: S.Schema<SendMessageResponseCompletedEvent>;
export interface SendMessageResponseFailedEvent {
    responseId?: string;
    errorCode?: string;
    errorMessage?: string;
    sequenceNumber?: number;
}
export declare const SendMessageResponseFailedEvent: S.Schema<SendMessageResponseFailedEvent>;
export interface SendMessageSummaryEvent {
    content?: string;
    sequenceNumber?: number;
}
export declare const SendMessageSummaryEvent: S.Schema<SendMessageSummaryEvent>;
export interface SendMessageHeartbeatEvent {
}
export declare const SendMessageHeartbeatEvent: S.Schema<SendMessageHeartbeatEvent>;
export interface SendMessageContentBlockStartEvent {
    index?: number;
    type?: string;
    id?: string;
    parentId?: string;
    sequenceNumber?: number;
}
export declare const SendMessageContentBlockStartEvent: S.Schema<SendMessageContentBlockStartEvent>;
export interface SendMessageTextDelta {
    text?: string;
}
export declare const SendMessageTextDelta: S.Schema<SendMessageTextDelta>;
export interface SendMessageJsonDelta {
    partialJson?: string;
}
export declare const SendMessageJsonDelta: S.Schema<SendMessageJsonDelta>;
export type SendMessageContentBlockDelta = {
    textDelta: SendMessageTextDelta;
    jsonDelta?: never;
} | {
    textDelta?: never;
    jsonDelta: SendMessageJsonDelta;
};
export declare const SendMessageContentBlockDelta: S.Union<readonly [S.Struct<{
    readonly textDelta: S.Schema<SendMessageTextDelta>;
}>, S.Struct<{
    readonly jsonDelta: S.Schema<SendMessageJsonDelta>;
}>]>;
export interface SendMessageContentBlockDeltaEvent {
    index?: number;
    delta?: SendMessageContentBlockDelta;
    sequenceNumber?: number;
}
export declare const SendMessageContentBlockDeltaEvent: S.Schema<SendMessageContentBlockDeltaEvent>;
export interface SendMessageContentBlockStopEvent {
    index?: number;
    type?: string;
    text?: string;
    last?: boolean;
    sequenceNumber?: number;
}
export declare const SendMessageContentBlockStopEvent: S.Schema<SendMessageContentBlockStopEvent>;
export type SendMessageEvents = {
    responseCreated: SendMessageResponseCreatedEvent;
    responseInProgress?: never;
    responseCompleted?: never;
    responseFailed?: never;
    summary?: never;
    heartbeat?: never;
    contentBlockStart?: never;
    contentBlockDelta?: never;
    contentBlockStop?: never;
} | {
    responseCreated?: never;
    responseInProgress: SendMessageResponseInProgressEvent;
    responseCompleted?: never;
    responseFailed?: never;
    summary?: never;
    heartbeat?: never;
    contentBlockStart?: never;
    contentBlockDelta?: never;
    contentBlockStop?: never;
} | {
    responseCreated?: never;
    responseInProgress?: never;
    responseCompleted: SendMessageResponseCompletedEvent;
    responseFailed?: never;
    summary?: never;
    heartbeat?: never;
    contentBlockStart?: never;
    contentBlockDelta?: never;
    contentBlockStop?: never;
} | {
    responseCreated?: never;
    responseInProgress?: never;
    responseCompleted?: never;
    responseFailed: SendMessageResponseFailedEvent;
    summary?: never;
    heartbeat?: never;
    contentBlockStart?: never;
    contentBlockDelta?: never;
    contentBlockStop?: never;
} | {
    responseCreated?: never;
    responseInProgress?: never;
    responseCompleted?: never;
    responseFailed?: never;
    summary: SendMessageSummaryEvent;
    heartbeat?: never;
    contentBlockStart?: never;
    contentBlockDelta?: never;
    contentBlockStop?: never;
} | {
    responseCreated?: never;
    responseInProgress?: never;
    responseCompleted?: never;
    responseFailed?: never;
    summary?: never;
    heartbeat: SendMessageHeartbeatEvent;
    contentBlockStart?: never;
    contentBlockDelta?: never;
    contentBlockStop?: never;
} | {
    responseCreated?: never;
    responseInProgress?: never;
    responseCompleted?: never;
    responseFailed?: never;
    summary?: never;
    heartbeat?: never;
    contentBlockStart: SendMessageContentBlockStartEvent;
    contentBlockDelta?: never;
    contentBlockStop?: never;
} | {
    responseCreated?: never;
    responseInProgress?: never;
    responseCompleted?: never;
    responseFailed?: never;
    summary?: never;
    heartbeat?: never;
    contentBlockStart?: never;
    contentBlockDelta: SendMessageContentBlockDeltaEvent;
    contentBlockStop?: never;
} | {
    responseCreated?: never;
    responseInProgress?: never;
    responseCompleted?: never;
    responseFailed?: never;
    summary?: never;
    heartbeat?: never;
    contentBlockStart?: never;
    contentBlockDelta?: never;
    contentBlockStop: SendMessageContentBlockStopEvent;
};
export declare const SendMessageEvents: S.Schema<stream.Stream<SendMessageEvents, Error, never>>;
export interface SendMessageResponse {
    events: stream.Stream<SendMessageEvents, Error, never>;
}
export declare const SendMessageResponse: S.Schema<SendMessageResponse>;
export interface TagResourceRequest {
    resourceArn: string;
    tags: {
        [key: string]: string | undefined;
    };
}
export declare const TagResourceRequest: S.Schema<TagResourceRequest>;
export interface TagResourceResponse {
}
export declare const TagResourceResponse: S.Schema<TagResourceResponse>;
export type TagKeyList = string[];
export declare const TagKeyList: S.$Array<S.String>;
export interface UntagResourceRequest {
    resourceArn: string;
    tagKeys: string[];
}
export declare const UntagResourceRequest: S.Schema<UntagResourceRequest>;
export interface UntagResourceResponse {
}
export declare const UntagResourceResponse: S.Schema<UntagResourceResponse>;
export interface UpdateBacklogTaskRequest {
    agentSpaceId: string;
    taskId: string;
    taskStatus?: TaskStatus;
    clientToken?: string;
}
export declare const UpdateBacklogTaskRequest: S.Schema<UpdateBacklogTaskRequest>;
export interface UpdateBacklogTaskResponse {
    task: Task;
}
export declare const UpdateBacklogTaskResponse: S.Schema<UpdateBacklogTaskResponse>;
export interface GoalScheduleInput {
    state: SchedulerState;
}
export declare const GoalScheduleInput: S.Schema<GoalScheduleInput>;
export interface UpdateGoalRequest {
    agentSpaceId: string;
    goalId: string;
    evaluationSchedule?: GoalScheduleInput;
    clientToken?: string;
}
export declare const UpdateGoalRequest: S.Schema<UpdateGoalRequest>;
export interface UpdateGoalResponse {
    goal: Goal;
}
export declare const UpdateGoalResponse: S.Schema<UpdateGoalResponse>;
export interface UpdateRecommendationRequest {
    agentSpaceId: string;
    recommendationId: string;
    status?: RecommendationStatus;
    additionalContext?: string;
    clientToken?: string;
}
export declare const UpdateRecommendationRequest: S.Schema<UpdateRecommendationRequest>;
export interface UpdateRecommendationResponse {
    recommendation: Recommendation;
}
export declare const UpdateRecommendationResponse: S.Schema<UpdateRecommendationResponse>;
export interface CreateAgentSpaceInput {
    name: string;
    description?: string | redacted.Redacted<string>;
    locale?: string;
    kmsKeyArn?: string;
    clientToken?: string;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateAgentSpaceInput: S.Schema<CreateAgentSpaceInput>;
export interface AgentSpace {
    name: string;
    description?: string | redacted.Redacted<string>;
    locale?: string;
    createdAt: Date;
    updatedAt: Date;
    kmsKeyArn?: string;
    agentSpaceId: string;
}
export declare const AgentSpace: S.Schema<AgentSpace>;
export interface CreateAgentSpaceOutput {
    agentSpace: AgentSpace;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateAgentSpaceOutput: S.Schema<CreateAgentSpaceOutput>;
export interface GetAgentSpaceInput {
    agentSpaceId: string;
}
export declare const GetAgentSpaceInput: S.Schema<GetAgentSpaceInput>;
export interface GetAgentSpaceOutput {
    agentSpace: AgentSpace;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const GetAgentSpaceOutput: S.Schema<GetAgentSpaceOutput>;
export interface UpdateAgentSpaceInput {
    agentSpaceId: string;
    name?: string;
    description?: string | redacted.Redacted<string>;
    locale?: string;
}
export declare const UpdateAgentSpaceInput: S.Schema<UpdateAgentSpaceInput>;
export interface UpdateAgentSpaceOutput {
    agentSpace: AgentSpace;
}
export declare const UpdateAgentSpaceOutput: S.Schema<UpdateAgentSpaceOutput>;
export interface DeleteAgentSpaceInput {
    agentSpaceId: string;
}
export declare const DeleteAgentSpaceInput: S.Schema<DeleteAgentSpaceInput>;
export interface DeleteAgentSpaceOutput {
}
export declare const DeleteAgentSpaceOutput: S.Schema<DeleteAgentSpaceOutput>;
export type AuthFlow = "iam" | "idc" | "idp" | (string & {});
export declare const AuthFlow: S.String;
export interface DisableOperatorAppInput {
    agentSpaceId: string;
    authFlow?: AuthFlow;
}
export declare const DisableOperatorAppInput: S.Schema<DisableOperatorAppInput>;
export interface DisableOperatorAppResponse {
}
export declare const DisableOperatorAppResponse: S.Schema<DisableOperatorAppResponse>;
export interface EnableOperatorAppInput {
    agentSpaceId: string;
    authFlow: AuthFlow;
    operatorAppRoleArn: string;
    idcInstanceArn?: string;
    issuerUrl?: string;
    idpClientId?: string;
    idpClientSecret?: string | redacted.Redacted<string>;
    provider?: string;
}
export declare const EnableOperatorAppInput: S.Schema<EnableOperatorAppInput>;
export interface IamAuthConfiguration {
    operatorAppRoleArn: string;
    createdAt: Date;
    updatedAt?: Date;
}
export declare const IamAuthConfiguration: S.Schema<IamAuthConfiguration>;
export interface IdcAuthConfiguration {
    operatorAppRoleArn: string;
    idcInstanceArn: string;
    idcApplicationArn?: string;
    createdAt: Date;
    updatedAt?: Date;
}
export declare const IdcAuthConfiguration: S.Schema<IdcAuthConfiguration>;
export interface IdpAuthConfiguration {
    issuerUrl: string;
    clientId: string;
    operatorAppRoleArn: string;
    provider: string;
    createdAt: Date;
    updatedAt?: Date;
}
export declare const IdpAuthConfiguration: S.Schema<IdpAuthConfiguration>;
export interface EnableOperatorAppOutput {
    agentSpaceId: string;
    iam?: IamAuthConfiguration;
    idc?: IdcAuthConfiguration;
    idp?: IdpAuthConfiguration;
}
export declare const EnableOperatorAppOutput: S.Schema<EnableOperatorAppOutput>;
export interface GetOperatorAppInput {
    agentSpaceId: string;
}
export declare const GetOperatorAppInput: S.Schema<GetOperatorAppInput>;
export interface GetOperatorAppOutput {
    iam?: IamAuthConfiguration;
    idc?: IdcAuthConfiguration;
    idp?: IdpAuthConfiguration;
}
export declare const GetOperatorAppOutput: S.Schema<GetOperatorAppOutput>;
export interface UpdateOperatorAppIdpConfigInput {
    agentSpaceId: string;
    idpClientSecret?: string | redacted.Redacted<string>;
}
export declare const UpdateOperatorAppIdpConfigInput: S.Schema<UpdateOperatorAppIdpConfigInput>;
export interface UpdateOperatorAppIdpConfigOutput {
    agentSpaceId: string;
    idp: IdpAuthConfiguration;
}
export declare const UpdateOperatorAppIdpConfigOutput: S.Schema<UpdateOperatorAppIdpConfigOutput>;
export interface ListAgentSpacesInput {
    maxResults?: number;
    nextToken?: string;
}
export declare const ListAgentSpacesInput: S.Schema<ListAgentSpacesInput>;
export type AgentSpaceList = AgentSpace[];
export declare const AgentSpaceList: S.$Array<S.Schema<AgentSpace>>;
export interface ListAgentSpacesOutput {
    nextToken?: string;
    agentSpaces: AgentSpace[];
}
export declare const ListAgentSpacesOutput: S.Schema<ListAgentSpacesOutput>;
export type SourceAccountType = "source" | (string & {});
export declare const SourceAccountType: S.String;
export interface SourceAwsConfiguration {
    accountId: string;
    accountType: SourceAccountType;
    assumableRoleArn: string;
    externalId?: string;
}
export declare const SourceAwsConfiguration: S.Schema<SourceAwsConfiguration>;
export type MonitorAccountType = "monitor" | (string & {});
export declare const MonitorAccountType: S.String;
export interface AWSConfiguration {
    assumableRoleArn: string;
    accountId: string;
    accountType: MonitorAccountType;
}
export declare const AWSConfiguration: S.Schema<AWSConfiguration>;
export type GithubRepoOwnerType = "organization" | "user" | (string & {});
export declare const GithubRepoOwnerType: S.String;
export interface GitHubConfiguration {
    repoName: string;
    repoId: string;
    owner: string;
    ownerType: GithubRepoOwnerType;
    instanceIdentifier?: string;
}
export declare const GitHubConfiguration: S.Schema<GitHubConfiguration>;
export interface SlackChannel {
    channelName?: string;
    channelId: string;
}
export declare const SlackChannel: S.Schema<SlackChannel>;
export interface SlackTransmissionTarget {
    opsOncallTarget: SlackChannel;
    opsSRETarget?: SlackChannel;
}
export declare const SlackTransmissionTarget: S.Schema<SlackTransmissionTarget>;
export interface SlackConfiguration {
    workspaceId: string;
    workspaceName: string;
    transmissionTarget: SlackTransmissionTarget;
}
export declare const SlackConfiguration: S.Schema<SlackConfiguration>;
export type DynatraceResourceList = string[];
export declare const DynatraceResourceList: S.$Array<S.String>;
export interface DynatraceConfiguration {
    envId: string;
    resources?: string[];
}
export declare const DynatraceConfiguration: S.Schema<DynatraceConfiguration>;
export type ServiceNowAuthenticationScopeList = string[];
export declare const ServiceNowAuthenticationScopeList: S.$Array<S.String>;
export interface ServiceNowConfiguration {
    instanceId?: string;
    authScopes?: string[];
}
export declare const ServiceNowConfiguration: S.Schema<ServiceNowConfiguration>;
export interface MCPServerNewRelicConfiguration {
    accountId: string;
    endpoint: string;
}
export declare const MCPServerNewRelicConfiguration: S.Schema<MCPServerNewRelicConfiguration>;
export interface MCPServerDatadogConfiguration {
}
export declare const MCPServerDatadogConfiguration: S.Schema<MCPServerDatadogConfiguration>;
export type MCPToolsList = string[];
export declare const MCPToolsList: S.$Array<S.String>;
export interface MCPServerConfiguration {
    tools: string[];
}
export declare const MCPServerConfiguration: S.Schema<MCPServerConfiguration>;
export interface GitLabConfiguration {
    projectId: string;
    projectPath: string;
    instanceIdentifier?: string;
}
export declare const GitLabConfiguration: S.Schema<GitLabConfiguration>;
export interface MCPServerSplunkConfiguration {
}
export declare const MCPServerSplunkConfiguration: S.Schema<MCPServerSplunkConfiguration>;
export interface EventChannelConfiguration {
}
export declare const EventChannelConfiguration: S.Schema<EventChannelConfiguration>;
export interface AzureConfiguration {
    subscriptionId: string;
}
export declare const AzureConfiguration: S.Schema<AzureConfiguration>;
export interface AzureDevOpsConfiguration {
    organizationName: string;
    projectId: string;
    projectName: string;
}
export declare const AzureDevOpsConfiguration: S.Schema<AzureDevOpsConfiguration>;
export interface MCPServerGrafanaConfiguration {
    endpoint: string;
    organizationId?: string;
    tools?: string[];
}
export declare const MCPServerGrafanaConfiguration: S.Schema<MCPServerGrafanaConfiguration>;
export type PagerDutyServicesList = string[];
export declare const PagerDutyServicesList: S.$Array<S.String>;
export interface PagerDutyConfiguration {
    services: string[];
    customerEmail: string | redacted.Redacted<string>;
}
export declare const PagerDutyConfiguration: S.Schema<PagerDutyConfiguration>;
export type ServiceConfiguration = {
    sourceAws: SourceAwsConfiguration;
    aws?: never;
    github?: never;
    slack?: never;
    dynatrace?: never;
    servicenow?: never;
    mcpservernewrelic?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    eventChannel?: never;
    azure?: never;
    azuredevops?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
} | {
    sourceAws?: never;
    aws: AWSConfiguration;
    github?: never;
    slack?: never;
    dynatrace?: never;
    servicenow?: never;
    mcpservernewrelic?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    eventChannel?: never;
    azure?: never;
    azuredevops?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
} | {
    sourceAws?: never;
    aws?: never;
    github: GitHubConfiguration;
    slack?: never;
    dynatrace?: never;
    servicenow?: never;
    mcpservernewrelic?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    eventChannel?: never;
    azure?: never;
    azuredevops?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
} | {
    sourceAws?: never;
    aws?: never;
    github?: never;
    slack: SlackConfiguration;
    dynatrace?: never;
    servicenow?: never;
    mcpservernewrelic?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    eventChannel?: never;
    azure?: never;
    azuredevops?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
} | {
    sourceAws?: never;
    aws?: never;
    github?: never;
    slack?: never;
    dynatrace: DynatraceConfiguration;
    servicenow?: never;
    mcpservernewrelic?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    eventChannel?: never;
    azure?: never;
    azuredevops?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
} | {
    sourceAws?: never;
    aws?: never;
    github?: never;
    slack?: never;
    dynatrace?: never;
    servicenow: ServiceNowConfiguration;
    mcpservernewrelic?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    eventChannel?: never;
    azure?: never;
    azuredevops?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
} | {
    sourceAws?: never;
    aws?: never;
    github?: never;
    slack?: never;
    dynatrace?: never;
    servicenow?: never;
    mcpservernewrelic: MCPServerNewRelicConfiguration;
    mcpserverdatadog?: never;
    mcpserver?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    eventChannel?: never;
    azure?: never;
    azuredevops?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
} | {
    sourceAws?: never;
    aws?: never;
    github?: never;
    slack?: never;
    dynatrace?: never;
    servicenow?: never;
    mcpservernewrelic?: never;
    mcpserverdatadog: MCPServerDatadogConfiguration;
    mcpserver?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    eventChannel?: never;
    azure?: never;
    azuredevops?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
} | {
    sourceAws?: never;
    aws?: never;
    github?: never;
    slack?: never;
    dynatrace?: never;
    servicenow?: never;
    mcpservernewrelic?: never;
    mcpserverdatadog?: never;
    mcpserver: MCPServerConfiguration;
    gitlab?: never;
    mcpserversplunk?: never;
    eventChannel?: never;
    azure?: never;
    azuredevops?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
} | {
    sourceAws?: never;
    aws?: never;
    github?: never;
    slack?: never;
    dynatrace?: never;
    servicenow?: never;
    mcpservernewrelic?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    gitlab: GitLabConfiguration;
    mcpserversplunk?: never;
    eventChannel?: never;
    azure?: never;
    azuredevops?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
} | {
    sourceAws?: never;
    aws?: never;
    github?: never;
    slack?: never;
    dynatrace?: never;
    servicenow?: never;
    mcpservernewrelic?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    gitlab?: never;
    mcpserversplunk: MCPServerSplunkConfiguration;
    eventChannel?: never;
    azure?: never;
    azuredevops?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
} | {
    sourceAws?: never;
    aws?: never;
    github?: never;
    slack?: never;
    dynatrace?: never;
    servicenow?: never;
    mcpservernewrelic?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    eventChannel: EventChannelConfiguration;
    azure?: never;
    azuredevops?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
} | {
    sourceAws?: never;
    aws?: never;
    github?: never;
    slack?: never;
    dynatrace?: never;
    servicenow?: never;
    mcpservernewrelic?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    eventChannel?: never;
    azure: AzureConfiguration;
    azuredevops?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
} | {
    sourceAws?: never;
    aws?: never;
    github?: never;
    slack?: never;
    dynatrace?: never;
    servicenow?: never;
    mcpservernewrelic?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    eventChannel?: never;
    azure?: never;
    azuredevops: AzureDevOpsConfiguration;
    mcpservergrafana?: never;
    pagerduty?: never;
} | {
    sourceAws?: never;
    aws?: never;
    github?: never;
    slack?: never;
    dynatrace?: never;
    servicenow?: never;
    mcpservernewrelic?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    eventChannel?: never;
    azure?: never;
    azuredevops?: never;
    mcpservergrafana: MCPServerGrafanaConfiguration;
    pagerduty?: never;
} | {
    sourceAws?: never;
    aws?: never;
    github?: never;
    slack?: never;
    dynatrace?: never;
    servicenow?: never;
    mcpservernewrelic?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    eventChannel?: never;
    azure?: never;
    azuredevops?: never;
    mcpservergrafana?: never;
    pagerduty: PagerDutyConfiguration;
};
export declare const ServiceConfiguration: S.Union<readonly [S.Struct<{
    readonly sourceAws: S.Schema<SourceAwsConfiguration>;
}>, S.Struct<{
    readonly aws: S.Schema<AWSConfiguration>;
}>, S.Struct<{
    readonly github: S.Schema<GitHubConfiguration>;
}>, S.Struct<{
    readonly slack: S.Schema<SlackConfiguration>;
}>, S.Struct<{
    readonly dynatrace: S.Schema<DynatraceConfiguration>;
}>, S.Struct<{
    readonly servicenow: S.Schema<ServiceNowConfiguration>;
}>, S.Struct<{
    readonly mcpservernewrelic: S.Schema<MCPServerNewRelicConfiguration>;
}>, S.Struct<{
    readonly mcpserverdatadog: S.Schema<MCPServerDatadogConfiguration>;
}>, S.Struct<{
    readonly mcpserver: S.Schema<MCPServerConfiguration>;
}>, S.Struct<{
    readonly gitlab: S.Schema<GitLabConfiguration>;
}>, S.Struct<{
    readonly mcpserversplunk: S.Schema<MCPServerSplunkConfiguration>;
}>, S.Struct<{
    readonly eventChannel: S.Schema<EventChannelConfiguration>;
}>, S.Struct<{
    readonly azure: S.Schema<AzureConfiguration>;
}>, S.Struct<{
    readonly azuredevops: S.Schema<AzureDevOpsConfiguration>;
}>, S.Struct<{
    readonly mcpservergrafana: S.Schema<MCPServerGrafanaConfiguration>;
}>, S.Struct<{
    readonly pagerduty: S.Schema<PagerDutyConfiguration>;
}>]>;
export interface AssociateServiceInput {
    agentSpaceId: string;
    serviceId: string;
    configuration: ServiceConfiguration;
}
export declare const AssociateServiceInput: S.Schema<AssociateServiceInput>;
export type ValidationStatus = "valid" | "invalid" | "pending-confirmation" | (string & {});
export declare const ValidationStatus: S.String;
export interface Association {
    agentSpaceId: string;
    createdAt: Date;
    updatedAt: Date;
    status?: ValidationStatus;
    associationId: string;
    serviceId: string;
    configuration: ServiceConfiguration;
}
export declare const Association: S.Schema<Association>;
export type WebhookType = "hmac" | "apikey" | "gitlab" | "pagerduty" | (string & {});
export declare const WebhookType: S.String;
export interface GenericWebhook {
    webhookUrl?: string;
    webhookId?: string;
    webhookType?: WebhookType;
    webhookSecret?: string | redacted.Redacted<string>;
    apiKey?: string | redacted.Redacted<string>;
}
export declare const GenericWebhook: S.Schema<GenericWebhook>;
export interface AssociateServiceOutput {
    association: Association;
    webhook?: GenericWebhook;
}
export declare const AssociateServiceOutput: S.Schema<AssociateServiceOutput>;
export interface GetAssociationInput {
    agentSpaceId: string;
    associationId: string;
}
export declare const GetAssociationInput: S.Schema<GetAssociationInput>;
export interface GetAssociationOutput {
    association: Association;
}
export declare const GetAssociationOutput: S.Schema<GetAssociationOutput>;
export interface UpdateAssociationInput {
    agentSpaceId: string;
    associationId: string;
    configuration: ServiceConfiguration;
}
export declare const UpdateAssociationInput: S.Schema<UpdateAssociationInput>;
export interface UpdateAssociationOutput {
    association: Association;
    webhook?: GenericWebhook;
}
export declare const UpdateAssociationOutput: S.Schema<UpdateAssociationOutput>;
export interface DisassociateServiceInput {
    agentSpaceId: string;
    associationId: string;
}
export declare const DisassociateServiceInput: S.Schema<DisassociateServiceInput>;
export interface DisassociateServiceOutput {
}
export declare const DisassociateServiceOutput: S.Schema<DisassociateServiceOutput>;
export interface ListWebhooksInput {
    agentSpaceId: string;
    associationId: string;
}
export declare const ListWebhooksInput: S.Schema<ListWebhooksInput>;
export interface Webhook {
    webhookUrl: string;
    webhookType?: WebhookType;
    webhookId: string;
}
export declare const Webhook: S.Schema<Webhook>;
export type WebhooksList = Webhook[];
export declare const WebhooksList: S.$Array<S.Schema<Webhook>>;
export interface ListWebhooksOutput {
    webhooks: Webhook[];
}
export declare const ListWebhooksOutput: S.Schema<ListWebhooksOutput>;
export interface ListAssociationsInput {
    agentSpaceId: string;
    maxResults?: number;
    nextToken?: string;
    filterServiceTypes?: string;
}
export declare const ListAssociationsInput: S.Schema<ListAssociationsInput>;
export type AssociationsList = Association[];
export declare const AssociationsList: S.$Array<S.Schema<Association>>;
export interface ListAssociationsOutput {
    nextToken?: string;
    associations: Association[];
}
export declare const ListAssociationsOutput: S.Schema<ListAssociationsOutput>;
export interface ValidateAwsAssociationsInput {
    agentSpaceId: string;
}
export declare const ValidateAwsAssociationsInput: S.Schema<ValidateAwsAssociationsInput>;
export interface ValidateAwsAssociationsOutput {
}
export declare const ValidateAwsAssociationsOutput: S.Schema<ValidateAwsAssociationsOutput>;
export type ListOfSubnetIds = string[];
export declare const ListOfSubnetIds: S.$Array<S.String>;
export type ListOfSecurityGroupIds = string[];
export declare const ListOfSecurityGroupIds: S.$Array<S.String>;
export type IpAddressType = "IPV4" | "IPV6" | "DUAL_STACK" | (string & {});
export declare const IpAddressType: S.String;
export type PortRanges = string[];
export declare const PortRanges: S.$Array<S.String>;
export interface ServiceManagedInput {
    hostAddress: string;
    vpcId: string;
    subnetIds: string[];
    securityGroupIds?: string[];
    ipAddressType?: IpAddressType;
    ipv4AddressesPerEni?: number;
    portRanges?: string[];
    certificate?: string;
}
export declare const ServiceManagedInput: S.Schema<ServiceManagedInput>;
export interface SelfManagedInput {
    resourceConfigurationId: string;
    certificate?: string;
}
export declare const SelfManagedInput: S.Schema<SelfManagedInput>;
export type PrivateConnectionMode = {
    serviceManaged: ServiceManagedInput;
    selfManaged?: never;
} | {
    serviceManaged?: never;
    selfManaged: SelfManagedInput;
};
export declare const PrivateConnectionMode: S.Union<readonly [S.Struct<{
    readonly serviceManaged: S.Schema<ServiceManagedInput>;
}>, S.Struct<{
    readonly selfManaged: S.Schema<SelfManagedInput>;
}>]>;
export interface CreatePrivateConnectionInput {
    name: string;
    mode: PrivateConnectionMode;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreatePrivateConnectionInput: S.Schema<CreatePrivateConnectionInput>;
export type PrivateConnectionType = "SELF_MANAGED" | "SERVICE_MANAGED" | (string & {});
export declare const PrivateConnectionType: S.String;
export type PrivateConnectionStatus = "ACTIVE" | "CREATE_IN_PROGRESS" | "CREATE_FAILED" | "DELETE_IN_PROGRESS" | "DELETE_FAILED" | (string & {});
export declare const PrivateConnectionStatus: S.String;
export interface CreatePrivateConnectionOutput {
    name: string;
    type: PrivateConnectionType;
    resourceGatewayId?: string;
    hostAddress?: string;
    vpcId?: string;
    resourceConfigurationId?: string;
    status: PrivateConnectionStatus;
    certificateExpiryTime?: Date;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreatePrivateConnectionOutput: S.Schema<CreatePrivateConnectionOutput>;
export interface DescribePrivateConnectionInput {
    name: string;
}
export declare const DescribePrivateConnectionInput: S.Schema<DescribePrivateConnectionInput>;
export interface DescribePrivateConnectionOutput {
    name: string;
    type: PrivateConnectionType;
    resourceGatewayId?: string;
    hostAddress?: string;
    vpcId?: string;
    resourceConfigurationId?: string;
    status: PrivateConnectionStatus;
    certificateExpiryTime?: Date;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const DescribePrivateConnectionOutput: S.Schema<DescribePrivateConnectionOutput>;
export interface DeletePrivateConnectionInput {
    name: string;
}
export declare const DeletePrivateConnectionInput: S.Schema<DeletePrivateConnectionInput>;
export interface DeletePrivateConnectionOutput {
    name: string;
    status: PrivateConnectionStatus;
}
export declare const DeletePrivateConnectionOutput: S.Schema<DeletePrivateConnectionOutput>;
export interface ListPrivateConnectionsInput {
}
export declare const ListPrivateConnectionsInput: S.Schema<ListPrivateConnectionsInput>;
export interface PrivateConnectionSummary {
    name: string;
    type: PrivateConnectionType;
    resourceGatewayId?: string;
    hostAddress?: string;
    vpcId?: string;
    resourceConfigurationId?: string;
    status: PrivateConnectionStatus;
    certificateExpiryTime?: Date;
}
export declare const PrivateConnectionSummary: S.Schema<PrivateConnectionSummary>;
export type PrivateConnectionSummaryList = PrivateConnectionSummary[];
export declare const PrivateConnectionSummaryList: S.$Array<S.Schema<PrivateConnectionSummary>>;
export interface ListPrivateConnectionsOutput {
    privateConnections: PrivateConnectionSummary[];
}
export declare const ListPrivateConnectionsOutput: S.Schema<ListPrivateConnectionsOutput>;
export interface UpdatePrivateConnectionCertificateInput {
    name: string;
    certificate: string;
}
export declare const UpdatePrivateConnectionCertificateInput: S.Schema<UpdatePrivateConnectionCertificateInput>;
export interface UpdatePrivateConnectionCertificateOutput {
    name: string;
    type: PrivateConnectionType;
    resourceGatewayId?: string;
    hostAddress?: string;
    vpcId?: string;
    resourceConfigurationId?: string;
    status: PrivateConnectionStatus;
    certificateExpiryTime?: Date;
}
export declare const UpdatePrivateConnectionCertificateOutput: S.Schema<UpdatePrivateConnectionCertificateOutput>;
export type PostRegisterServiceSupportedService = "dynatrace" | "servicenow" | "pagerduty" | "gitlab" | "eventChannel" | "mcpservernewrelic" | "mcpservergrafana" | "mcpserverdatadog" | "mcpserver" | "mcpserversplunk" | "azureidentity" | (string & {});
export declare const PostRegisterServiceSupportedService: S.String;
export type ExchangeParameters = {
    [key: string]: string | redacted.Redacted<string> | undefined;
};
export declare const ExchangeParameters: S.$Record<S.String, S.optional<S.Schema<string | redacted.Redacted<string>>>>;
export interface DynatraceOAuthClientCredentialsConfig {
    clientName?: string;
    clientId: string | redacted.Redacted<string>;
    exchangeParameters?: {
        [key: string]: string | redacted.Redacted<string> | undefined;
    };
    clientSecret: string | redacted.Redacted<string>;
}
export declare const DynatraceOAuthClientCredentialsConfig: S.Schema<DynatraceOAuthClientCredentialsConfig>;
export type DynatraceServiceAuthorizationConfig = {
    oAuthClientCredentials: DynatraceOAuthClientCredentialsConfig;
};
export declare const DynatraceServiceAuthorizationConfig: S.Union<readonly [S.Struct<{
    readonly oAuthClientCredentials: S.Schema<DynatraceOAuthClientCredentialsConfig>;
}>]>;
export interface DynatraceServiceDetails {
    accountUrn: string;
    authorizationConfig?: DynatraceServiceAuthorizationConfig;
}
export declare const DynatraceServiceDetails: S.Schema<DynatraceServiceDetails>;
export interface ServiceNowOAuthClientCredentialsConfig {
    clientName?: string;
    clientId: string | redacted.Redacted<string>;
    exchangeParameters?: {
        [key: string]: string | redacted.Redacted<string> | undefined;
    };
    clientSecret: string | redacted.Redacted<string>;
}
export declare const ServiceNowOAuthClientCredentialsConfig: S.Schema<ServiceNowOAuthClientCredentialsConfig>;
export type ServiceNowServiceAuthorizationConfig = {
    oAuthClientCredentials: ServiceNowOAuthClientCredentialsConfig;
};
export declare const ServiceNowServiceAuthorizationConfig: S.Union<readonly [S.Struct<{
    readonly oAuthClientCredentials: S.Schema<ServiceNowOAuthClientCredentialsConfig>;
}>]>;
export interface ServiceNowServiceDetails {
    instanceUrl: string;
    authorizationConfig?: ServiceNowServiceAuthorizationConfig;
}
export declare const ServiceNowServiceDetails: S.Schema<ServiceNowServiceDetails>;
export interface MCPServerAuthorizationDiscoveryConfig {
    returnToEndpoint: string;
}
export declare const MCPServerAuthorizationDiscoveryConfig: S.Schema<MCPServerAuthorizationDiscoveryConfig>;
export type DatadogAuthorizationConfig = {
    authorizationDiscovery: MCPServerAuthorizationDiscoveryConfig;
};
export declare const DatadogAuthorizationConfig: S.Union<readonly [S.Struct<{
    readonly authorizationDiscovery: S.Schema<MCPServerAuthorizationDiscoveryConfig>;
}>]>;
export interface DatadogServiceDetails {
    name: string;
    endpoint: string;
    description?: string | redacted.Redacted<string>;
    authorizationConfig: DatadogAuthorizationConfig;
}
export declare const DatadogServiceDetails: S.Schema<DatadogServiceDetails>;
export type Scopes = string[];
export declare const Scopes: S.$Array<S.String>;
export interface MCPServerOAuthClientCredentialsConfig {
    clientName?: string;
    clientId: string | redacted.Redacted<string>;
    exchangeParameters?: {
        [key: string]: string | redacted.Redacted<string> | undefined;
    };
    clientSecret: string | redacted.Redacted<string>;
    exchangeUrl: string;
    scopes?: string[];
}
export declare const MCPServerOAuthClientCredentialsConfig: S.Schema<MCPServerOAuthClientCredentialsConfig>;
export interface MCPServerOAuth3LOConfig {
    clientName?: string;
    clientId: string | redacted.Redacted<string>;
    exchangeParameters?: {
        [key: string]: string | redacted.Redacted<string> | undefined;
    };
    returnToEndpoint: string;
    authorizationUrl: string;
    exchangeUrl: string;
    clientSecret?: string | redacted.Redacted<string>;
    supportCodeChallenge?: boolean;
    scopes?: string[];
}
export declare const MCPServerOAuth3LOConfig: S.Schema<MCPServerOAuth3LOConfig>;
export interface MCPServerAPIKeyConfig {
    apiKeyName: string;
    apiKeyValue: string | redacted.Redacted<string>;
    apiKeyHeader: string;
}
export declare const MCPServerAPIKeyConfig: S.Schema<MCPServerAPIKeyConfig>;
export interface MCPServerBearerTokenConfig {
    tokenName: string;
    tokenValue: string | redacted.Redacted<string>;
    authorizationHeader?: string;
}
export declare const MCPServerBearerTokenConfig: S.Schema<MCPServerBearerTokenConfig>;
export type MCPServerAuthorizationConfig = {
    oAuthClientCredentials: MCPServerOAuthClientCredentialsConfig;
    oAuth3LO?: never;
    apiKey?: never;
    bearerToken?: never;
    authorizationDiscovery?: never;
} | {
    oAuthClientCredentials?: never;
    oAuth3LO: MCPServerOAuth3LOConfig;
    apiKey?: never;
    bearerToken?: never;
    authorizationDiscovery?: never;
} | {
    oAuthClientCredentials?: never;
    oAuth3LO?: never;
    apiKey: MCPServerAPIKeyConfig;
    bearerToken?: never;
    authorizationDiscovery?: never;
} | {
    oAuthClientCredentials?: never;
    oAuth3LO?: never;
    apiKey?: never;
    bearerToken: MCPServerBearerTokenConfig;
    authorizationDiscovery?: never;
} | {
    oAuthClientCredentials?: never;
    oAuth3LO?: never;
    apiKey?: never;
    bearerToken?: never;
    authorizationDiscovery: MCPServerAuthorizationDiscoveryConfig;
};
export declare const MCPServerAuthorizationConfig: S.Union<readonly [S.Struct<{
    readonly oAuthClientCredentials: S.Schema<MCPServerOAuthClientCredentialsConfig>;
}>, S.Struct<{
    readonly oAuth3LO: S.Schema<MCPServerOAuth3LOConfig>;
}>, S.Struct<{
    readonly apiKey: S.Schema<MCPServerAPIKeyConfig>;
}>, S.Struct<{
    readonly bearerToken: S.Schema<MCPServerBearerTokenConfig>;
}>, S.Struct<{
    readonly authorizationDiscovery: S.Schema<MCPServerAuthorizationDiscoveryConfig>;
}>]>;
export interface MCPServerDetails {
    name: string;
    endpoint: string;
    description?: string | redacted.Redacted<string>;
    authorizationConfig: MCPServerAuthorizationConfig;
}
export declare const MCPServerDetails: S.Schema<MCPServerDetails>;
export type GitLabTokenType = "personal" | "group" | (string & {});
export declare const GitLabTokenType: S.String;
export interface GitLabDetails {
    targetUrl: string;
    tokenType: GitLabTokenType;
    tokenValue: string | redacted.Redacted<string>;
    groupId?: string;
}
export declare const GitLabDetails: S.Schema<GitLabDetails>;
export type NewRelicRegion = "US" | "EU" | (string & {});
export declare const NewRelicRegion: S.String;
export type NewRelicApplicationIds = string[];
export declare const NewRelicApplicationIds: S.$Array<S.String>;
export type NewRelicEntityGuids = string[];
export declare const NewRelicEntityGuids: S.$Array<S.String>;
export type NewRelicAlertPolicyIds = string[];
export declare const NewRelicAlertPolicyIds: S.$Array<S.String>;
export interface NewRelicApiKeyConfig {
    apiKey: string | redacted.Redacted<string>;
    accountId: string;
    region: NewRelicRegion;
    applicationIds?: string[];
    entityGuids?: string[];
    alertPolicyIds?: string[];
}
export declare const NewRelicApiKeyConfig: S.Schema<NewRelicApiKeyConfig>;
export type NewRelicServiceAuthorizationConfig = {
    apiKey: NewRelicApiKeyConfig;
};
export declare const NewRelicServiceAuthorizationConfig: S.Union<readonly [S.Struct<{
    readonly apiKey: S.Schema<NewRelicApiKeyConfig>;
}>]>;
export interface NewRelicServiceDetails {
    authorizationConfig: NewRelicServiceAuthorizationConfig;
}
export declare const NewRelicServiceDetails: S.Schema<NewRelicServiceDetails>;
export type EventChannelType = "webhook" | (string & {});
export declare const EventChannelType: S.String;
export interface EventChannelDetails {
    type?: EventChannelType;
}
export declare const EventChannelDetails: S.Schema<EventChannelDetails>;
export interface GrafanaServiceDetails {
    name: string;
    endpoint: string;
    description?: string | redacted.Redacted<string>;
    authorizationConfig: MCPServerAuthorizationConfig;
}
export declare const GrafanaServiceDetails: S.Schema<GrafanaServiceDetails>;
export type PagerDutyScopes = string[];
export declare const PagerDutyScopes: S.$Array<S.String>;
export interface PagerDutyOAuthClientCredentialsConfig {
    clientName?: string;
    clientId: string | redacted.Redacted<string>;
    exchangeParameters?: {
        [key: string]: string | redacted.Redacted<string> | undefined;
    };
    clientSecret: string | redacted.Redacted<string>;
}
export declare const PagerDutyOAuthClientCredentialsConfig: S.Schema<PagerDutyOAuthClientCredentialsConfig>;
export type PagerDutyAuthorizationConfig = {
    oAuthClientCredentials: PagerDutyOAuthClientCredentialsConfig;
};
export declare const PagerDutyAuthorizationConfig: S.Union<readonly [S.Struct<{
    readonly oAuthClientCredentials: S.Schema<PagerDutyOAuthClientCredentialsConfig>;
}>]>;
export interface PagerDutyDetails {
    scopes: string[];
    authorizationConfig: PagerDutyAuthorizationConfig;
}
export declare const PagerDutyDetails: S.Schema<PagerDutyDetails>;
export type WebIdentityTokenAudienceList = string[];
export declare const WebIdentityTokenAudienceList: S.$Array<S.String>;
export interface RegisteredAzureIdentityDetails {
    tenantId: string;
    clientId: string;
    webIdentityRoleArn: string;
    webIdentityTokenAudiences: string[];
}
export declare const RegisteredAzureIdentityDetails: S.Schema<RegisteredAzureIdentityDetails>;
export type ServiceDetails = {
    dynatrace: DynatraceServiceDetails;
    servicenow?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    mcpservernewrelic?: never;
    eventChannel?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
    azureidentity?: never;
} | {
    dynatrace?: never;
    servicenow: ServiceNowServiceDetails;
    mcpserverdatadog?: never;
    mcpserver?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    mcpservernewrelic?: never;
    eventChannel?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
    azureidentity?: never;
} | {
    dynatrace?: never;
    servicenow?: never;
    mcpserverdatadog: DatadogServiceDetails;
    mcpserver?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    mcpservernewrelic?: never;
    eventChannel?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
    azureidentity?: never;
} | {
    dynatrace?: never;
    servicenow?: never;
    mcpserverdatadog?: never;
    mcpserver: MCPServerDetails;
    gitlab?: never;
    mcpserversplunk?: never;
    mcpservernewrelic?: never;
    eventChannel?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
    azureidentity?: never;
} | {
    dynatrace?: never;
    servicenow?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    gitlab: GitLabDetails;
    mcpserversplunk?: never;
    mcpservernewrelic?: never;
    eventChannel?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
    azureidentity?: never;
} | {
    dynatrace?: never;
    servicenow?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    gitlab?: never;
    mcpserversplunk: MCPServerDetails;
    mcpservernewrelic?: never;
    eventChannel?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
    azureidentity?: never;
} | {
    dynatrace?: never;
    servicenow?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    mcpservernewrelic: NewRelicServiceDetails;
    eventChannel?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
    azureidentity?: never;
} | {
    dynatrace?: never;
    servicenow?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    mcpservernewrelic?: never;
    eventChannel: EventChannelDetails;
    mcpservergrafana?: never;
    pagerduty?: never;
    azureidentity?: never;
} | {
    dynatrace?: never;
    servicenow?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    mcpservernewrelic?: never;
    eventChannel?: never;
    mcpservergrafana: GrafanaServiceDetails;
    pagerduty?: never;
    azureidentity?: never;
} | {
    dynatrace?: never;
    servicenow?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    mcpservernewrelic?: never;
    eventChannel?: never;
    mcpservergrafana?: never;
    pagerduty: PagerDutyDetails;
    azureidentity?: never;
} | {
    dynatrace?: never;
    servicenow?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    mcpservernewrelic?: never;
    eventChannel?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
    azureidentity: RegisteredAzureIdentityDetails;
};
export declare const ServiceDetails: S.Union<readonly [S.Struct<{
    readonly dynatrace: S.Schema<DynatraceServiceDetails>;
}>, S.Struct<{
    readonly servicenow: S.Schema<ServiceNowServiceDetails>;
}>, S.Struct<{
    readonly mcpserverdatadog: S.Schema<DatadogServiceDetails>;
}>, S.Struct<{
    readonly mcpserver: S.Schema<MCPServerDetails>;
}>, S.Struct<{
    readonly gitlab: S.Schema<GitLabDetails>;
}>, S.Struct<{
    readonly mcpserversplunk: S.Schema<MCPServerDetails>;
}>, S.Struct<{
    readonly mcpservernewrelic: S.Schema<NewRelicServiceDetails>;
}>, S.Struct<{
    readonly eventChannel: S.Schema<EventChannelDetails>;
}>, S.Struct<{
    readonly mcpservergrafana: S.Schema<GrafanaServiceDetails>;
}>, S.Struct<{
    readonly pagerduty: S.Schema<PagerDutyDetails>;
}>, S.Struct<{
    readonly azureidentity: S.Schema<RegisteredAzureIdentityDetails>;
}>]>;
export interface RegisterServiceInput {
    service: PostRegisterServiceSupportedService;
    serviceDetails: ServiceDetails;
    kmsKeyArn?: string;
    privateConnectionName?: string;
    name?: string;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const RegisterServiceInput: S.Schema<RegisterServiceInput>;
export interface OAuthAdditionalStepDetails {
    authorizationUrl: string;
}
export declare const OAuthAdditionalStepDetails: S.Schema<OAuthAdditionalStepDetails>;
export type AdditionalServiceRegistrationStep = {
    oauth: OAuthAdditionalStepDetails;
};
export declare const AdditionalServiceRegistrationStep: S.Union<readonly [S.Struct<{
    readonly oauth: S.Schema<OAuthAdditionalStepDetails>;
}>]>;
export interface RegisterServiceOutput {
    serviceId?: string;
    additionalStep?: AdditionalServiceRegistrationStep;
    kmsKeyArn?: string;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const RegisterServiceOutput: S.Schema<RegisterServiceOutput>;
export interface GetServiceInput {
    serviceId: string;
}
export declare const GetServiceInput: S.Schema<GetServiceInput>;
export type Service = "github" | "slack" | "azure" | "azuredevops" | "dynatrace" | "servicenow" | "pagerduty" | "gitlab" | "eventChannel" | "mcpservernewrelic" | "mcpservergrafana" | "mcpserverdatadog" | "mcpserver" | "mcpserversplunk" | "azureidentity" | (string & {});
export declare const Service: S.String;
export type DocumentList = any[];
export declare const DocumentList: S.$Array<S.Any>;
export interface RegisteredGithubServiceDetails {
    owner: string;
    ownerType: GithubRepoOwnerType;
    targetUrl?: string;
}
export declare const RegisteredGithubServiceDetails: S.Schema<RegisteredGithubServiceDetails>;
export interface RegisteredSlackServiceDetails {
    teamId: string;
    teamName: string;
}
export declare const RegisteredSlackServiceDetails: S.Schema<RegisteredSlackServiceDetails>;
export type MCPServerAuthorizationMethod = "oauth-client-credentials" | "oauth-3lo" | "api-key" | "bearer-token" | (string & {});
export declare const MCPServerAuthorizationMethod: S.String;
export interface RegisteredMCPServerDetails {
    name: string;
    endpoint: string;
    authorizationMethod: MCPServerAuthorizationMethod;
    description?: string | redacted.Redacted<string>;
    apiKeyHeader?: string;
}
export declare const RegisteredMCPServerDetails: S.Schema<RegisteredMCPServerDetails>;
export interface RegisteredServiceNowDetails {
    instanceUrl?: string;
}
export declare const RegisteredServiceNowDetails: S.Schema<RegisteredServiceNowDetails>;
export interface RegisteredGitLabServiceDetails {
    targetUrl: string;
    tokenType: GitLabTokenType;
    groupId?: string;
}
export declare const RegisteredGitLabServiceDetails: S.Schema<RegisteredGitLabServiceDetails>;
export interface RegisteredNewRelicDetails {
    accountId: string;
    region: NewRelicRegion;
    description?: string | redacted.Redacted<string>;
}
export declare const RegisteredNewRelicDetails: S.Schema<RegisteredNewRelicDetails>;
export interface RegisteredAzureDevOpsServiceDetails {
    organizationName: string;
}
export declare const RegisteredAzureDevOpsServiceDetails: S.Schema<RegisteredAzureDevOpsServiceDetails>;
export interface RegisteredGrafanaServerDetails {
    endpoint: string;
    authorizationMethod: MCPServerAuthorizationMethod;
}
export declare const RegisteredGrafanaServerDetails: S.Schema<RegisteredGrafanaServerDetails>;
export type PagerDutyScopesList = string[];
export declare const PagerDutyScopesList: S.$Array<S.String>;
export interface RegisteredPagerDutyDetails {
    scopes: string[];
}
export declare const RegisteredPagerDutyDetails: S.Schema<RegisteredPagerDutyDetails>;
export type AdditionalServiceDetails = {
    github: RegisteredGithubServiceDetails;
    slack?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    servicenow?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    mcpservernewrelic?: never;
    azuredevops?: never;
    azureidentity?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
} | {
    github?: never;
    slack: RegisteredSlackServiceDetails;
    mcpserverdatadog?: never;
    mcpserver?: never;
    servicenow?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    mcpservernewrelic?: never;
    azuredevops?: never;
    azureidentity?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
} | {
    github?: never;
    slack?: never;
    mcpserverdatadog: RegisteredMCPServerDetails;
    mcpserver?: never;
    servicenow?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    mcpservernewrelic?: never;
    azuredevops?: never;
    azureidentity?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
} | {
    github?: never;
    slack?: never;
    mcpserverdatadog?: never;
    mcpserver: RegisteredMCPServerDetails;
    servicenow?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    mcpservernewrelic?: never;
    azuredevops?: never;
    azureidentity?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
} | {
    github?: never;
    slack?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    servicenow: RegisteredServiceNowDetails;
    gitlab?: never;
    mcpserversplunk?: never;
    mcpservernewrelic?: never;
    azuredevops?: never;
    azureidentity?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
} | {
    github?: never;
    slack?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    servicenow?: never;
    gitlab: RegisteredGitLabServiceDetails;
    mcpserversplunk?: never;
    mcpservernewrelic?: never;
    azuredevops?: never;
    azureidentity?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
} | {
    github?: never;
    slack?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    servicenow?: never;
    gitlab?: never;
    mcpserversplunk: RegisteredMCPServerDetails;
    mcpservernewrelic?: never;
    azuredevops?: never;
    azureidentity?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
} | {
    github?: never;
    slack?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    servicenow?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    mcpservernewrelic: RegisteredNewRelicDetails;
    azuredevops?: never;
    azureidentity?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
} | {
    github?: never;
    slack?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    servicenow?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    mcpservernewrelic?: never;
    azuredevops: RegisteredAzureDevOpsServiceDetails;
    azureidentity?: never;
    mcpservergrafana?: never;
    pagerduty?: never;
} | {
    github?: never;
    slack?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    servicenow?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    mcpservernewrelic?: never;
    azuredevops?: never;
    azureidentity: RegisteredAzureIdentityDetails;
    mcpservergrafana?: never;
    pagerduty?: never;
} | {
    github?: never;
    slack?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    servicenow?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    mcpservernewrelic?: never;
    azuredevops?: never;
    azureidentity?: never;
    mcpservergrafana: RegisteredGrafanaServerDetails;
    pagerduty?: never;
} | {
    github?: never;
    slack?: never;
    mcpserverdatadog?: never;
    mcpserver?: never;
    servicenow?: never;
    gitlab?: never;
    mcpserversplunk?: never;
    mcpservernewrelic?: never;
    azuredevops?: never;
    azureidentity?: never;
    mcpservergrafana?: never;
    pagerduty: RegisteredPagerDutyDetails;
};
export declare const AdditionalServiceDetails: S.Union<readonly [S.Struct<{
    readonly github: S.Schema<RegisteredGithubServiceDetails>;
}>, S.Struct<{
    readonly slack: S.Schema<RegisteredSlackServiceDetails>;
}>, S.Struct<{
    readonly mcpserverdatadog: S.Schema<RegisteredMCPServerDetails>;
}>, S.Struct<{
    readonly mcpserver: S.Schema<RegisteredMCPServerDetails>;
}>, S.Struct<{
    readonly servicenow: S.Schema<RegisteredServiceNowDetails>;
}>, S.Struct<{
    readonly gitlab: S.Schema<RegisteredGitLabServiceDetails>;
}>, S.Struct<{
    readonly mcpserversplunk: S.Schema<RegisteredMCPServerDetails>;
}>, S.Struct<{
    readonly mcpservernewrelic: S.Schema<RegisteredNewRelicDetails>;
}>, S.Struct<{
    readonly azuredevops: S.Schema<RegisteredAzureDevOpsServiceDetails>;
}>, S.Struct<{
    readonly azureidentity: S.Schema<RegisteredAzureIdentityDetails>;
}>, S.Struct<{
    readonly mcpservergrafana: S.Schema<RegisteredGrafanaServerDetails>;
}>, S.Struct<{
    readonly pagerduty: S.Schema<RegisteredPagerDutyDetails>;
}>]>;
export interface RegisteredService {
    serviceId: string;
    serviceType: Service;
    name?: string;
    accessibleResources?: any[];
    additionalServiceDetails?: AdditionalServiceDetails;
    kmsKeyArn?: string;
    privateConnectionName?: string;
}
export declare const RegisteredService: S.Schema<RegisteredService>;
export interface GetServiceOutput {
    service: RegisteredService;
    tags?: {
        [key: string]: string | undefined;
    };
}
export declare const GetServiceOutput: S.Schema<GetServiceOutput>;
export interface DeregisterServiceInput {
    serviceId: string;
}
export declare const DeregisterServiceInput: S.Schema<DeregisterServiceInput>;
export interface DeregisterServiceOutput {
}
export declare const DeregisterServiceOutput: S.Schema<DeregisterServiceOutput>;
export interface ListServicesInput {
    maxResults?: number;
    nextToken?: string;
    filterServiceType?: Service;
}
export declare const ListServicesInput: S.Schema<ListServicesInput>;
export type RegisteredServicesList = RegisteredService[];
export declare const RegisteredServicesList: S.$Array<S.Schema<RegisteredService>>;
export interface ListServicesOutput {
    nextToken?: string;
    services: RegisteredService[];
}
export declare const ListServicesOutput: S.Schema<ListServicesOutput>;
declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class AccessDeniedException extends AccessDeniedException_base {
}
declare const ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ConflictError: true;
    };
});
export declare class ConflictException extends ConflictException_base {
}
declare const InternalServerException_base: S.Class<InternalServerException, S.TaggedStruct<"InternalServerException", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class InternalServerException extends InternalServerException_base {
}
declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
}
declare const ThrottlingException_base: S.Class<ThrottlingException, S.TaggedStruct<"ThrottlingException", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ThrottlingError: true;
    };
}) & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        RetryableError: true;
    };
});
export declare class ThrottlingException extends ThrottlingException_base {
}
declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
    readonly message: S.String;
    readonly fieldList: S.optional<S.$Array<S.Schema<ValidationExceptionField>>>;
}>, import("effect/Cause").YieldableError>;
export declare class ValidationException extends ValidationException_base {
}
declare const ServiceQuotaExceededException_base: S.Class<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        QuotaError: true;
    };
});
export declare class ServiceQuotaExceededException extends ServiceQuotaExceededException_base {
}
declare const InvalidParameterException_base: S.Class<InvalidParameterException, S.TaggedStruct<"InvalidParameterException", {
    readonly message: S.String;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class InvalidParameterException extends InvalidParameterException_base {
}
declare const IdentityCenterServiceException_base: S.Class<IdentityCenterServiceException, S.TaggedStruct<"IdentityCenterServiceException", {
    readonly message: S.String;
    readonly underlyingErrorCode: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class IdentityCenterServiceException extends IdentityCenterServiceException_base {
}
export type AllowVendedLogDeliveryForResourceError = CommonErrors;
/**
 * Authorize Ingestion Hub subscription operation.
 */
export declare const allowVendedLogDeliveryForResource: API.OperationMethod<AllowVendedLogDeliveryForResourceInput, AllowVendedLogDeliveryForResourceOutput, AllowVendedLogDeliveryForResourceError, Credentials | Region | HttpClient.HttpClient>;
export type CreateBacklogTaskError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Creates a new backlog task in the specified agent space
 */
export declare const createBacklogTask: API.OperationMethod<CreateBacklogTaskRequest, CreateBacklogTaskResponse, CreateBacklogTaskError, Credentials | Region | HttpClient.HttpClient>;
export type CreateChatError = InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Creates a new chat execution in the specified agent space
 */
export declare const createChat: API.OperationMethod<CreateChatRequest, CreateChatResponse, CreateChatError, Credentials | Region | HttpClient.HttpClient>;
export type GetAccountUsageError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Retrieves monthly account usage metrics and limits for the AWS account.
 */
export declare const getAccountUsage: API.OperationMethod<GetAccountUsageInput, GetAccountUsageOutput, GetAccountUsageError, Credentials | Region | HttpClient.HttpClient>;
export type GetBacklogTaskError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Gets a backlog task for the specified agent space and task id
 */
export declare const getBacklogTask: API.OperationMethod<GetBacklogTaskRequest, GetBacklogTaskResponse, GetBacklogTaskError, Credentials | Region | HttpClient.HttpClient>;
export type GetRecommendationError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Retrieves a specific recommendation by its ID
 */
export declare const getRecommendation: API.OperationMethod<GetRecommendationRequest, GetRecommendationResponse, GetRecommendationError, Credentials | Region | HttpClient.HttpClient>;
export type ListBacklogTasksError = AccessDeniedException | InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists backlog tasks in the specified agent space with optional filtering and sorting
 */
export declare const listBacklogTasks: API.OperationMethod<ListBacklogTasksRequest, ListBacklogTasksResponse, ListBacklogTasksError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListBacklogTasksRequest) => stream.Stream<ListBacklogTasksResponse, ListBacklogTasksError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListBacklogTasksRequest) => stream.Stream<Task, ListBacklogTasksError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListChatsError = InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Retrieves a paginated list of the user's recent chat executions
 */
export declare const listChats: API.OperationMethod<ListChatsRequest, ListChatsResponse, ListChatsError, Credentials | Region | HttpClient.HttpClient>;
export type ListExecutionsError = AccessDeniedException | ConflictException | InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * List executions
 */
export declare const listExecutions: API.OperationMethod<ListExecutionsRequest, ListExecutionsResponse, ListExecutionsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListExecutionsRequest) => stream.Stream<ListExecutionsResponse, ListExecutionsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListExecutionsRequest) => stream.Stream<Execution, ListExecutionsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListGoalsError = AccessDeniedException | InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists goals in the specified agent space with optional filtering
 */
export declare const listGoals: API.OperationMethod<ListGoalsRequest, ListGoalsResponse, ListGoalsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListGoalsRequest) => stream.Stream<ListGoalsResponse, ListGoalsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListGoalsRequest) => stream.Stream<Goal, ListGoalsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListJournalRecordsError = AccessDeniedException | ConflictException | InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * List journal records for a specific execution
 */
export declare const listJournalRecords: API.OperationMethod<ListJournalRecordsRequest, ListJournalRecordsResponse, ListJournalRecordsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListJournalRecordsRequest) => stream.Stream<ListJournalRecordsResponse, ListJournalRecordsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListJournalRecordsRequest) => stream.Stream<JournalRecord, ListJournalRecordsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListPendingMessagesError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * List pending messages for a specific execution.
 */
export declare const listPendingMessages: API.OperationMethod<ListPendingMessagesRequest, ListPendingMessagesResponse, ListPendingMessagesError, Credentials | Region | HttpClient.HttpClient>;
export type ListRecommendationsError = AccessDeniedException | InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists recommendations for the specified agent space
 */
export declare const listRecommendations: API.OperationMethod<ListRecommendationsRequest, ListRecommendationsResponse, ListRecommendationsError, Credentials | Region | HttpClient.HttpClient>;
export type ListTagsForResourceError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Lists tags for the specified AWS DevOps Agent resource.
 */
export declare const listTagsForResource: API.OperationMethod<ListTagsForResourceRequest, ListTagsForResourceResponse, ListTagsForResourceError, Credentials | Region | HttpClient.HttpClient>;
export type SendMessageError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Sends a chat message and streams the response for the specified agent space execution
 */
export declare const sendMessage: API.OperationMethod<SendMessageRequest, SendMessageResponse, SendMessageError, Credentials | Region | HttpClient.HttpClient>;
export type TagResourceError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Adds or overwrites tags for the specified AWS DevOps Agent resource.
 */
export declare const tagResource: API.OperationMethod<TagResourceRequest, TagResourceResponse, TagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UntagResourceError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Removes tags from the specified AWS DevOps Agent resource.
 */
export declare const untagResource: API.OperationMethod<UntagResourceRequest, UntagResourceResponse, UntagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateBacklogTaskError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Update an existing backlog task.
 */
export declare const updateBacklogTask: API.OperationMethod<UpdateBacklogTaskRequest, UpdateBacklogTaskResponse, UpdateBacklogTaskError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateGoalError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Update an existing goal
 */
export declare const updateGoal: API.OperationMethod<UpdateGoalRequest, UpdateGoalResponse, UpdateGoalError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateRecommendationError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Updates an existing recommendation with new content, status, or metadata
 */
export declare const updateRecommendation: API.OperationMethod<UpdateRecommendationRequest, UpdateRecommendationResponse, UpdateRecommendationError, Credentials | Region | HttpClient.HttpClient>;
export type CreateAgentSpaceError = ConflictException | InternalServerException | InvalidParameterException | ServiceQuotaExceededException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Creates a new AgentSpace with the specified name and description. Duplicate space names are allowed.
 */
export declare const createAgentSpace: API.OperationMethod<CreateAgentSpaceInput, CreateAgentSpaceOutput, CreateAgentSpaceError, Credentials | Region | HttpClient.HttpClient>;
export type GetAgentSpaceError = InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Retrieves detailed information about a specific AgentSpace.
 */
export declare const getAgentSpace: API.OperationMethod<GetAgentSpaceInput, GetAgentSpaceOutput, GetAgentSpaceError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateAgentSpaceError = ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Updates the information of an existing AgentSpace.
 */
export declare const updateAgentSpace: API.OperationMethod<UpdateAgentSpaceInput, UpdateAgentSpaceOutput, UpdateAgentSpaceError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteAgentSpaceError = ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Deletes an AgentSpace. This operation is idempotent and returns a 204 No Content response on success.
 */
export declare const deleteAgentSpace: API.OperationMethod<DeleteAgentSpaceInput, DeleteAgentSpaceOutput, DeleteAgentSpaceError, Credentials | Region | HttpClient.HttpClient>;
export type DisableOperatorAppError = IdentityCenterServiceException | InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Disable the Operator App for the specified AgentSpace
 */
export declare const disableOperatorApp: API.OperationMethod<DisableOperatorAppInput, DisableOperatorAppResponse, DisableOperatorAppError, Credentials | Region | HttpClient.HttpClient>;
export type EnableOperatorAppError = IdentityCenterServiceException | InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Enable the Operator App to access the given AgentSpace
 */
export declare const enableOperatorApp: API.OperationMethod<EnableOperatorAppInput, EnableOperatorAppOutput, EnableOperatorAppError, Credentials | Region | HttpClient.HttpClient>;
export type GetOperatorAppError = InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Get the full auth configuration of operator including any enabled auth flow
 */
export declare const getOperatorApp: API.OperationMethod<GetOperatorAppInput, GetOperatorAppOutput, GetOperatorAppError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateOperatorAppIdpConfigError = InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Update the external Identity Provider configuration for the Operator App
 */
export declare const updateOperatorAppIdpConfig: API.OperationMethod<UpdateOperatorAppIdpConfigInput, UpdateOperatorAppIdpConfigOutput, UpdateOperatorAppIdpConfigError, Credentials | Region | HttpClient.HttpClient>;
export type ListAgentSpacesError = InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists all AgentSpaces with optional pagination.
 */
export declare const listAgentSpaces: API.OperationMethod<ListAgentSpacesInput, ListAgentSpacesOutput, ListAgentSpacesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListAgentSpacesInput) => stream.Stream<ListAgentSpacesOutput, ListAgentSpacesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListAgentSpacesInput) => stream.Stream<AgentSpace, ListAgentSpacesError, Credentials | Region | HttpClient.HttpClient>;
};
export type AssociateServiceError = ConflictException | InternalServerException | InvalidParameterException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Adds a specific service association to an AgentSpace. It overwrites the existing association of the same service. Returns 201 Created on success.
 */
export declare const associateService: API.OperationMethod<AssociateServiceInput, AssociateServiceOutput, AssociateServiceError, Credentials | Region | HttpClient.HttpClient>;
export type GetAssociationError = InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Retrieves given associations configured for a specific AgentSpace.
 */
export declare const getAssociation: API.OperationMethod<GetAssociationInput, GetAssociationOutput, GetAssociationError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateAssociationError = InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Partially updates the configuration of an existing service association for an AgentSpace. Present fields are fully replaced; absent fields are left unchanged. Returns 200 OK on success.
 */
export declare const updateAssociation: API.OperationMethod<UpdateAssociationInput, UpdateAssociationOutput, UpdateAssociationError, Credentials | Region | HttpClient.HttpClient>;
export type DisassociateServiceError = InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Deletes a specific service association from an AgentSpace. This operation is idempotent and returns a 204 No Content response on success.
 */
export declare const disassociateService: API.OperationMethod<DisassociateServiceInput, DisassociateServiceOutput, DisassociateServiceError, Credentials | Region | HttpClient.HttpClient>;
export type ListWebhooksError = InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * List all webhooks for given Association
 */
export declare const listWebhooks: API.OperationMethod<ListWebhooksInput, ListWebhooksOutput, ListWebhooksError, Credentials | Region | HttpClient.HttpClient>;
export type ListAssociationsError = InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * List all associations for given AgentSpace
 */
export declare const listAssociations: API.OperationMethod<ListAssociationsInput, ListAssociationsOutput, ListAssociationsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListAssociationsInput) => stream.Stream<ListAssociationsOutput, ListAssociationsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListAssociationsInput) => stream.Stream<Association, ListAssociationsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ValidateAwsAssociationsError = InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Validates an aws association and set status and returns a 204 No Content response on success.
 */
export declare const validateAwsAssociations: API.OperationMethod<ValidateAwsAssociationsInput, ValidateAwsAssociationsOutput, ValidateAwsAssociationsError, Credentials | Region | HttpClient.HttpClient>;
export type CreatePrivateConnectionError = AccessDeniedException | InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Creates a Private Connection to a target resource.
 */
export declare const createPrivateConnection: API.OperationMethod<CreatePrivateConnectionInput, CreatePrivateConnectionOutput, CreatePrivateConnectionError, Credentials | Region | HttpClient.HttpClient>;
export type DescribePrivateConnectionError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Retrieves details of an existing Private Connection.
 */
export declare const describePrivateConnection: API.OperationMethod<DescribePrivateConnectionInput, DescribePrivateConnectionOutput, DescribePrivateConnectionError, Credentials | Region | HttpClient.HttpClient>;
export type DeletePrivateConnectionError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Deletes a Private Connection. The deletion is asynchronous and returns DELETE_IN_PROGRESS status.
 */
export declare const deletePrivateConnection: API.OperationMethod<DeletePrivateConnectionInput, DeletePrivateConnectionOutput, DeletePrivateConnectionError, Credentials | Region | HttpClient.HttpClient>;
export type ListPrivateConnectionsError = AccessDeniedException | InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Lists all Private Connections in the caller's account.
 */
export declare const listPrivateConnections: API.OperationMethod<ListPrivateConnectionsInput, ListPrivateConnectionsOutput, ListPrivateConnectionsError, Credentials | Region | HttpClient.HttpClient>;
export type UpdatePrivateConnectionCertificateError = AccessDeniedException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Updates the certificate associated with a Private Connection.
 */
export declare const updatePrivateConnectionCertificate: API.OperationMethod<UpdatePrivateConnectionCertificateInput, UpdatePrivateConnectionCertificateOutput, UpdatePrivateConnectionCertificateError, Credentials | Region | HttpClient.HttpClient>;
export type RegisterServiceError = InternalServerException | InvalidParameterException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * This operation registers the specified service
 */
export declare const registerService: API.OperationMethod<RegisterServiceInput, RegisterServiceOutput, RegisterServiceError, Credentials | Region | HttpClient.HttpClient>;
export type GetServiceError = InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Retrieves given service by it's unique identifier
 */
export declare const getService: API.OperationMethod<GetServiceInput, GetServiceOutput, GetServiceError, Credentials | Region | HttpClient.HttpClient>;
export type DeregisterServiceError = ConflictException | InternalServerException | ResourceNotFoundException | ThrottlingException | ValidationException | CommonErrors;
/**
 * Deregister a service
 */
export declare const deregisterService: API.OperationMethod<DeregisterServiceInput, DeregisterServiceOutput, DeregisterServiceError, Credentials | Region | HttpClient.HttpClient>;
export type ListServicesError = InternalServerException | ThrottlingException | ValidationException | CommonErrors;
/**
 * List a list of registered service on the account level.
 */
export declare const listServices: API.OperationMethod<ListServicesInput, ListServicesOutput, ListServicesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListServicesInput) => stream.Stream<ListServicesOutput, ListServicesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListServicesInput) => stream.Stream<RegisteredService, ListServicesError, Credentials | Region | HttpClient.HttpClient>;
};
export {};
//# sourceMappingURL=devops-agent.d.ts.map