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.js";
import * as T from "../traits.js";
import * as C from "../category.js";
import { SensitiveString } from "../sensitive.js";
const ns = T.XmlNamespace("http://events.amazonaws.com/doc/2015-10-07");
const svc = T.AwsApiService({ sdkId: "Pipes", serviceShapeName: "Pipes" });
const auth = T.AwsAuthSigv4({ name: "pipes" });
const ver = T.ServiceVersion("2015-10-07");
const proto = T.AwsProtocolsRestJson1();
const rules = T.EndpointResolver((p, _) => {
    const { Region, UseDualStack = false, UseFIPS = false, Endpoint } = p;
    const e = (u, p = {}, h = {}) => ({
        type: "endpoint",
        endpoint: { url: u, properties: p, headers: h },
    });
    const err = (m) => ({
        type: "error",
        message: m,
    });
    if (Endpoint != null) {
        if (UseFIPS === true) {
            return err("Invalid Configuration: FIPS and custom endpoint are not supported");
        }
        if (UseDualStack === true) {
            return err("Invalid Configuration: Dualstack and custom endpoint are not supported");
        }
        return e(Endpoint);
    }
    if (Region != null) {
        {
            const PartitionResult = _.partition(Region);
            if (PartitionResult != null && PartitionResult !== false) {
                if (UseFIPS === true && UseDualStack === true) {
                    if (true === _.getAttr(PartitionResult, "supportsFIPS") &&
                        true === _.getAttr(PartitionResult, "supportsDualStack")) {
                        return e(`https://pipes-fips.${Region}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`);
                    }
                    return err("FIPS and DualStack are enabled, but this partition does not support one or both");
                }
                if (UseFIPS === true) {
                    if (_.getAttr(PartitionResult, "supportsFIPS") === true) {
                        return e(`https://pipes-fips.${Region}.${_.getAttr(PartitionResult, "dnsSuffix")}`);
                    }
                    return err("FIPS is enabled but this partition does not support FIPS");
                }
                if (UseDualStack === true) {
                    if (true === _.getAttr(PartitionResult, "supportsDualStack")) {
                        return e(`https://pipes.${Region}.${_.getAttr(PartitionResult, "dualStackDnsSuffix")}`);
                    }
                    return err("DualStack is enabled but this partition does not support DualStack");
                }
                return e(`https://pipes.${Region}.${_.getAttr(PartitionResult, "dnsSuffix")}`);
            }
        }
    }
    return err("Invalid Configuration: Missing Region");
});
export const ListTagsForResourceRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ resourceArn: S.String.pipe(T.HttpLabel("resourceArn")) }).pipe(T.all(ns, T.Http({ method: "GET", uri: "/tags/{resourceArn}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListTagsForResourceRequest",
});
export const TagMap = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, SensitiveString.pipe(S.optional));
export const ListTagsForResourceResponse = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ tags: S.optional(TagMap) }).pipe(ns)).annotate({
    identifier: "ListTagsForResourceResponse",
});
export const ValidationExceptionField = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ name: S.String, message: S.String })).annotate({
    identifier: "ValidationExceptionField",
});
export const ValidationExceptionFieldList = /*@__PURE__*/ /*#__PURE__*/ S.Array(ValidationExceptionField);
export const TagResourceRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    resourceArn: S.String.pipe(T.HttpLabel("resourceArn")),
    tags: TagMap,
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/tags/{resourceArn}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "TagResourceRequest",
});
export const TagResourceResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(ns)).annotate({
    identifier: "TagResourceResponse",
});
export const TagKeyList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const UntagResourceRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    resourceArn: S.String.pipe(T.HttpLabel("resourceArn")),
    tagKeys: TagKeyList.pipe(T.HttpQuery("tagKeys")),
}).pipe(T.all(ns, T.Http({ method: "DELETE", uri: "/tags/{resourceArn}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UntagResourceRequest",
});
export const UntagResourceResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({}).pipe(ns)).annotate({
    identifier: "UntagResourceResponse",
});
export const Filter = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Pattern: S.optional(SensitiveString) })).annotate({ identifier: "Filter" });
export const FilterList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Filter);
export const FilterCriteria = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Filters: S.optional(FilterList) })).annotate({ identifier: "FilterCriteria" });
export const DeadLetterConfig = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Arn: S.optional(S.String) })).annotate({
    identifier: "DeadLetterConfig",
});
export const PipeSourceKinesisStreamParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    BatchSize: S.optional(S.Number),
    DeadLetterConfig: S.optional(DeadLetterConfig),
    OnPartialBatchItemFailure: S.optional(S.String),
    MaximumBatchingWindowInSeconds: S.optional(S.Number),
    MaximumRecordAgeInSeconds: S.optional(S.Number),
    MaximumRetryAttempts: S.optional(S.Number),
    ParallelizationFactor: S.optional(S.Number),
    StartingPosition: S.String,
    StartingPositionTimestamp: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
})).annotate({
    identifier: "PipeSourceKinesisStreamParameters",
});
export const PipeSourceDynamoDBStreamParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    BatchSize: S.optional(S.Number),
    DeadLetterConfig: S.optional(DeadLetterConfig),
    OnPartialBatchItemFailure: S.optional(S.String),
    MaximumBatchingWindowInSeconds: S.optional(S.Number),
    MaximumRecordAgeInSeconds: S.optional(S.Number),
    MaximumRetryAttempts: S.optional(S.Number),
    ParallelizationFactor: S.optional(S.Number),
    StartingPosition: S.String,
})).annotate({
    identifier: "PipeSourceDynamoDBStreamParameters",
});
export const PipeSourceSqsQueueParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    BatchSize: S.optional(S.Number),
    MaximumBatchingWindowInSeconds: S.optional(S.Number),
})).annotate({
    identifier: "PipeSourceSqsQueueParameters",
});
export const MQBrokerAccessCredentials = /*@__PURE__*/ /*#__PURE__*/ S.Union([
    S.Struct({ BasicAuth: S.String }),
]);
export const PipeSourceActiveMQBrokerParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Credentials: MQBrokerAccessCredentials,
    QueueName: SensitiveString,
    BatchSize: S.optional(S.Number),
    MaximumBatchingWindowInSeconds: S.optional(S.Number),
})).annotate({
    identifier: "PipeSourceActiveMQBrokerParameters",
});
export const PipeSourceRabbitMQBrokerParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Credentials: MQBrokerAccessCredentials,
    QueueName: SensitiveString,
    VirtualHost: S.optional(SensitiveString),
    BatchSize: S.optional(S.Number),
    MaximumBatchingWindowInSeconds: S.optional(S.Number),
})).annotate({
    identifier: "PipeSourceRabbitMQBrokerParameters",
});
export const MSKAccessCredentials = /*@__PURE__*/ /*#__PURE__*/ S.Union([
    S.Struct({ SaslScram512Auth: S.String }),
    S.Struct({ ClientCertificateTlsAuth: S.String }),
]);
export const PipeSourceManagedStreamingKafkaParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    TopicName: SensitiveString,
    StartingPosition: S.optional(S.String),
    BatchSize: S.optional(S.Number),
    MaximumBatchingWindowInSeconds: S.optional(S.Number),
    ConsumerGroupID: S.optional(SensitiveString),
    Credentials: S.optional(MSKAccessCredentials),
})).annotate({
    identifier: "PipeSourceManagedStreamingKafkaParameters",
});
export const KafkaBootstrapServers = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(SensitiveString);
export const SelfManagedKafkaAccessConfigurationCredentials = 
/*@__PURE__*/ /*#__PURE__*/ S.Union([
    S.Struct({ BasicAuth: S.String }),
    S.Struct({ SaslScram512Auth: S.String }),
    S.Struct({ SaslScram256Auth: S.String }),
    S.Struct({ ClientCertificateTlsAuth: S.String }),
]);
export const SubnetIds = /*@__PURE__*/ /*#__PURE__*/ S.Array(SensitiveString);
export const SecurityGroupIds = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(SensitiveString);
export const SelfManagedKafkaAccessConfigurationVpc = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Subnets: S.optional(SubnetIds),
    SecurityGroup: S.optional(SecurityGroupIds),
})).annotate({
    identifier: "SelfManagedKafkaAccessConfigurationVpc",
});
export const PipeSourceSelfManagedKafkaParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    TopicName: SensitiveString,
    StartingPosition: S.optional(S.String),
    AdditionalBootstrapServers: S.optional(KafkaBootstrapServers),
    BatchSize: S.optional(S.Number),
    MaximumBatchingWindowInSeconds: S.optional(S.Number),
    ConsumerGroupID: S.optional(SensitiveString),
    Credentials: S.optional(SelfManagedKafkaAccessConfigurationCredentials),
    ServerRootCaCertificate: S.optional(S.String),
    Vpc: S.optional(SelfManagedKafkaAccessConfigurationVpc),
})).annotate({
    identifier: "PipeSourceSelfManagedKafkaParameters",
});
export const PipeSourceParameters = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    FilterCriteria: S.optional(FilterCriteria),
    KinesisStreamParameters: S.optional(PipeSourceKinesisStreamParameters),
    DynamoDBStreamParameters: S.optional(PipeSourceDynamoDBStreamParameters),
    SqsQueueParameters: S.optional(PipeSourceSqsQueueParameters),
    ActiveMQBrokerParameters: S.optional(PipeSourceActiveMQBrokerParameters),
    RabbitMQBrokerParameters: S.optional(PipeSourceRabbitMQBrokerParameters),
    ManagedStreamingKafkaParameters: S.optional(PipeSourceManagedStreamingKafkaParameters),
    SelfManagedKafkaParameters: S.optional(PipeSourceSelfManagedKafkaParameters),
})).annotate({
    identifier: "PipeSourceParameters",
});
export const PathParameterList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(SensitiveString);
export const HeaderParametersMap = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, SensitiveString.pipe(S.optional));
export const QueryStringParametersMap = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, SensitiveString.pipe(S.optional));
export const PipeEnrichmentHttpParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    PathParameterValues: S.optional(PathParameterList),
    HeaderParameters: S.optional(HeaderParametersMap),
    QueryStringParameters: S.optional(QueryStringParametersMap),
})).annotate({
    identifier: "PipeEnrichmentHttpParameters",
});
export const PipeEnrichmentParameters = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    InputTemplate: S.optional(SensitiveString),
    HttpParameters: S.optional(PipeEnrichmentHttpParameters),
})).annotate({
    identifier: "PipeEnrichmentParameters",
});
export const PipeTargetLambdaFunctionParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ InvocationType: S.optional(S.String) })).annotate({
    identifier: "PipeTargetLambdaFunctionParameters",
});
export const PipeTargetStateMachineParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ InvocationType: S.optional(S.String) })).annotate({
    identifier: "PipeTargetStateMachineParameters",
});
export const PipeTargetKinesisStreamParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ PartitionKey: SensitiveString })).annotate({
    identifier: "PipeTargetKinesisStreamParameters",
});
export const Subnets = /*@__PURE__*/ /*#__PURE__*/ S.Array(SensitiveString);
export const SecurityGroups = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(SensitiveString);
export const AwsVpcConfiguration = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Subnets: Subnets,
    SecurityGroups: S.optional(SecurityGroups),
    AssignPublicIp: S.optional(S.String),
})).annotate({
    identifier: "AwsVpcConfiguration",
});
export const NetworkConfiguration = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ awsvpcConfiguration: S.optional(AwsVpcConfiguration) })).annotate({
    identifier: "NetworkConfiguration",
});
export const CapacityProviderStrategyItem = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    capacityProvider: SensitiveString,
    weight: S.optional(S.Number),
    base: S.optional(S.Number),
})).annotate({
    identifier: "CapacityProviderStrategyItem",
});
export const CapacityProviderStrategy = /*@__PURE__*/ /*#__PURE__*/ S.Array(CapacityProviderStrategyItem);
export const PlacementConstraint = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    type: S.optional(S.String),
    expression: S.optional(SensitiveString),
})).annotate({
    identifier: "PlacementConstraint",
});
export const PlacementConstraints = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(PlacementConstraint);
export const PlacementStrategy = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ type: S.optional(S.String), field: S.optional(SensitiveString) })).annotate({
    identifier: "PlacementStrategy",
});
export const PlacementStrategies = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(PlacementStrategy);
export const StringList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const EcsEnvironmentVariable = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ name: S.optional(S.String), value: S.optional(S.String) })).annotate({
    identifier: "EcsEnvironmentVariable",
});
export const EcsEnvironmentVariableList = /*@__PURE__*/ /*#__PURE__*/ S.Array(EcsEnvironmentVariable);
export const EcsEnvironmentFile = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ type: S.String, value: S.String })).annotate({
    identifier: "EcsEnvironmentFile",
});
export const EcsEnvironmentFileList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(EcsEnvironmentFile);
export const EcsResourceRequirement = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ type: S.String, value: S.String })).annotate({
    identifier: "EcsResourceRequirement",
});
export const EcsResourceRequirementsList = /*@__PURE__*/ /*#__PURE__*/ S.Array(EcsResourceRequirement);
export const EcsContainerOverride = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Command: S.optional(StringList),
    Cpu: S.optional(S.Number),
    Environment: S.optional(EcsEnvironmentVariableList),
    EnvironmentFiles: S.optional(EcsEnvironmentFileList),
    Memory: S.optional(S.Number),
    MemoryReservation: S.optional(S.Number),
    Name: S.optional(S.String),
    ResourceRequirements: S.optional(EcsResourceRequirementsList),
})).annotate({
    identifier: "EcsContainerOverride",
});
export const EcsContainerOverrideList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(EcsContainerOverride);
export const EcsEphemeralStorage = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ sizeInGiB: S.Number })).annotate({
    identifier: "EcsEphemeralStorage",
});
export const EcsInferenceAcceleratorOverride = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    deviceName: S.optional(S.String),
    deviceType: S.optional(S.String),
})).annotate({
    identifier: "EcsInferenceAcceleratorOverride",
});
export const EcsInferenceAcceleratorOverrideList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(EcsInferenceAcceleratorOverride);
export const EcsTaskOverride = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    ContainerOverrides: S.optional(EcsContainerOverrideList),
    Cpu: S.optional(S.String),
    EphemeralStorage: S.optional(EcsEphemeralStorage),
    ExecutionRoleArn: S.optional(S.String),
    InferenceAcceleratorOverrides: S.optional(EcsInferenceAcceleratorOverrideList),
    Memory: S.optional(S.String),
    TaskRoleArn: S.optional(S.String),
})).annotate({
    identifier: "EcsTaskOverride",
});
export const Tag = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Key: S.String, Value: SensitiveString })).annotate({ identifier: "Tag" });
export const TagList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Tag);
export const PipeTargetEcsTaskParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    TaskDefinitionArn: S.String,
    TaskCount: S.optional(S.Number),
    LaunchType: S.optional(S.String),
    NetworkConfiguration: S.optional(NetworkConfiguration),
    PlatformVersion: S.optional(S.String),
    Group: S.optional(S.String),
    CapacityProviderStrategy: S.optional(CapacityProviderStrategy),
    EnableECSManagedTags: S.optional(S.Boolean),
    EnableExecuteCommand: S.optional(S.Boolean),
    PlacementConstraints: S.optional(PlacementConstraints),
    PlacementStrategy: S.optional(PlacementStrategies),
    PropagateTags: S.optional(S.String),
    ReferenceId: S.optional(SensitiveString),
    Overrides: S.optional(EcsTaskOverride),
    Tags: S.optional(TagList),
})).annotate({
    identifier: "PipeTargetEcsTaskParameters",
});
export const BatchArrayProperties = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Size: S.optional(S.Number) })).annotate({
    identifier: "BatchArrayProperties",
});
export const BatchRetryStrategy = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Attempts: S.optional(S.Number) })).annotate({
    identifier: "BatchRetryStrategy",
});
export const BatchEnvironmentVariable = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: S.optional(S.String), Value: S.optional(S.String) })).annotate({
    identifier: "BatchEnvironmentVariable",
});
export const BatchEnvironmentVariableList = /*@__PURE__*/ /*#__PURE__*/ S.Array(BatchEnvironmentVariable);
export const BatchResourceRequirement = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Type: S.String, Value: S.String })).annotate({
    identifier: "BatchResourceRequirement",
});
export const BatchResourceRequirementsList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(BatchResourceRequirement);
export const BatchContainerOverrides = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Command: S.optional(StringList),
    Environment: S.optional(BatchEnvironmentVariableList),
    InstanceType: S.optional(S.String),
    ResourceRequirements: S.optional(BatchResourceRequirementsList),
})).annotate({
    identifier: "BatchContainerOverrides",
});
export const BatchJobDependency = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ JobId: S.optional(S.String), Type: S.optional(S.String) })).annotate({
    identifier: "BatchJobDependency",
});
export const BatchDependsOn = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(BatchJobDependency);
export const BatchParametersMap = /*@__PURE__*/ /*#__PURE__*/ S.Record(S.String, S.String.pipe(S.optional));
export const PipeTargetBatchJobParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    JobDefinition: S.String,
    JobName: S.String,
    ArrayProperties: S.optional(BatchArrayProperties),
    RetryStrategy: S.optional(BatchRetryStrategy),
    ContainerOverrides: S.optional(BatchContainerOverrides),
    DependsOn: S.optional(BatchDependsOn),
    Parameters: S.optional(BatchParametersMap),
})).annotate({
    identifier: "PipeTargetBatchJobParameters",
});
export const PipeTargetSqsQueueParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    MessageGroupId: S.optional(SensitiveString),
    MessageDeduplicationId: S.optional(SensitiveString),
})).annotate({
    identifier: "PipeTargetSqsQueueParameters",
});
export const PipeTargetHttpParameters = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    PathParameterValues: S.optional(PathParameterList),
    HeaderParameters: S.optional(HeaderParametersMap),
    QueryStringParameters: S.optional(QueryStringParametersMap),
})).annotate({
    identifier: "PipeTargetHttpParameters",
});
export const Sqls = /*@__PURE__*/ /*#__PURE__*/ S.Array(SensitiveString);
export const PipeTargetRedshiftDataParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    SecretManagerArn: S.optional(S.String),
    Database: SensitiveString,
    DbUser: S.optional(SensitiveString),
    StatementName: S.optional(SensitiveString),
    WithEvent: S.optional(S.Boolean),
    Sqls: Sqls,
})).annotate({
    identifier: "PipeTargetRedshiftDataParameters",
});
export const SageMakerPipelineParameter = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: SensitiveString, Value: SensitiveString })).annotate({
    identifier: "SageMakerPipelineParameter",
});
export const SageMakerPipelineParameterList = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(SageMakerPipelineParameter);
export const PipeTargetSageMakerPipelineParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    PipelineParameterList: S.optional(SageMakerPipelineParameterList),
})).annotate({
    identifier: "PipeTargetSageMakerPipelineParameters",
});
export const EventBridgeEventResourceList = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const PipeTargetEventBridgeEventBusParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    EndpointId: S.optional(SensitiveString),
    DetailType: S.optional(SensitiveString),
    Source: S.optional(SensitiveString),
    Resources: S.optional(EventBridgeEventResourceList),
    Time: S.optional(S.String),
})).annotate({
    identifier: "PipeTargetEventBridgeEventBusParameters",
});
export const PipeTargetCloudWatchLogsParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    LogStreamName: S.optional(S.String),
    Timestamp: S.optional(S.String),
})).annotate({
    identifier: "PipeTargetCloudWatchLogsParameters",
});
export const DimensionMapping = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    DimensionValue: S.String,
    DimensionValueType: S.String,
    DimensionName: S.String,
})).annotate({
    identifier: "DimensionMapping",
});
export const DimensionMappings = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(DimensionMapping);
export const SingleMeasureMapping = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    MeasureValue: S.String,
    MeasureValueType: S.String,
    MeasureName: S.String,
})).annotate({
    identifier: "SingleMeasureMapping",
});
export const SingleMeasureMappings = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(SingleMeasureMapping);
export const MultiMeasureAttributeMapping = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    MeasureValue: S.String,
    MeasureValueType: S.String,
    MultiMeasureAttributeName: S.String,
})).annotate({
    identifier: "MultiMeasureAttributeMapping",
});
export const MultiMeasureAttributeMappings = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(MultiMeasureAttributeMapping);
export const MultiMeasureMapping = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    MultiMeasureName: S.String,
    MultiMeasureAttributeMappings: MultiMeasureAttributeMappings,
})).annotate({
    identifier: "MultiMeasureMapping",
});
export const MultiMeasureMappings = 
/*@__PURE__*/ /*#__PURE__*/ S.Array(MultiMeasureMapping);
export const PipeTargetTimestreamParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    TimeValue: S.String,
    EpochTimeUnit: S.optional(S.String),
    TimeFieldType: S.optional(S.String),
    TimestampFormat: S.optional(S.String),
    VersionValue: S.String,
    DimensionMappings: DimensionMappings,
    SingleMeasureMappings: S.optional(SingleMeasureMappings),
    MultiMeasureMappings: S.optional(MultiMeasureMappings),
})).annotate({
    identifier: "PipeTargetTimestreamParameters",
});
export const PipeTargetParameters = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    InputTemplate: S.optional(SensitiveString),
    LambdaFunctionParameters: S.optional(PipeTargetLambdaFunctionParameters),
    StepFunctionStateMachineParameters: S.optional(PipeTargetStateMachineParameters),
    KinesisStreamParameters: S.optional(PipeTargetKinesisStreamParameters),
    EcsTaskParameters: S.optional(PipeTargetEcsTaskParameters),
    BatchJobParameters: S.optional(PipeTargetBatchJobParameters),
    SqsQueueParameters: S.optional(PipeTargetSqsQueueParameters),
    HttpParameters: S.optional(PipeTargetHttpParameters),
    RedshiftDataParameters: S.optional(PipeTargetRedshiftDataParameters),
    SageMakerPipelineParameters: S.optional(PipeTargetSageMakerPipelineParameters),
    EventBridgeEventBusParameters: S.optional(PipeTargetEventBridgeEventBusParameters),
    CloudWatchLogsParameters: S.optional(PipeTargetCloudWatchLogsParameters),
    TimestreamParameters: S.optional(PipeTargetTimestreamParameters),
})).annotate({
    identifier: "PipeTargetParameters",
});
export const S3LogDestinationParameters = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    BucketName: S.String,
    BucketOwner: S.String,
    OutputFormat: S.optional(S.String),
    Prefix: S.optional(S.String),
})).annotate({
    identifier: "S3LogDestinationParameters",
});
export const FirehoseLogDestinationParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DeliveryStreamArn: S.String })).annotate({
    identifier: "FirehoseLogDestinationParameters",
});
export const CloudwatchLogsLogDestinationParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ LogGroupArn: S.String })).annotate({
    identifier: "CloudwatchLogsLogDestinationParameters",
});
export const IncludeExecutionData = /*@__PURE__*/ /*#__PURE__*/ S.Array(S.String);
export const PipeLogConfigurationParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    S3LogDestination: S.optional(S3LogDestinationParameters),
    FirehoseLogDestination: S.optional(FirehoseLogDestinationParameters),
    CloudwatchLogsLogDestination: S.optional(CloudwatchLogsLogDestinationParameters),
    Level: S.String,
    IncludeExecutionData: S.optional(IncludeExecutionData),
})).annotate({
    identifier: "PipeLogConfigurationParameters",
});
export const CreatePipeRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.String.pipe(T.HttpLabel("Name")),
    Description: S.optional(SensitiveString),
    DesiredState: S.optional(S.String),
    Source: S.String,
    SourceParameters: S.optional(PipeSourceParameters),
    Enrichment: S.optional(S.String),
    EnrichmentParameters: S.optional(PipeEnrichmentParameters),
    Target: S.String,
    TargetParameters: S.optional(PipeTargetParameters),
    RoleArn: S.String,
    Tags: S.optional(TagMap),
    LogConfiguration: S.optional(PipeLogConfigurationParameters),
    KmsKeyIdentifier: S.optional(S.String),
}).pipe(T.all(ns, T.Http({ method: "POST", uri: "/v1/pipes/{Name}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "CreatePipeRequest",
});
export const CreatePipeResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Arn: S.optional(S.String),
    Name: S.optional(S.String),
    DesiredState: S.optional(S.String),
    CurrentState: S.optional(S.String),
    CreationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastModifiedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
}).pipe(ns)).annotate({
    identifier: "CreatePipeResponse",
});
export const DescribePipeRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: S.String.pipe(T.HttpLabel("Name")) }).pipe(T.all(ns, T.Http({ method: "GET", uri: "/v1/pipes/{Name}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DescribePipeRequest",
});
export const S3LogDestination = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    BucketName: S.optional(S.String),
    Prefix: S.optional(S.String),
    BucketOwner: S.optional(S.String),
    OutputFormat: S.optional(S.String),
})).annotate({
    identifier: "S3LogDestination",
});
export const FirehoseLogDestination = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ DeliveryStreamArn: S.optional(S.String) })).annotate({
    identifier: "FirehoseLogDestination",
});
export const CloudwatchLogsLogDestination = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ LogGroupArn: S.optional(S.String) })).annotate({
    identifier: "CloudwatchLogsLogDestination",
});
export const PipeLogConfiguration = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    S3LogDestination: S.optional(S3LogDestination),
    FirehoseLogDestination: S.optional(FirehoseLogDestination),
    CloudwatchLogsLogDestination: S.optional(CloudwatchLogsLogDestination),
    Level: S.optional(S.String),
    IncludeExecutionData: S.optional(IncludeExecutionData),
})).annotate({
    identifier: "PipeLogConfiguration",
});
export const DescribePipeResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Arn: S.optional(S.String),
    Name: S.optional(S.String),
    Description: S.optional(SensitiveString),
    DesiredState: S.optional(S.String),
    CurrentState: S.optional(S.String),
    StateReason: S.optional(S.String),
    Source: S.optional(S.String),
    SourceParameters: S.optional(PipeSourceParameters),
    Enrichment: S.optional(S.String),
    EnrichmentParameters: S.optional(PipeEnrichmentParameters),
    Target: S.optional(S.String),
    TargetParameters: S.optional(PipeTargetParameters),
    RoleArn: S.optional(S.String),
    Tags: S.optional(TagMap),
    CreationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastModifiedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LogConfiguration: S.optional(PipeLogConfiguration),
    KmsKeyIdentifier: S.optional(S.String),
}).pipe(ns)).annotate({
    identifier: "DescribePipeResponse",
});
export const UpdatePipeSourceKinesisStreamParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    BatchSize: S.optional(S.Number),
    DeadLetterConfig: S.optional(DeadLetterConfig),
    OnPartialBatchItemFailure: S.optional(S.String),
    MaximumBatchingWindowInSeconds: S.optional(S.Number),
    MaximumRecordAgeInSeconds: S.optional(S.Number),
    MaximumRetryAttempts: S.optional(S.Number),
    ParallelizationFactor: S.optional(S.Number),
})).annotate({
    identifier: "UpdatePipeSourceKinesisStreamParameters",
});
export const UpdatePipeSourceDynamoDBStreamParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    BatchSize: S.optional(S.Number),
    DeadLetterConfig: S.optional(DeadLetterConfig),
    OnPartialBatchItemFailure: S.optional(S.String),
    MaximumBatchingWindowInSeconds: S.optional(S.Number),
    MaximumRecordAgeInSeconds: S.optional(S.Number),
    MaximumRetryAttempts: S.optional(S.Number),
    ParallelizationFactor: S.optional(S.Number),
})).annotate({
    identifier: "UpdatePipeSourceDynamoDBStreamParameters",
});
export const UpdatePipeSourceSqsQueueParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    BatchSize: S.optional(S.Number),
    MaximumBatchingWindowInSeconds: S.optional(S.Number),
})).annotate({
    identifier: "UpdatePipeSourceSqsQueueParameters",
});
export const UpdatePipeSourceActiveMQBrokerParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Credentials: MQBrokerAccessCredentials,
    BatchSize: S.optional(S.Number),
    MaximumBatchingWindowInSeconds: S.optional(S.Number),
})).annotate({
    identifier: "UpdatePipeSourceActiveMQBrokerParameters",
});
export const UpdatePipeSourceRabbitMQBrokerParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Credentials: MQBrokerAccessCredentials,
    BatchSize: S.optional(S.Number),
    MaximumBatchingWindowInSeconds: S.optional(S.Number),
})).annotate({
    identifier: "UpdatePipeSourceRabbitMQBrokerParameters",
});
export const UpdatePipeSourceManagedStreamingKafkaParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    BatchSize: S.optional(S.Number),
    Credentials: S.optional(MSKAccessCredentials),
    MaximumBatchingWindowInSeconds: S.optional(S.Number),
})).annotate({
    identifier: "UpdatePipeSourceManagedStreamingKafkaParameters",
});
export const UpdatePipeSourceSelfManagedKafkaParameters = 
/*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    BatchSize: S.optional(S.Number),
    MaximumBatchingWindowInSeconds: S.optional(S.Number),
    Credentials: S.optional(SelfManagedKafkaAccessConfigurationCredentials),
    ServerRootCaCertificate: S.optional(S.String),
    Vpc: S.optional(SelfManagedKafkaAccessConfigurationVpc),
})).annotate({
    identifier: "UpdatePipeSourceSelfManagedKafkaParameters",
});
export const UpdatePipeSourceParameters = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    FilterCriteria: S.optional(FilterCriteria),
    KinesisStreamParameters: S.optional(UpdatePipeSourceKinesisStreamParameters),
    DynamoDBStreamParameters: S.optional(UpdatePipeSourceDynamoDBStreamParameters),
    SqsQueueParameters: S.optional(UpdatePipeSourceSqsQueueParameters),
    ActiveMQBrokerParameters: S.optional(UpdatePipeSourceActiveMQBrokerParameters),
    RabbitMQBrokerParameters: S.optional(UpdatePipeSourceRabbitMQBrokerParameters),
    ManagedStreamingKafkaParameters: S.optional(UpdatePipeSourceManagedStreamingKafkaParameters),
    SelfManagedKafkaParameters: S.optional(UpdatePipeSourceSelfManagedKafkaParameters),
})).annotate({
    identifier: "UpdatePipeSourceParameters",
});
export const UpdatePipeRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.String.pipe(T.HttpLabel("Name")),
    Description: S.optional(SensitiveString),
    DesiredState: S.optional(S.String),
    SourceParameters: S.optional(UpdatePipeSourceParameters),
    Enrichment: S.optional(S.String),
    EnrichmentParameters: S.optional(PipeEnrichmentParameters),
    Target: S.optional(S.String),
    TargetParameters: S.optional(PipeTargetParameters),
    RoleArn: S.String,
    LogConfiguration: S.optional(PipeLogConfigurationParameters),
    KmsKeyIdentifier: S.optional(S.String),
}).pipe(T.all(ns, T.Http({ method: "PUT", uri: "/v1/pipes/{Name}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "UpdatePipeRequest",
});
export const UpdatePipeResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Arn: S.optional(S.String),
    Name: S.optional(S.String),
    DesiredState: S.optional(S.String),
    CurrentState: S.optional(S.String),
    CreationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastModifiedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
}).pipe(ns)).annotate({
    identifier: "UpdatePipeResponse",
});
export const DeletePipeRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: S.String.pipe(T.HttpLabel("Name")) }).pipe(T.all(ns, T.Http({ method: "DELETE", uri: "/v1/pipes/{Name}" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "DeletePipeRequest",
});
export const DeletePipeResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Arn: S.optional(S.String),
    Name: S.optional(S.String),
    DesiredState: S.optional(S.String),
    CurrentState: S.optional(S.String),
    CreationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastModifiedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
}).pipe(ns)).annotate({
    identifier: "DeletePipeResponse",
});
export const ListPipesRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    NamePrefix: S.optional(S.String).pipe(T.HttpQuery("NamePrefix")),
    DesiredState: S.optional(S.String).pipe(T.HttpQuery("DesiredState")),
    CurrentState: S.optional(S.String).pipe(T.HttpQuery("CurrentState")),
    SourcePrefix: S.optional(S.String).pipe(T.HttpQuery("SourcePrefix")),
    TargetPrefix: S.optional(S.String).pipe(T.HttpQuery("TargetPrefix")),
    NextToken: S.optional(SensitiveString).pipe(T.HttpQuery("NextToken")),
    Limit: S.optional(S.Number).pipe(T.HttpQuery("Limit")),
}).pipe(T.all(ns, T.Http({ method: "GET", uri: "/v1/pipes" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "ListPipesRequest",
});
export const Pipe = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Name: S.optional(S.String),
    Arn: S.optional(S.String),
    DesiredState: S.optional(S.String),
    CurrentState: S.optional(S.String),
    StateReason: S.optional(S.String),
    CreationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastModifiedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    Source: S.optional(S.String),
    Target: S.optional(S.String),
    Enrichment: S.optional(S.String),
})).annotate({ identifier: "Pipe" });
export const PipeList = /*@__PURE__*/ /*#__PURE__*/ S.Array(Pipe);
export const ListPipesResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Pipes: S.optional(PipeList),
    NextToken: S.optional(SensitiveString),
}).pipe(ns)).annotate({
    identifier: "ListPipesResponse",
});
export const StartPipeRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: S.String.pipe(T.HttpLabel("Name")) }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/v1/pipes/{Name}/start" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "StartPipeRequest",
});
export const StartPipeResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Arn: S.optional(S.String),
    Name: S.optional(S.String),
    DesiredState: S.optional(S.String),
    CurrentState: S.optional(S.String),
    CreationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastModifiedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
}).pipe(ns)).annotate({
    identifier: "StartPipeResponse",
});
export const StopPipeRequest = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({ Name: S.String.pipe(T.HttpLabel("Name")) }).pipe(T.all(ns, T.Http({ method: "POST", uri: "/v1/pipes/{Name}/stop" }), svc, auth, proto, ver, rules))).annotate({
    identifier: "StopPipeRequest",
});
export const StopPipeResponse = /*@__PURE__*/ /*#__PURE__*/ S.suspend(() => S.Struct({
    Arn: S.optional(S.String),
    Name: S.optional(S.String),
    DesiredState: S.optional(S.String),
    CurrentState: S.optional(S.String),
    CreationTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
    LastModifiedTime: S.optional(S.Date.pipe(T.TimestampFormat("epoch-seconds"))),
}).pipe(ns)).annotate({
    identifier: "StopPipeResponse",
});
//# Errors
export class InternalException extends S.TaggedErrorClass()("InternalException", {
    message: S.String,
    retryAfterSeconds: S.optional(S.Number).pipe(T.HttpHeader("Retry-After")),
}).pipe(C.withServerError) {
}
export class NotFoundException extends S.TaggedErrorClass()("NotFoundException", { message: S.optional(S.String) }).pipe(C.withBadRequestError) {
}
export class ValidationException extends S.TaggedErrorClass()("ValidationException", {
    message: S.optional(S.String),
    fieldList: S.optional(ValidationExceptionFieldList),
}).pipe(C.withBadRequestError) {
}
export class ConflictException extends S.TaggedErrorClass()("ConflictException", { message: S.String, resourceId: S.String, resourceType: S.String }).pipe(C.withConflictError) {
}
export class ServiceQuotaExceededException extends S.TaggedErrorClass()("ServiceQuotaExceededException", {
    message: S.String,
    resourceId: S.String,
    resourceType: S.String,
    serviceCode: S.String,
    quotaCode: S.String,
}).pipe(C.withQuotaError) {
}
export class ThrottlingException extends S.TaggedErrorClass()("ThrottlingException", {
    message: S.String,
    serviceCode: S.optional(S.String),
    quotaCode: S.optional(S.String),
    retryAfterSeconds: S.optional(S.Number).pipe(T.HttpHeader("Retry-After")),
}).pipe(C.withThrottlingError) {
}
/**
 * Displays the tags associated with a pipe.
 */
export const listTagsForResource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: ListTagsForResourceRequest,
    output: ListTagsForResourceResponse,
    errors: [InternalException, NotFoundException, ValidationException],
}));
/**
 * Assigns one or more tags (key-value pairs) to the specified pipe. 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 pipe that already has tags. If
 * you specify a new tag key, this tag is appended to the list of tags associated with the
 * pipe. If you specify a tag key that is already associated with the pipe, the new tag value
 * that you specify replaces the previous value for that tag.
 *
 * You can associate as many as 50 tags with a pipe.
 */
export const tagResource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: TagResourceRequest,
    output: TagResourceResponse,
    errors: [InternalException, NotFoundException, ValidationException],
}));
/**
 * Removes one or more tags from the specified pipes.
 */
export const untagResource = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UntagResourceRequest,
    output: UntagResourceResponse,
    errors: [InternalException, NotFoundException, ValidationException],
}));
/**
 * Create a pipe. Amazon EventBridge Pipes connect event sources to targets and reduces
 * the need for specialized knowledge and integration code.
 */
export const createPipe = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: CreatePipeRequest,
    output: CreatePipeResponse,
    errors: [
        ConflictException,
        InternalException,
        NotFoundException,
        ServiceQuotaExceededException,
        ThrottlingException,
        ValidationException,
    ],
}));
/**
 * Get the information about an existing pipe. For more information about pipes, see Amazon EventBridge Pipes in the Amazon EventBridge User Guide.
 */
export const describePipe = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DescribePipeRequest,
    output: DescribePipeResponse,
    errors: [
        InternalException,
        NotFoundException,
        ThrottlingException,
        ValidationException,
    ],
}));
/**
 * Update an existing pipe. When you call `UpdatePipe`, EventBridge only the
 * updates fields you have specified in the request; the rest remain unchanged. The exception
 * to this is if you modify any Amazon Web Services-service specific fields in the
 * `SourceParameters`, `EnrichmentParameters`, or
 * `TargetParameters` objects. For example,
 * `DynamoDBStreamParameters` or `EventBridgeEventBusParameters`.
 * EventBridge updates the fields in these objects atomically as one and overrides existing
 * values. This is by design, and means that if you don't specify an optional field in one of
 * these `Parameters` objects, EventBridge sets that field to its system-default
 * value during the update.
 *
 * For more information about pipes, see
 * Amazon EventBridge Pipes in the Amazon EventBridge User Guide.
 */
export const updatePipe = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: UpdatePipeRequest,
    output: UpdatePipeResponse,
    errors: [
        ConflictException,
        InternalException,
        NotFoundException,
        ThrottlingException,
        ValidationException,
    ],
}));
/**
 * Delete an existing pipe. For more information about pipes, see Amazon EventBridge Pipes in the Amazon EventBridge User Guide.
 */
export const deletePipe = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: DeletePipeRequest,
    output: DeletePipeResponse,
    errors: [
        ConflictException,
        InternalException,
        NotFoundException,
        ThrottlingException,
        ValidationException,
    ],
}));
/**
 * Get the pipes associated with this account. For more information about pipes, see Amazon EventBridge Pipes in the Amazon EventBridge User Guide.
 */
export const listPipes = /*@__PURE__*/ /*#__PURE__*/ API.makePaginated(() => ({
    input: ListPipesRequest,
    output: ListPipesResponse,
    errors: [InternalException, ThrottlingException, ValidationException],
    pagination: {
        inputToken: "NextToken",
        outputToken: "NextToken",
        items: "Pipes",
        pageSize: "Limit",
    },
}));
/**
 * Start an existing pipe.
 */
export const startPipe = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: StartPipeRequest,
    output: StartPipeResponse,
    errors: [
        ConflictException,
        InternalException,
        NotFoundException,
        ThrottlingException,
        ValidationException,
    ],
}));
/**
 * Stop an existing pipe.
 */
export const stopPipe = /*@__PURE__*/ /*#__PURE__*/ API.make(() => ({
    input: StopPipeRequest,
    output: StopPipeResponse,
    errors: [
        ConflictException,
        InternalException,
        NotFoundException,
        ThrottlingException,
        ValidationException,
    ],
}));
//# sourceMappingURL=pipes.js.map