@aws-sdk/client-apprunner 3.50.0 → 3.51.0

package/dist-types/ts3.4/models/models_0.d.ts

@@ -0,0 +1,882 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+export interface AssociateCustomDomainRequest {
+    
+    ServiceArn: string | undefined;
+    
+    DomainName: string | undefined;
+    
+    EnableWWWSubdomain?: boolean;
+}
+export declare namespace AssociateCustomDomainRequest {
+    
+    const filterSensitiveLog: (obj: AssociateCustomDomainRequest) => any;
+}
+export declare enum CertificateValidationRecordStatus {
+    FAILED = "FAILED",
+    PENDING_VALIDATION = "PENDING_VALIDATION",
+    SUCCESS = "SUCCESS"
+}
+
+export interface CertificateValidationRecord {
+    
+    Name?: string;
+    
+    Type?: string;
+    
+    Value?: string;
+    
+    Status?: CertificateValidationRecordStatus | string;
+}
+export declare namespace CertificateValidationRecord {
+    
+    const filterSensitiveLog: (obj: CertificateValidationRecord) => any;
+}
+export declare enum CustomDomainAssociationStatus {
+    ACTIVE = "ACTIVE",
+    BINDING_CERTIFICATE = "BINDING_CERTIFICATE",
+    CREATE_FAILED = "CREATE_FAILED",
+    CREATING = "CREATING",
+    DELETE_FAILED = "DELETE_FAILED",
+    DELETING = "DELETING",
+    PENDING_CERTIFICATE_DNS_VALIDATION = "PENDING_CERTIFICATE_DNS_VALIDATION"
+}
+
+export interface CustomDomain {
+    
+    DomainName: string | undefined;
+    
+    EnableWWWSubdomain: boolean | undefined;
+    
+    CertificateValidationRecords?: CertificateValidationRecord[];
+    
+    Status: CustomDomainAssociationStatus | string | undefined;
+}
+export declare namespace CustomDomain {
+    
+    const filterSensitiveLog: (obj: CustomDomain) => any;
+}
+export interface AssociateCustomDomainResponse {
+    
+    DNSTarget: string | undefined;
+    
+    ServiceArn: string | undefined;
+    
+    CustomDomain: CustomDomain | undefined;
+}
+export declare namespace AssociateCustomDomainResponse {
+    
+    const filterSensitiveLog: (obj: AssociateCustomDomainResponse) => any;
+}
+
+export interface InternalServiceErrorException extends __SmithyException, $MetadataBearer {
+    name: "InternalServiceErrorException";
+    $fault: "server";
+    Message?: string;
+}
+
+export interface InvalidRequestException extends __SmithyException, $MetadataBearer {
+    name: "InvalidRequestException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface InvalidStateException extends __SmithyException, $MetadataBearer {
+    name: "InvalidStateException";
+    $fault: "client";
+    Message?: string;
+}
+
+export interface Tag {
+    
+    Key?: string;
+    
+    Value?: string;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+export interface CreateAutoScalingConfigurationRequest {
+    
+    AutoScalingConfigurationName: string | undefined;
+    
+    MaxConcurrency?: number;
+    
+    MinSize?: number;
+    
+    MaxSize?: number;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateAutoScalingConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: CreateAutoScalingConfigurationRequest) => any;
+}
+export declare enum AutoScalingConfigurationStatus {
+    ACTIVE = "ACTIVE",
+    INACTIVE = "INACTIVE"
+}
+
+export interface AutoScalingConfiguration {
+    
+    AutoScalingConfigurationArn?: string;
+    
+    AutoScalingConfigurationName?: string;
+    
+    AutoScalingConfigurationRevision?: number;
+    
+    Latest?: boolean;
+    
+    Status?: AutoScalingConfigurationStatus | string;
+    
+    MaxConcurrency?: number;
+    
+    MinSize?: number;
+    
+    MaxSize?: number;
+    
+    CreatedAt?: Date;
+    
+    DeletedAt?: Date;
+}
+export declare namespace AutoScalingConfiguration {
+    
+    const filterSensitiveLog: (obj: AutoScalingConfiguration) => any;
+}
+export interface CreateAutoScalingConfigurationResponse {
+    
+    AutoScalingConfiguration: AutoScalingConfiguration | undefined;
+}
+export declare namespace CreateAutoScalingConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: CreateAutoScalingConfigurationResponse) => any;
+}
+
+export interface ServiceQuotaExceededException extends __SmithyException, $MetadataBearer {
+    name: "ServiceQuotaExceededException";
+    $fault: "client";
+    Message?: string;
+}
+export declare enum ProviderType {
+    GITHUB = "GITHUB"
+}
+export interface CreateConnectionRequest {
+    
+    ConnectionName: string | undefined;
+    
+    ProviderType: ProviderType | string | undefined;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateConnectionRequest {
+    
+    const filterSensitiveLog: (obj: CreateConnectionRequest) => any;
+}
+export declare enum ConnectionStatus {
+    AVAILABLE = "AVAILABLE",
+    DELETED = "DELETED",
+    ERROR = "ERROR",
+    PENDING_HANDSHAKE = "PENDING_HANDSHAKE"
+}
+
+export interface Connection {
+    
+    ConnectionName?: string;
+    
+    ConnectionArn?: string;
+    
+    ProviderType?: ProviderType | string;
+    
+    Status?: ConnectionStatus | string;
+    
+    CreatedAt?: Date;
+}
+export declare namespace Connection {
+    
+    const filterSensitiveLog: (obj: Connection) => any;
+}
+export interface CreateConnectionResponse {
+    
+    Connection: Connection | undefined;
+}
+export declare namespace CreateConnectionResponse {
+    
+    const filterSensitiveLog: (obj: CreateConnectionResponse) => any;
+}
+
+export interface EncryptionConfiguration {
+    
+    KmsKey: string | undefined;
+}
+export declare namespace EncryptionConfiguration {
+    
+    const filterSensitiveLog: (obj: EncryptionConfiguration) => any;
+}
+export declare enum HealthCheckProtocol {
+    HTTP = "HTTP",
+    TCP = "TCP"
+}
+
+export interface HealthCheckConfiguration {
+    
+    Protocol?: HealthCheckProtocol | string;
+    
+    Path?: string;
+    
+    Interval?: number;
+    
+    Timeout?: number;
+    
+    HealthyThreshold?: number;
+    
+    UnhealthyThreshold?: number;
+}
+export declare namespace HealthCheckConfiguration {
+    
+    const filterSensitiveLog: (obj: HealthCheckConfiguration) => any;
+}
+
+export interface InstanceConfiguration {
+    
+    Cpu?: string;
+    
+    Memory?: string;
+    
+    InstanceRoleArn?: string;
+}
+export declare namespace InstanceConfiguration {
+    
+    const filterSensitiveLog: (obj: InstanceConfiguration) => any;
+}
+
+export interface AuthenticationConfiguration {
+    
+    ConnectionArn?: string;
+    
+    AccessRoleArn?: string;
+}
+export declare namespace AuthenticationConfiguration {
+    
+    const filterSensitiveLog: (obj: AuthenticationConfiguration) => any;
+}
+export declare enum Runtime {
+    NODEJS_12 = "NODEJS_12",
+    PYTHON_3 = "PYTHON_3"
+}
+
+export interface CodeConfigurationValues {
+    
+    Runtime: Runtime | string | undefined;
+    
+    BuildCommand?: string;
+    
+    StartCommand?: string;
+    
+    Port?: string;
+    
+    RuntimeEnvironmentVariables?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CodeConfigurationValues {
+    
+    const filterSensitiveLog: (obj: CodeConfigurationValues) => any;
+}
+export declare enum ConfigurationSource {
+    API = "API",
+    REPOSITORY = "REPOSITORY"
+}
+
+export interface CodeConfiguration {
+    
+    ConfigurationSource: ConfigurationSource | string | undefined;
+    
+    CodeConfigurationValues?: CodeConfigurationValues;
+}
+export declare namespace CodeConfiguration {
+    
+    const filterSensitiveLog: (obj: CodeConfiguration) => any;
+}
+export declare enum SourceCodeVersionType {
+    BRANCH = "BRANCH"
+}
+
+export interface SourceCodeVersion {
+    
+    Type: SourceCodeVersionType | string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace SourceCodeVersion {
+    
+    const filterSensitiveLog: (obj: SourceCodeVersion) => any;
+}
+
+export interface CodeRepository {
+    
+    RepositoryUrl: string | undefined;
+    
+    SourceCodeVersion: SourceCodeVersion | undefined;
+    
+    CodeConfiguration?: CodeConfiguration;
+}
+export declare namespace CodeRepository {
+    
+    const filterSensitiveLog: (obj: CodeRepository) => any;
+}
+
+export interface ImageConfiguration {
+    
+    RuntimeEnvironmentVariables?: {
+        [key: string]: string;
+    };
+    
+    StartCommand?: string;
+    
+    Port?: string;
+}
+export declare namespace ImageConfiguration {
+    
+    const filterSensitiveLog: (obj: ImageConfiguration) => any;
+}
+export declare enum ImageRepositoryType {
+    ECR = "ECR",
+    ECR_PUBLIC = "ECR_PUBLIC"
+}
+
+export interface ImageRepository {
+    
+    ImageIdentifier: string | undefined;
+    
+    ImageConfiguration?: ImageConfiguration;
+    
+    ImageRepositoryType: ImageRepositoryType | string | undefined;
+}
+export declare namespace ImageRepository {
+    
+    const filterSensitiveLog: (obj: ImageRepository) => any;
+}
+
+export interface SourceConfiguration {
+    
+    CodeRepository?: CodeRepository;
+    
+    ImageRepository?: ImageRepository;
+    
+    AutoDeploymentsEnabled?: boolean;
+    
+    AuthenticationConfiguration?: AuthenticationConfiguration;
+}
+export declare namespace SourceConfiguration {
+    
+    const filterSensitiveLog: (obj: SourceConfiguration) => any;
+}
+export interface CreateServiceRequest {
+    
+    ServiceName: string | undefined;
+    
+    SourceConfiguration: SourceConfiguration | undefined;
+    
+    InstanceConfiguration?: InstanceConfiguration;
+    
+    Tags?: Tag[];
+    
+    EncryptionConfiguration?: EncryptionConfiguration;
+    
+    HealthCheckConfiguration?: HealthCheckConfiguration;
+    
+    AutoScalingConfigurationArn?: string;
+}
+export declare namespace CreateServiceRequest {
+    
+    const filterSensitiveLog: (obj: CreateServiceRequest) => any;
+}
+
+export interface AutoScalingConfigurationSummary {
+    
+    AutoScalingConfigurationArn?: string;
+    
+    AutoScalingConfigurationName?: string;
+    
+    AutoScalingConfigurationRevision?: number;
+}
+export declare namespace AutoScalingConfigurationSummary {
+    
+    const filterSensitiveLog: (obj: AutoScalingConfigurationSummary) => any;
+}
+export declare enum ServiceStatus {
+    CREATE_FAILED = "CREATE_FAILED",
+    DELETED = "DELETED",
+    DELETE_FAILED = "DELETE_FAILED",
+    OPERATION_IN_PROGRESS = "OPERATION_IN_PROGRESS",
+    PAUSED = "PAUSED",
+    RUNNING = "RUNNING"
+}
+
+export interface Service {
+    
+    ServiceName: string | undefined;
+    
+    ServiceId: string | undefined;
+    
+    ServiceArn: string | undefined;
+    
+    ServiceUrl: string | undefined;
+    
+    CreatedAt: Date | undefined;
+    
+    UpdatedAt: Date | undefined;
+    
+    DeletedAt?: Date;
+    
+    Status: ServiceStatus | string | undefined;
+    
+    SourceConfiguration: SourceConfiguration | undefined;
+    
+    InstanceConfiguration: InstanceConfiguration | undefined;
+    
+    EncryptionConfiguration?: EncryptionConfiguration;
+    
+    HealthCheckConfiguration?: HealthCheckConfiguration;
+    
+    AutoScalingConfigurationSummary: AutoScalingConfigurationSummary | undefined;
+}
+export declare namespace Service {
+    
+    const filterSensitiveLog: (obj: Service) => any;
+}
+export interface CreateServiceResponse {
+    
+    Service: Service | undefined;
+    
+    OperationId: string | undefined;
+}
+export declare namespace CreateServiceResponse {
+    
+    const filterSensitiveLog: (obj: CreateServiceResponse) => any;
+}
+export interface DeleteAutoScalingConfigurationRequest {
+    
+    AutoScalingConfigurationArn: string | undefined;
+}
+export declare namespace DeleteAutoScalingConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteAutoScalingConfigurationRequest) => any;
+}
+export interface DeleteAutoScalingConfigurationResponse {
+    
+    AutoScalingConfiguration: AutoScalingConfiguration | undefined;
+}
+export declare namespace DeleteAutoScalingConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: DeleteAutoScalingConfigurationResponse) => any;
+}
+
+export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    Message?: string;
+}
+export interface DeleteConnectionRequest {
+    
+    ConnectionArn: string | undefined;
+}
+export declare namespace DeleteConnectionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteConnectionRequest) => any;
+}
+export interface DeleteConnectionResponse {
+    
+    Connection?: Connection;
+}
+export declare namespace DeleteConnectionResponse {
+    
+    const filterSensitiveLog: (obj: DeleteConnectionResponse) => any;
+}
+export interface DeleteServiceRequest {
+    
+    ServiceArn: string | undefined;
+}
+export declare namespace DeleteServiceRequest {
+    
+    const filterSensitiveLog: (obj: DeleteServiceRequest) => any;
+}
+export interface DeleteServiceResponse {
+    
+    Service: Service | undefined;
+    
+    OperationId: string | undefined;
+}
+export declare namespace DeleteServiceResponse {
+    
+    const filterSensitiveLog: (obj: DeleteServiceResponse) => any;
+}
+export interface DescribeAutoScalingConfigurationRequest {
+    
+    AutoScalingConfigurationArn: string | undefined;
+}
+export declare namespace DescribeAutoScalingConfigurationRequest {
+    
+    const filterSensitiveLog: (obj: DescribeAutoScalingConfigurationRequest) => any;
+}
+export interface DescribeAutoScalingConfigurationResponse {
+    
+    AutoScalingConfiguration: AutoScalingConfiguration | undefined;
+}
+export declare namespace DescribeAutoScalingConfigurationResponse {
+    
+    const filterSensitiveLog: (obj: DescribeAutoScalingConfigurationResponse) => any;
+}
+export interface DescribeCustomDomainsRequest {
+    
+    ServiceArn: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace DescribeCustomDomainsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeCustomDomainsRequest) => any;
+}
+export interface DescribeCustomDomainsResponse {
+    
+    DNSTarget: string | undefined;
+    
+    ServiceArn: string | undefined;
+    
+    CustomDomains: CustomDomain[] | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace DescribeCustomDomainsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeCustomDomainsResponse) => any;
+}
+export interface DescribeServiceRequest {
+    
+    ServiceArn: string | undefined;
+}
+export declare namespace DescribeServiceRequest {
+    
+    const filterSensitiveLog: (obj: DescribeServiceRequest) => any;
+}
+export interface DescribeServiceResponse {
+    
+    Service: Service | undefined;
+}
+export declare namespace DescribeServiceResponse {
+    
+    const filterSensitiveLog: (obj: DescribeServiceResponse) => any;
+}
+export interface DisassociateCustomDomainRequest {
+    
+    ServiceArn: string | undefined;
+    
+    DomainName: string | undefined;
+}
+export declare namespace DisassociateCustomDomainRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateCustomDomainRequest) => any;
+}
+export interface DisassociateCustomDomainResponse {
+    
+    DNSTarget: string | undefined;
+    
+    ServiceArn: string | undefined;
+    
+    CustomDomain: CustomDomain | undefined;
+}
+export declare namespace DisassociateCustomDomainResponse {
+    
+    const filterSensitiveLog: (obj: DisassociateCustomDomainResponse) => any;
+}
+export interface ListAutoScalingConfigurationsRequest {
+    
+    AutoScalingConfigurationName?: string;
+    
+    LatestOnly?: boolean;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListAutoScalingConfigurationsRequest {
+    
+    const filterSensitiveLog: (obj: ListAutoScalingConfigurationsRequest) => any;
+}
+export interface ListAutoScalingConfigurationsResponse {
+    
+    AutoScalingConfigurationSummaryList: AutoScalingConfigurationSummary[] | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace ListAutoScalingConfigurationsResponse {
+    
+    const filterSensitiveLog: (obj: ListAutoScalingConfigurationsResponse) => any;
+}
+export interface ListConnectionsRequest {
+    
+    ConnectionName?: string;
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace ListConnectionsRequest {
+    
+    const filterSensitiveLog: (obj: ListConnectionsRequest) => any;
+}
+
+export interface ConnectionSummary {
+    
+    ConnectionName?: string;
+    
+    ConnectionArn?: string;
+    
+    ProviderType?: ProviderType | string;
+    
+    Status?: ConnectionStatus | string;
+    
+    CreatedAt?: Date;
+}
+export declare namespace ConnectionSummary {
+    
+    const filterSensitiveLog: (obj: ConnectionSummary) => any;
+}
+export interface ListConnectionsResponse {
+    
+    ConnectionSummaryList: ConnectionSummary[] | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace ListConnectionsResponse {
+    
+    const filterSensitiveLog: (obj: ListConnectionsResponse) => any;
+}
+export interface ListOperationsRequest {
+    
+    ServiceArn: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListOperationsRequest {
+    
+    const filterSensitiveLog: (obj: ListOperationsRequest) => any;
+}
+export declare enum OperationStatus {
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    PENDING = "PENDING",
+    ROLLBACK_FAILED = "ROLLBACK_FAILED",
+    ROLLBACK_IN_PROGRESS = "ROLLBACK_IN_PROGRESS",
+    ROLLBACK_SUCCEEDED = "ROLLBACK_SUCCEEDED",
+    SUCCEEDED = "SUCCEEDED"
+}
+export declare enum OperationType {
+    CREATE_SERVICE = "CREATE_SERVICE",
+    DELETE_SERVICE = "DELETE_SERVICE",
+    PAUSE_SERVICE = "PAUSE_SERVICE",
+    RESUME_SERVICE = "RESUME_SERVICE",
+    START_DEPLOYMENT = "START_DEPLOYMENT"
+}
+
+export interface OperationSummary {
+    
+    Id?: string;
+    
+    Type?: OperationType | string;
+    
+    Status?: OperationStatus | string;
+    
+    TargetArn?: string;
+    
+    StartedAt?: Date;
+    
+    EndedAt?: Date;
+    
+    UpdatedAt?: Date;
+}
+export declare namespace OperationSummary {
+    
+    const filterSensitiveLog: (obj: OperationSummary) => any;
+}
+export interface ListOperationsResponse {
+    
+    OperationSummaryList?: OperationSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListOperationsResponse {
+    
+    const filterSensitiveLog: (obj: ListOperationsResponse) => any;
+}
+export interface ListServicesRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListServicesRequest {
+    
+    const filterSensitiveLog: (obj: ListServicesRequest) => any;
+}
+
+export interface ServiceSummary {
+    
+    ServiceName?: string;
+    
+    ServiceId?: string;
+    
+    ServiceArn?: string;
+    
+    ServiceUrl?: string;
+    
+    CreatedAt?: Date;
+    
+    UpdatedAt?: Date;
+    
+    Status?: ServiceStatus | string;
+}
+export declare namespace ServiceSummary {
+    
+    const filterSensitiveLog: (obj: ServiceSummary) => any;
+}
+export interface ListServicesResponse {
+    
+    ServiceSummaryList: ServiceSummary[] | undefined;
+    
+    NextToken?: string;
+}
+export declare namespace ListServicesResponse {
+    
+    const filterSensitiveLog: (obj: ListServicesResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    
+    ResourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    
+    Tags?: Tag[];
+}
+export declare namespace ListTagsForResourceResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+export interface PauseServiceRequest {
+    
+    ServiceArn: string | undefined;
+}
+export declare namespace PauseServiceRequest {
+    
+    const filterSensitiveLog: (obj: PauseServiceRequest) => any;
+}
+export interface PauseServiceResponse {
+    
+    Service: Service | undefined;
+    
+    OperationId?: string;
+}
+export declare namespace PauseServiceResponse {
+    
+    const filterSensitiveLog: (obj: PauseServiceResponse) => any;
+}
+export interface ResumeServiceRequest {
+    
+    ServiceArn: string | undefined;
+}
+export declare namespace ResumeServiceRequest {
+    
+    const filterSensitiveLog: (obj: ResumeServiceRequest) => any;
+}
+export interface ResumeServiceResponse {
+    
+    Service: Service | undefined;
+    
+    OperationId?: string;
+}
+export declare namespace ResumeServiceResponse {
+    
+    const filterSensitiveLog: (obj: ResumeServiceResponse) => any;
+}
+export interface StartDeploymentRequest {
+    
+    ServiceArn: string | undefined;
+}
+export declare namespace StartDeploymentRequest {
+    
+    const filterSensitiveLog: (obj: StartDeploymentRequest) => any;
+}
+export interface StartDeploymentResponse {
+    
+    OperationId: string | undefined;
+}
+export declare namespace StartDeploymentResponse {
+    
+    const filterSensitiveLog: (obj: StartDeploymentResponse) => any;
+}
+export interface TagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    Tags: Tag[] | undefined;
+}
+export declare namespace TagResourceRequest {
+    
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UntagResourceRequest {
+    
+    ResourceArn: string | undefined;
+    
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}
+export interface UpdateServiceRequest {
+    
+    ServiceArn: string | undefined;
+    
+    SourceConfiguration?: SourceConfiguration;
+    
+    InstanceConfiguration?: InstanceConfiguration;
+    
+    AutoScalingConfigurationArn?: string;
+    
+    HealthCheckConfiguration?: HealthCheckConfiguration;
+}
+export declare namespace UpdateServiceRequest {
+    
+    const filterSensitiveLog: (obj: UpdateServiceRequest) => any;
+}
+export interface UpdateServiceResponse {
+    
+    Service: Service | undefined;
+    
+    OperationId: string | undefined;
+}
+export declare namespace UpdateServiceResponse {
+    
+    const filterSensitiveLog: (obj: UpdateServiceResponse) => any;
+}