import * as HttpClient from "effect/unstable/http/HttpClient";
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 GroupIdentifier = string;
export type CanaryArn = string;
export type ErrorMessage = string;
export type CanaryName = string;
export type CodeHandler = string;
export type BlueprintType = string;
export type RoleArn = string;
export type MaxOneYearInSeconds = number;
export type MaxRetries = number;
export type MaxFifteenMinutesInSeconds = number;
export type MaxSize3008 = number;
export type EnvironmentVariableName = string;
export type EnvironmentVariableValue = string;
export type EphemeralStorageSize = number;
export type MaxSize1024 = number;
export type SubnetId = string;
export type SecurityGroupId = string;
export type TagKey = string;
export type TagValue = string;
export type KmsKeyArn = string;
export type UUID = string;
export type FunctionArn = string;
export type VpcId = string;
export type BaseScreenshotConfigIgnoreCoordinate = string;
export type GroupName = string;
export type GroupArn = string;
export type Token = string;
export type MaxCanaryResults = number;
export type MaxSize100 = number;
export type RetryAttempt = number;
export type PaginationToken = string;
export type MaxGroupResults = number;
export type ResourceArn = string;
export interface AssociateResourceRequest {
    GroupIdentifier: string;
    ResourceArn: string;
}
export declare const AssociateResourceRequest: S.Schema<AssociateResourceRequest>;
export interface AssociateResourceResponse {
}
export declare const AssociateResourceResponse: S.Schema<AssociateResourceResponse>;
export type BlueprintTypes = string[];
export declare const BlueprintTypes: S.$Array<S.String>;
export type DependencyType = "LambdaLayer" | (string & {});
export declare const DependencyType: S.String;
export interface Dependency {
    Type?: DependencyType;
    Reference: string;
}
export declare const Dependency: S.Schema<Dependency>;
export type Dependencies = Dependency[];
export declare const Dependencies: S.$Array<S.Schema<Dependency>>;
export interface CanaryCodeInput {
    S3Bucket?: string;
    S3Key?: string;
    S3Version?: string;
    ZipFile?: Uint8Array;
    Handler?: string;
    BlueprintTypes?: string[];
    Dependencies?: Dependency[];
}
export declare const CanaryCodeInput: S.Schema<CanaryCodeInput>;
export interface RetryConfigInput {
    MaxRetries: number;
}
export declare const RetryConfigInput: S.Schema<RetryConfigInput>;
export interface CanaryScheduleInput {
    Expression: string;
    DurationInSeconds?: number;
    RetryConfig?: RetryConfigInput;
}
export declare const CanaryScheduleInput: S.Schema<CanaryScheduleInput>;
export type EnvironmentVariablesMap = {
    [key: string]: string | undefined;
};
export declare const EnvironmentVariablesMap: S.$Record<S.String, S.optional<S.String>>;
export interface CanaryRunConfigInput {
    TimeoutInSeconds?: number;
    MemoryInMB?: number;
    ActiveTracing?: boolean;
    EnvironmentVariables?: {
        [key: string]: string | undefined;
    };
    EphemeralStorage?: number;
}
export declare const CanaryRunConfigInput: S.Schema<CanaryRunConfigInput>;
export type SubnetIds = string[];
export declare const SubnetIds: S.$Array<S.String>;
export type SecurityGroupIds = string[];
export declare const SecurityGroupIds: S.$Array<S.String>;
export interface VpcConfigInput {
    SubnetIds?: string[];
    SecurityGroupIds?: string[];
    Ipv6AllowedForDualStack?: boolean;
}
export declare const VpcConfigInput: S.Schema<VpcConfigInput>;
export type ResourceToTag = "lambda-function" | (string & {});
export declare const ResourceToTag: S.String;
export type ResourceList = ResourceToTag[];
export declare const ResourceList: S.$Array<S.String>;
export type ProvisionedResourceCleanupSetting = "AUTOMATIC" | "OFF" | (string & {});
export declare const ProvisionedResourceCleanupSetting: S.String;
export type BrowserType = "CHROME" | "FIREFOX" | (string & {});
export declare const BrowserType: S.String;
export interface BrowserConfig {
    BrowserType?: BrowserType;
}
export declare const BrowserConfig: S.Schema<BrowserConfig>;
export type BrowserConfigs = BrowserConfig[];
export declare const BrowserConfigs: S.$Array<S.Schema<BrowserConfig>>;
export type TagMap = {
    [key: string]: string | undefined;
};
export declare const TagMap: S.$Record<S.String, S.optional<S.String>>;
export type EncryptionMode = "SSE_S3" | "SSE_KMS" | (string & {});
export declare const EncryptionMode: S.String;
export interface S3EncryptionConfig {
    EncryptionMode?: EncryptionMode;
    KmsKeyArn?: string;
}
export declare const S3EncryptionConfig: S.Schema<S3EncryptionConfig>;
export interface ArtifactConfigInput {
    S3Encryption?: S3EncryptionConfig;
}
export declare const ArtifactConfigInput: S.Schema<ArtifactConfigInput>;
export interface CreateCanaryRequest {
    Name: string;
    Code: CanaryCodeInput;
    ArtifactS3Location: string;
    ExecutionRoleArn: string;
    Schedule: CanaryScheduleInput;
    RunConfig?: CanaryRunConfigInput;
    SuccessRetentionPeriodInDays?: number;
    FailureRetentionPeriodInDays?: number;
    RuntimeVersion: string;
    VpcConfig?: VpcConfigInput;
    ResourcesToReplicateTags?: ResourceToTag[];
    ProvisionedResourceCleanup?: ProvisionedResourceCleanupSetting;
    BrowserConfigs?: BrowserConfig[];
    Tags?: {
        [key: string]: string | undefined;
    };
    ArtifactConfig?: ArtifactConfigInput;
}
export declare const CreateCanaryRequest: S.Schema<CreateCanaryRequest>;
export interface CanaryCodeOutput {
    SourceLocationArn?: string;
    Handler?: string;
    BlueprintTypes?: string[];
    Dependencies?: Dependency[];
}
export declare const CanaryCodeOutput: S.Schema<CanaryCodeOutput>;
export interface RetryConfigOutput {
    MaxRetries?: number;
}
export declare const RetryConfigOutput: S.Schema<RetryConfigOutput>;
export interface CanaryScheduleOutput {
    Expression?: string;
    DurationInSeconds?: number;
    RetryConfig?: RetryConfigOutput;
}
export declare const CanaryScheduleOutput: S.Schema<CanaryScheduleOutput>;
export interface CanaryRunConfigOutput {
    TimeoutInSeconds?: number;
    MemoryInMB?: number;
    ActiveTracing?: boolean;
    EphemeralStorage?: number;
}
export declare const CanaryRunConfigOutput: S.Schema<CanaryRunConfigOutput>;
export type CanaryState = "CREATING" | "READY" | "STARTING" | "RUNNING" | "UPDATING" | "STOPPING" | "STOPPED" | "ERROR" | "DELETING" | (string & {});
export declare const CanaryState: S.String;
export type CanaryStateReasonCode = "INVALID_PERMISSIONS" | "CREATE_PENDING" | "CREATE_IN_PROGRESS" | "CREATE_FAILED" | "UPDATE_PENDING" | "UPDATE_IN_PROGRESS" | "UPDATE_COMPLETE" | "ROLLBACK_COMPLETE" | "ROLLBACK_FAILED" | "DELETE_IN_PROGRESS" | "DELETE_FAILED" | "SYNC_DELETE_IN_PROGRESS" | (string & {});
export declare const CanaryStateReasonCode: S.String;
export interface CanaryStatus {
    State?: CanaryState;
    StateReason?: string;
    StateReasonCode?: CanaryStateReasonCode;
}
export declare const CanaryStatus: S.Schema<CanaryStatus>;
export interface CanaryTimeline {
    Created?: Date;
    LastModified?: Date;
    LastStarted?: Date;
    LastStopped?: Date;
}
export declare const CanaryTimeline: S.Schema<CanaryTimeline>;
export interface VpcConfigOutput {
    VpcId?: string;
    SubnetIds?: string[];
    SecurityGroupIds?: string[];
    Ipv6AllowedForDualStack?: boolean;
}
export declare const VpcConfigOutput: S.Schema<VpcConfigOutput>;
export type BaseScreenshotIgnoreCoordinates = string[];
export declare const BaseScreenshotIgnoreCoordinates: S.$Array<S.String>;
export interface BaseScreenshot {
    ScreenshotName: string;
    IgnoreCoordinates?: string[];
}
export declare const BaseScreenshot: S.Schema<BaseScreenshot>;
export type BaseScreenshots = BaseScreenshot[];
export declare const BaseScreenshots: S.$Array<S.Schema<BaseScreenshot>>;
export interface VisualReferenceOutput {
    BaseScreenshots?: BaseScreenshot[];
    BaseCanaryRunId?: string;
    BrowserType?: BrowserType;
}
export declare const VisualReferenceOutput: S.Schema<VisualReferenceOutput>;
export interface EngineConfig {
    EngineArn?: string;
    BrowserType?: BrowserType;
}
export declare const EngineConfig: S.Schema<EngineConfig>;
export type EngineConfigs = EngineConfig[];
export declare const EngineConfigs: S.$Array<S.Schema<EngineConfig>>;
export type VisualReferencesOutput = VisualReferenceOutput[];
export declare const VisualReferencesOutput: S.$Array<S.Schema<VisualReferenceOutput>>;
export interface ArtifactConfigOutput {
    S3Encryption?: S3EncryptionConfig;
}
export declare const ArtifactConfigOutput: S.Schema<ArtifactConfigOutput>;
export interface DryRunConfigOutput {
    DryRunId?: string;
    LastDryRunExecutionStatus?: string;
}
export declare const DryRunConfigOutput: S.Schema<DryRunConfigOutput>;
export interface Canary {
    Id?: string;
    Name?: string;
    Code?: CanaryCodeOutput;
    ExecutionRoleArn?: string;
    Schedule?: CanaryScheduleOutput;
    RunConfig?: CanaryRunConfigOutput;
    SuccessRetentionPeriodInDays?: number;
    FailureRetentionPeriodInDays?: number;
    Status?: CanaryStatus;
    Timeline?: CanaryTimeline;
    ArtifactS3Location?: string;
    EngineArn?: string;
    RuntimeVersion?: string;
    VpcConfig?: VpcConfigOutput;
    VisualReference?: VisualReferenceOutput;
    ProvisionedResourceCleanup?: ProvisionedResourceCleanupSetting;
    BrowserConfigs?: BrowserConfig[];
    EngineConfigs?: EngineConfig[];
    VisualReferences?: VisualReferenceOutput[];
    Tags?: {
        [key: string]: string | undefined;
    };
    ArtifactConfig?: ArtifactConfigOutput;
    DryRunConfig?: DryRunConfigOutput;
}
export declare const Canary: S.Schema<Canary>;
export interface CreateCanaryResponse {
    Canary?: Canary;
}
export declare const CreateCanaryResponse: S.Schema<CreateCanaryResponse>;
export interface CreateGroupRequest {
    Name: string;
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const CreateGroupRequest: S.Schema<CreateGroupRequest>;
export interface Group {
    Id?: string;
    Name?: string;
    Arn?: string;
    Tags?: {
        [key: string]: string | undefined;
    };
    CreatedTime?: Date;
    LastModifiedTime?: Date;
}
export declare const Group: S.Schema<Group>;
export interface CreateGroupResponse {
    Group?: Group;
}
export declare const CreateGroupResponse: S.Schema<CreateGroupResponse>;
export interface DeleteCanaryRequest {
    Name: string;
    DeleteLambda?: boolean;
}
export declare const DeleteCanaryRequest: S.Schema<DeleteCanaryRequest>;
export interface DeleteCanaryResponse {
}
export declare const DeleteCanaryResponse: S.Schema<DeleteCanaryResponse>;
export interface DeleteGroupRequest {
    GroupIdentifier: string;
}
export declare const DeleteGroupRequest: S.Schema<DeleteGroupRequest>;
export interface DeleteGroupResponse {
}
export declare const DeleteGroupResponse: S.Schema<DeleteGroupResponse>;
export type DescribeCanariesNameFilter = string[];
export declare const DescribeCanariesNameFilter: S.$Array<S.String>;
export interface DescribeCanariesRequest {
    NextToken?: string;
    MaxResults?: number;
    Names?: string[];
}
export declare const DescribeCanariesRequest: S.Schema<DescribeCanariesRequest>;
export type Canaries = Canary[];
export declare const Canaries: S.$Array<S.Schema<Canary>>;
export interface DescribeCanariesResponse {
    Canaries?: Canary[];
    NextToken?: string;
}
export declare const DescribeCanariesResponse: S.Schema<DescribeCanariesResponse>;
export type DescribeCanariesLastRunNameFilter = string[];
export declare const DescribeCanariesLastRunNameFilter: S.$Array<S.String>;
export interface DescribeCanariesLastRunRequest {
    NextToken?: string;
    MaxResults?: number;
    Names?: string[];
    BrowserType?: BrowserType;
}
export declare const DescribeCanariesLastRunRequest: S.Schema<DescribeCanariesLastRunRequest>;
export type CanaryRunState = "RUNNING" | "PASSED" | "FAILED" | (string & {});
export declare const CanaryRunState: S.String;
export type CanaryRunStateReasonCode = "CANARY_FAILURE" | "EXECUTION_FAILURE" | (string & {});
export declare const CanaryRunStateReasonCode: S.String;
export type CanaryRunTestResult = "PASSED" | "FAILED" | "UNKNOWN" | (string & {});
export declare const CanaryRunTestResult: S.String;
export interface CanaryRunStatus {
    State?: CanaryRunState;
    StateReason?: string;
    StateReasonCode?: CanaryRunStateReasonCode;
    TestResult?: CanaryRunTestResult;
}
export declare const CanaryRunStatus: S.Schema<CanaryRunStatus>;
export interface CanaryRunTimeline {
    Started?: Date;
    Completed?: Date;
    MetricTimestampForRunAndRetries?: Date;
}
export declare const CanaryRunTimeline: S.Schema<CanaryRunTimeline>;
export interface CanaryDryRunConfigOutput {
    DryRunId?: string;
}
export declare const CanaryDryRunConfigOutput: S.Schema<CanaryDryRunConfigOutput>;
export interface CanaryRun {
    Id?: string;
    ScheduledRunId?: string;
    RetryAttempt?: number;
    Name?: string;
    Status?: CanaryRunStatus;
    Timeline?: CanaryRunTimeline;
    ArtifactS3Location?: string;
    DryRunConfig?: CanaryDryRunConfigOutput;
    BrowserType?: BrowserType;
}
export declare const CanaryRun: S.Schema<CanaryRun>;
export interface CanaryLastRun {
    CanaryName?: string;
    LastRun?: CanaryRun;
}
export declare const CanaryLastRun: S.Schema<CanaryLastRun>;
export type CanariesLastRun = CanaryLastRun[];
export declare const CanariesLastRun: S.$Array<S.Schema<CanaryLastRun>>;
export interface DescribeCanariesLastRunResponse {
    CanariesLastRun?: CanaryLastRun[];
    NextToken?: string;
}
export declare const DescribeCanariesLastRunResponse: S.Schema<DescribeCanariesLastRunResponse>;
export interface DescribeRuntimeVersionsRequest {
    NextToken?: string;
    MaxResults?: number;
}
export declare const DescribeRuntimeVersionsRequest: S.Schema<DescribeRuntimeVersionsRequest>;
export interface RuntimeVersion {
    VersionName?: string;
    Description?: string;
    ReleaseDate?: Date;
    DeprecationDate?: Date;
}
export declare const RuntimeVersion: S.Schema<RuntimeVersion>;
export type RuntimeVersionList = RuntimeVersion[];
export declare const RuntimeVersionList: S.$Array<S.Schema<RuntimeVersion>>;
export interface DescribeRuntimeVersionsResponse {
    RuntimeVersions?: RuntimeVersion[];
    NextToken?: string;
}
export declare const DescribeRuntimeVersionsResponse: S.Schema<DescribeRuntimeVersionsResponse>;
export interface DisassociateResourceRequest {
    GroupIdentifier: string;
    ResourceArn: string;
}
export declare const DisassociateResourceRequest: S.Schema<DisassociateResourceRequest>;
export interface DisassociateResourceResponse {
}
export declare const DisassociateResourceResponse: S.Schema<DisassociateResourceResponse>;
export interface GetCanaryRequest {
    Name: string;
    DryRunId?: string;
}
export declare const GetCanaryRequest: S.Schema<GetCanaryRequest>;
export interface GetCanaryResponse {
    Canary?: Canary;
}
export declare const GetCanaryResponse: S.Schema<GetCanaryResponse>;
export type RunType = "CANARY_RUN" | "DRY_RUN" | (string & {});
export declare const RunType: S.String;
export interface GetCanaryRunsRequest {
    Name: string;
    NextToken?: string;
    MaxResults?: number;
    DryRunId?: string;
    RunType?: RunType;
}
export declare const GetCanaryRunsRequest: S.Schema<GetCanaryRunsRequest>;
export type CanaryRuns = CanaryRun[];
export declare const CanaryRuns: S.$Array<S.Schema<CanaryRun>>;
export interface GetCanaryRunsResponse {
    CanaryRuns?: CanaryRun[];
    NextToken?: string;
}
export declare const GetCanaryRunsResponse: S.Schema<GetCanaryRunsResponse>;
export interface GetGroupRequest {
    GroupIdentifier: string;
}
export declare const GetGroupRequest: S.Schema<GetGroupRequest>;
export interface GetGroupResponse {
    Group?: Group;
}
export declare const GetGroupResponse: S.Schema<GetGroupResponse>;
export interface ListAssociatedGroupsRequest {
    NextToken?: string;
    MaxResults?: number;
    ResourceArn: string;
}
export declare const ListAssociatedGroupsRequest: S.Schema<ListAssociatedGroupsRequest>;
export interface GroupSummary {
    Id?: string;
    Name?: string;
    Arn?: string;
}
export declare const GroupSummary: S.Schema<GroupSummary>;
export type GroupSummaryList = GroupSummary[];
export declare const GroupSummaryList: S.$Array<S.Schema<GroupSummary>>;
export interface ListAssociatedGroupsResponse {
    Groups?: GroupSummary[];
    NextToken?: string;
}
export declare const ListAssociatedGroupsResponse: S.Schema<ListAssociatedGroupsResponse>;
export interface ListGroupResourcesRequest {
    NextToken?: string;
    MaxResults?: number;
    GroupIdentifier: string;
}
export declare const ListGroupResourcesRequest: S.Schema<ListGroupResourcesRequest>;
export type StringList = string[];
export declare const StringList: S.$Array<S.String>;
export interface ListGroupResourcesResponse {
    Resources?: string[];
    NextToken?: string;
}
export declare const ListGroupResourcesResponse: S.Schema<ListGroupResourcesResponse>;
export interface ListGroupsRequest {
    NextToken?: string;
    MaxResults?: number;
}
export declare const ListGroupsRequest: S.Schema<ListGroupsRequest>;
export interface ListGroupsResponse {
    Groups?: GroupSummary[];
    NextToken?: string;
}
export declare const ListGroupsResponse: S.Schema<ListGroupsResponse>;
export interface ListTagsForResourceRequest {
    ResourceArn: string;
}
export declare const ListTagsForResourceRequest: S.Schema<ListTagsForResourceRequest>;
export interface ListTagsForResourceResponse {
    Tags?: {
        [key: string]: string | undefined;
    };
}
export declare const ListTagsForResourceResponse: S.Schema<ListTagsForResourceResponse>;
export interface StartCanaryRequest {
    Name: string;
}
export declare const StartCanaryRequest: S.Schema<StartCanaryRequest>;
export interface StartCanaryResponse {
}
export declare const StartCanaryResponse: S.Schema<StartCanaryResponse>;
export interface VisualReferenceInput {
    BaseScreenshots?: BaseScreenshot[];
    BaseCanaryRunId: string;
    BrowserType?: BrowserType;
}
export declare const VisualReferenceInput: S.Schema<VisualReferenceInput>;
export type VisualReferences = VisualReferenceInput[];
export declare const VisualReferences: S.$Array<S.Schema<VisualReferenceInput>>;
export interface StartCanaryDryRunRequest {
    Name: string;
    Code?: CanaryCodeInput;
    RuntimeVersion?: string;
    RunConfig?: CanaryRunConfigInput;
    VpcConfig?: VpcConfigInput;
    ExecutionRoleArn?: string;
    SuccessRetentionPeriodInDays?: number;
    FailureRetentionPeriodInDays?: number;
    VisualReference?: VisualReferenceInput;
    ArtifactS3Location?: string;
    ArtifactConfig?: ArtifactConfigInput;
    ProvisionedResourceCleanup?: ProvisionedResourceCleanupSetting;
    BrowserConfigs?: BrowserConfig[];
    VisualReferences?: VisualReferenceInput[];
}
export declare const StartCanaryDryRunRequest: S.Schema<StartCanaryDryRunRequest>;
export interface StartCanaryDryRunResponse {
    DryRunConfig?: DryRunConfigOutput;
}
export declare const StartCanaryDryRunResponse: S.Schema<StartCanaryDryRunResponse>;
export interface StopCanaryRequest {
    Name: string;
}
export declare const StopCanaryRequest: S.Schema<StopCanaryRequest>;
export interface StopCanaryResponse {
}
export declare const StopCanaryResponse: S.Schema<StopCanaryResponse>;
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 UpdateCanaryRequest {
    Name: string;
    Code?: CanaryCodeInput;
    ExecutionRoleArn?: string;
    RuntimeVersion?: string;
    Schedule?: CanaryScheduleInput;
    RunConfig?: CanaryRunConfigInput;
    SuccessRetentionPeriodInDays?: number;
    FailureRetentionPeriodInDays?: number;
    VpcConfig?: VpcConfigInput;
    VisualReference?: VisualReferenceInput;
    ArtifactS3Location?: string;
    ArtifactConfig?: ArtifactConfigInput;
    ProvisionedResourceCleanup?: ProvisionedResourceCleanupSetting;
    DryRunId?: string;
    VisualReferences?: VisualReferenceInput[];
    BrowserConfigs?: BrowserConfig[];
}
export declare const UpdateCanaryRequest: S.Schema<UpdateCanaryRequest>;
export interface UpdateCanaryResponse {
}
export declare const UpdateCanaryResponse: S.Schema<UpdateCanaryResponse>;
declare const ConflictException_base: S.Class<ConflictException, S.TaggedStruct<"ConflictException", {
    readonly Message: S.optional<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.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
});
export declare class InternalServerException extends InternalServerException_base {
}
declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
}
declare const ServiceQuotaExceededException_base: S.Class<ServiceQuotaExceededException, S.TaggedStruct<"ServiceQuotaExceededException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        QuotaError: true;
    };
});
export declare class ServiceQuotaExceededException extends ServiceQuotaExceededException_base {
}
declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ValidationException extends ValidationException_base {
}
declare const RequestEntityTooLargeException_base: S.Class<RequestEntityTooLargeException, S.TaggedStruct<"RequestEntityTooLargeException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class RequestEntityTooLargeException extends RequestEntityTooLargeException_base {
}
declare const BadRequestException_base: S.Class<BadRequestException, S.TaggedStruct<"BadRequestException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class BadRequestException extends BadRequestException_base {
}
declare const InternalFailureException_base: S.Class<InternalFailureException, S.TaggedStruct<"InternalFailureException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ServerError: true;
    };
});
export declare class InternalFailureException extends InternalFailureException_base {
}
declare const NotFoundException_base: S.Class<NotFoundException, S.TaggedStruct<"NotFoundException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class NotFoundException extends NotFoundException_base {
}
declare const TooManyRequestsException_base: S.Class<TooManyRequestsException, S.TaggedStruct<"TooManyRequestsException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        ThrottlingError: true;
    };
});
export declare class TooManyRequestsException extends TooManyRequestsException_base {
}
declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
    readonly Message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class AccessDeniedException extends AccessDeniedException_base {
}
export type AssociateResourceError = ConflictException | InternalServerException | ResourceNotFoundException | ServiceQuotaExceededException | ValidationException | CommonErrors;
/**
 * Associates a canary with a group. Using groups can help you with
 * managing and automating your canaries, and you can also view aggregated run results and statistics
 * for all canaries in a group.
 *
 * You must run this operation in the Region where the canary exists.
 */
export declare const associateResource: API.OperationMethod<AssociateResourceRequest, AssociateResourceResponse, AssociateResourceError, Credentials | Region | HttpClient.HttpClient>;
export type CreateCanaryError = InternalServerException | RequestEntityTooLargeException | ValidationException | CommonErrors;
/**
 * Creates a canary. Canaries are scripts that monitor your endpoints and APIs from the
 * outside-in. Canaries help you check the availability and latency of your web services and
 * troubleshoot anomalies by investigating load time data, screenshots of the UI, logs, and
 * metrics. You can set up a canary to run continuously or just once.
 *
 * Do not use `CreateCanary` to modify an existing canary. Use UpdateCanary instead.
 *
 * To create canaries, you must have the `CloudWatchSyntheticsFullAccess` policy.
 * If you are creating a new IAM role for the canary, you also need the
 * `iam:CreateRole`, `iam:CreatePolicy` and
 * `iam:AttachRolePolicy` permissions. For more information, see Necessary
 * Roles and Permissions.
 *
 * Do not include secrets or proprietary information in your canary names. The canary name
 * makes up part of the Amazon Resource Name (ARN) for the canary, and the ARN is included in
 * outbound calls over the internet. For more information, see Security
 * Considerations for Synthetics Canaries.
 */
export declare const createCanary: API.OperationMethod<CreateCanaryRequest, CreateCanaryResponse, CreateCanaryError, Credentials | Region | HttpClient.HttpClient>;
export type CreateGroupError = ConflictException | InternalServerException | ServiceQuotaExceededException | ValidationException | CommonErrors;
/**
 * Creates a group which you can use to associate canaries with each other, including cross-Region
 * canaries. Using groups can help you with
 * managing and automating your canaries, and you can also view aggregated run results and statistics
 * for all canaries in a group.
 *
 * Groups are global resources. When you create a group, it is replicated across Amazon Web Services Regions, and
 * you can view it and add canaries to it from any Region.
 * Although the group ARN format reflects the Region name where it was created, a group is not constrained to any Region.
 * This means that you can put canaries from multiple Regions into the same group, and then use
 * that group to view and manage all of those canaries in a single view.
 *
 * Groups are supported in all Regions except the Regions that are disabled by default. For more information
 * about these Regions, see Enabling a Region.
 *
 * Each group can contain as many as 10 canaries. You can have as many as 20 groups in your account. Any single canary
 * can be a member of up to 10 groups.
 */
export declare const createGroup: API.OperationMethod<CreateGroupRequest, CreateGroupResponse, CreateGroupError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteCanaryError = ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Permanently deletes the specified canary.
 *
 * If the canary's `ProvisionedResourceCleanup` field is set to `AUTOMATIC`
 * or you specify `DeleteLambda` in this operation as `true`, CloudWatch Synthetics also deletes
 * the Lambda functions and layers that are used by the canary.
 *
 * Other resources used and created by the canary are not automatically deleted.
 * After you delete a canary, you
 * should also delete the following:
 *
 * - The CloudWatch alarms created for this canary. These alarms have a name of
 * Synthetics-Alarm-*first-198-characters-of-canary-name*-*canaryId*-*alarm number*
 *
 * - Amazon S3 objects and buckets, such as the canary's artifact location.
 *
 * - IAM roles created for the canary. If they were created in the console, these roles
 * have the name
 * role/service-role/CloudWatchSyntheticsRole-*First-21-Characters-of-CanaryName*
 *
 * - CloudWatch Logs log groups created for the canary. These logs groups have the name
 * /aws/lambda/cwsyn-*First-21-Characters-of-CanaryName*
 *
 * Before you delete a canary, you might want to use `GetCanary` to display
 * the information about this canary. Make
 * note of the information returned by this operation so that you can delete these resources
 * after you delete the canary.
 */
export declare const deleteCanary: API.OperationMethod<DeleteCanaryRequest, DeleteCanaryResponse, DeleteCanaryError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteGroupError = ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Deletes a group. The group doesn't need to be empty to be deleted. If there are canaries in the group,
 * they are not deleted when you delete the group.
 *
 * Groups are a global resource that appear in all Regions, but the request to delete a group
 * must be made from its home Region. You can find the home Region of a group within its ARN.
 */
export declare const deleteGroup: API.OperationMethod<DeleteGroupRequest, DeleteGroupResponse, DeleteGroupError, Credentials | Region | HttpClient.HttpClient>;
export type DescribeCanariesError = InternalServerException | ValidationException | CommonErrors;
/**
 * This operation returns a list of the canaries in your account, along with full details
 * about each canary.
 *
 * This operation supports resource-level authorization using an IAM policy and
 * the `Names` parameter. If you specify the `Names` parameter, the operation is successful only if you have authorization to view
 * all the canaries that you specify in your request. If you do not have permission to view any of
 * the canaries, the request fails with a 403 response.
 *
 * You are required to use the `Names` parameter if you are logged on to a user or role that has an
 * IAM policy that restricts which canaries that you are allowed to view. For more information,
 * see
 * Limiting a user to viewing specific canaries.
 */
export declare const describeCanaries: API.OperationMethod<DescribeCanariesRequest, DescribeCanariesResponse, DescribeCanariesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: DescribeCanariesRequest) => stream.Stream<DescribeCanariesResponse, DescribeCanariesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: DescribeCanariesRequest) => stream.Stream<unknown, DescribeCanariesError, Credentials | Region | HttpClient.HttpClient>;
};
export type DescribeCanariesLastRunError = InternalServerException | ValidationException | CommonErrors;
/**
 * Use this operation to see information from the most recent run of each canary that you have created.
 *
 * This operation supports resource-level authorization using an IAM policy and
 * the `Names` parameter. If you specify the `Names` parameter, the operation is successful only if you have authorization to view
 * all the canaries that you specify in your request. If you do not have permission to view any of
 * the canaries, the request fails with a 403 response.
 *
 * You are required to use the `Names` parameter if you are logged on to a user or role that has an
 * IAM policy that restricts which canaries that you are allowed to view. For more information,
 * see
 * Limiting a user to viewing specific canaries.
 */
export declare const describeCanariesLastRun: API.OperationMethod<DescribeCanariesLastRunRequest, DescribeCanariesLastRunResponse, DescribeCanariesLastRunError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: DescribeCanariesLastRunRequest) => stream.Stream<DescribeCanariesLastRunResponse, DescribeCanariesLastRunError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: DescribeCanariesLastRunRequest) => stream.Stream<unknown, DescribeCanariesLastRunError, Credentials | Region | HttpClient.HttpClient>;
};
export type DescribeRuntimeVersionsError = InternalServerException | ValidationException | CommonErrors;
/**
 * Returns a list of Synthetics canary runtime versions. For more information,
 * see
 * Canary Runtime Versions.
 */
export declare const describeRuntimeVersions: API.OperationMethod<DescribeRuntimeVersionsRequest, DescribeRuntimeVersionsResponse, DescribeRuntimeVersionsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: DescribeRuntimeVersionsRequest) => stream.Stream<DescribeRuntimeVersionsResponse, DescribeRuntimeVersionsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: DescribeRuntimeVersionsRequest) => stream.Stream<unknown, DescribeRuntimeVersionsError, Credentials | Region | HttpClient.HttpClient>;
};
export type DisassociateResourceError = ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Removes a canary from a group. You must run this operation in the Region where the canary exists.
 */
export declare const disassociateResource: API.OperationMethod<DisassociateResourceRequest, DisassociateResourceResponse, DisassociateResourceError, Credentials | Region | HttpClient.HttpClient>;
export type GetCanaryError = InternalServerException | ValidationException | CommonErrors;
/**
 * Retrieves complete information about one canary. You must specify
 * the name of the canary that you want. To get a list of canaries
 * and their names, use DescribeCanaries.
 */
export declare const getCanary: API.OperationMethod<GetCanaryRequest, GetCanaryResponse, GetCanaryError, Credentials | Region | HttpClient.HttpClient>;
export type GetCanaryRunsError = InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Retrieves a list of runs for a specified canary.
 */
export declare const getCanaryRuns: API.OperationMethod<GetCanaryRunsRequest, GetCanaryRunsResponse, GetCanaryRunsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: GetCanaryRunsRequest) => stream.Stream<GetCanaryRunsResponse, GetCanaryRunsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: GetCanaryRunsRequest) => stream.Stream<unknown, GetCanaryRunsError, Credentials | Region | HttpClient.HttpClient>;
};
export type GetGroupError = ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Returns information about one group. Groups are a global resource, so you can use this operation from
 * any Region.
 */
export declare const getGroup: API.OperationMethod<GetGroupRequest, GetGroupResponse, GetGroupError, Credentials | Region | HttpClient.HttpClient>;
export type ListAssociatedGroupsError = InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Returns a list of the groups that the specified canary is associated with. The canary
 * that you specify must be in the current Region.
 */
export declare const listAssociatedGroups: API.OperationMethod<ListAssociatedGroupsRequest, ListAssociatedGroupsResponse, ListAssociatedGroupsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListAssociatedGroupsRequest) => stream.Stream<ListAssociatedGroupsResponse, ListAssociatedGroupsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListAssociatedGroupsRequest) => stream.Stream<unknown, ListAssociatedGroupsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListGroupResourcesError = ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * This operation returns a list of the ARNs of the canaries that are associated with the specified group.
 */
export declare const listGroupResources: API.OperationMethod<ListGroupResourcesRequest, ListGroupResourcesResponse, ListGroupResourcesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListGroupResourcesRequest) => stream.Stream<ListGroupResourcesResponse, ListGroupResourcesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListGroupResourcesRequest) => stream.Stream<unknown, ListGroupResourcesError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListGroupsError = InternalServerException | ValidationException | CommonErrors;
/**
 * Returns a list of all groups in the account, displaying their names, unique IDs, and ARNs. The groups
 * from all Regions are returned.
 */
export declare const listGroups: API.OperationMethod<ListGroupsRequest, ListGroupsResponse, ListGroupsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListGroupsRequest) => stream.Stream<ListGroupsResponse, ListGroupsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListGroupsRequest) => stream.Stream<unknown, ListGroupsError, Credentials | Region | HttpClient.HttpClient>;
};
export type ListTagsForResourceError = BadRequestException | ConflictException | InternalFailureException | NotFoundException | TooManyRequestsException | CommonErrors;
/**
 * Displays the tags associated with a canary or group.
 */
export declare const listTagsForResource: API.OperationMethod<ListTagsForResourceRequest, ListTagsForResourceResponse, ListTagsForResourceError, Credentials | Region | HttpClient.HttpClient>;
export type StartCanaryError = ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Use this operation to run a canary that has already been created.
 * The frequency of the canary runs is determined by the value of the canary's `Schedule`. To see a canary's schedule,
 * use GetCanary.
 */
export declare const startCanary: API.OperationMethod<StartCanaryRequest, StartCanaryResponse, StartCanaryError, Credentials | Region | HttpClient.HttpClient>;
export type StartCanaryDryRunError = AccessDeniedException | ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Use this operation to start a dry run for a canary that has already been created
 */
export declare const startCanaryDryRun: API.OperationMethod<StartCanaryDryRunRequest, StartCanaryDryRunResponse, StartCanaryDryRunError, Credentials | Region | HttpClient.HttpClient>;
export type StopCanaryError = ConflictException | InternalServerException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Stops the canary to prevent all future runs. If the canary is currently running,the
 * run that is in progress completes on its own, publishes metrics, and uploads artifacts, but
 * it is not recorded in Synthetics as a completed run.
 *
 * You can use `StartCanary` to start it running again
 * with the canary’s current schedule at any point in the future.
 */
export declare const stopCanary: API.OperationMethod<StopCanaryRequest, StopCanaryResponse, StopCanaryError, Credentials | Region | HttpClient.HttpClient>;
export type TagResourceError = BadRequestException | ConflictException | InternalFailureException | NotFoundException | TooManyRequestsException | CommonErrors;
/**
 * Assigns one or more tags (key-value pairs) to the specified canary or group.
 *
 * Tags can help you organize and categorize your
 * resources. You can also use them to scope user permissions, by granting a user permission to access or change only resources with
 * certain tag values.
 *
 * Tags don't have any semantic meaning to Amazon Web Services and are interpreted strictly as strings of characters.
 *
 * You can use the `TagResource` action with a resource that already has tags. If you specify a new
 * tag key for the resource,
 * this tag is appended to the list of tags associated
 * with the resource. If you specify a tag key that is already associated with the resource, the new tag
 * value that you specify replaces
 * the previous value for that tag.
 *
 * You can associate as many as 50 tags with a canary or group.
 */
export declare const tagResource: API.OperationMethod<TagResourceRequest, TagResourceResponse, TagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UntagResourceError = BadRequestException | ConflictException | InternalFailureException | NotFoundException | TooManyRequestsException | CommonErrors;
/**
 * Removes one or more tags from the specified resource.
 */
export declare const untagResource: API.OperationMethod<UntagResourceRequest, UntagResourceResponse, UntagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateCanaryError = AccessDeniedException | ConflictException | InternalServerException | RequestEntityTooLargeException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Updates the configuration of a canary that has already been created.
 *
 * For multibrowser canaries, you can add or remove browsers by updating the browserConfig list in the update call. For example:
 *
 * - To add Firefox to a canary that currently uses Chrome, specify browserConfigs as [CHROME, FIREFOX]
 *
 * - To remove Firefox and keep only Chrome, specify browserConfigs as [CHROME]
 *
 * You can't use this operation to update the tags of an existing canary. To change the tags of an existing canary, use
 * TagResource.
 *
 * When you use the `dryRunId` field when updating a canary, the only other field you can provide is the `Schedule`. Adding any other field will thrown an exception.
 */
export declare const updateCanary: API.OperationMethod<UpdateCanaryRequest, UpdateCanaryResponse, UpdateCanaryError, Credentials | Region | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=synthetics.d.ts.map