@aws-sdk/client-servicediscovery 3.50.0 → 3.53.0

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

@@ -0,0 +1,1189 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { ServiceDiscoveryServiceException as __BaseException } from "./ServiceDiscoveryServiceException";
+
+export interface Tag {
+    
+    Key: string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+export interface CreateHttpNamespaceRequest {
+    
+    Name: string | undefined;
+    
+    CreatorRequestId?: string;
+    
+    Description?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateHttpNamespaceRequest {
+    
+    const filterSensitiveLog: (obj: CreateHttpNamespaceRequest) => any;
+}
+export interface CreateHttpNamespaceResponse {
+    
+    OperationId?: string;
+}
+export declare namespace CreateHttpNamespaceResponse {
+    
+    const filterSensitiveLog: (obj: CreateHttpNamespaceResponse) => any;
+}
+
+export declare class DuplicateRequest extends __BaseException {
+    readonly name: "DuplicateRequest";
+    readonly $fault: "client";
+    Message?: string;
+    
+    DuplicateOperationId?: string;
+    
+    constructor(opts: __ExceptionOptionType<DuplicateRequest, __BaseException>);
+}
+
+export declare class InvalidInput extends __BaseException {
+    readonly name: "InvalidInput";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidInput, __BaseException>);
+}
+
+export declare class NamespaceAlreadyExists extends __BaseException {
+    readonly name: "NamespaceAlreadyExists";
+    readonly $fault: "client";
+    Message?: string;
+    
+    CreatorRequestId?: string;
+    
+    NamespaceId?: string;
+    
+    constructor(opts: __ExceptionOptionType<NamespaceAlreadyExists, __BaseException>);
+}
+
+export declare class ResourceLimitExceeded extends __BaseException {
+    readonly name: "ResourceLimitExceeded";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceLimitExceeded, __BaseException>);
+}
+
+export declare class TooManyTagsException extends __BaseException {
+    readonly name: "TooManyTagsException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    ResourceName?: string;
+    
+    constructor(opts: __ExceptionOptionType<TooManyTagsException, __BaseException>);
+}
+
+export interface SOA {
+    
+    TTL: number | undefined;
+}
+export declare namespace SOA {
+    
+    const filterSensitiveLog: (obj: SOA) => any;
+}
+
+export interface PrivateDnsPropertiesMutable {
+    
+    SOA: SOA | undefined;
+}
+export declare namespace PrivateDnsPropertiesMutable {
+    
+    const filterSensitiveLog: (obj: PrivateDnsPropertiesMutable) => any;
+}
+
+export interface PrivateDnsNamespaceProperties {
+    
+    DnsProperties: PrivateDnsPropertiesMutable | undefined;
+}
+export declare namespace PrivateDnsNamespaceProperties {
+    
+    const filterSensitiveLog: (obj: PrivateDnsNamespaceProperties) => any;
+}
+export interface CreatePrivateDnsNamespaceRequest {
+    
+    Name: string | undefined;
+    
+    CreatorRequestId?: string;
+    
+    Description?: string;
+    
+    Vpc: string | undefined;
+    
+    Tags?: Tag[];
+    
+    Properties?: PrivateDnsNamespaceProperties;
+}
+export declare namespace CreatePrivateDnsNamespaceRequest {
+    
+    const filterSensitiveLog: (obj: CreatePrivateDnsNamespaceRequest) => any;
+}
+export interface CreatePrivateDnsNamespaceResponse {
+    
+    OperationId?: string;
+}
+export declare namespace CreatePrivateDnsNamespaceResponse {
+    
+    const filterSensitiveLog: (obj: CreatePrivateDnsNamespaceResponse) => any;
+}
+
+export interface PublicDnsPropertiesMutable {
+    
+    SOA: SOA | undefined;
+}
+export declare namespace PublicDnsPropertiesMutable {
+    
+    const filterSensitiveLog: (obj: PublicDnsPropertiesMutable) => any;
+}
+
+export interface PublicDnsNamespaceProperties {
+    
+    DnsProperties: PublicDnsPropertiesMutable | undefined;
+}
+export declare namespace PublicDnsNamespaceProperties {
+    
+    const filterSensitiveLog: (obj: PublicDnsNamespaceProperties) => any;
+}
+export interface CreatePublicDnsNamespaceRequest {
+    
+    Name: string | undefined;
+    
+    CreatorRequestId?: string;
+    
+    Description?: string;
+    
+    Tags?: Tag[];
+    
+    Properties?: PublicDnsNamespaceProperties;
+}
+export declare namespace CreatePublicDnsNamespaceRequest {
+    
+    const filterSensitiveLog: (obj: CreatePublicDnsNamespaceRequest) => any;
+}
+export interface CreatePublicDnsNamespaceResponse {
+    
+    OperationId?: string;
+}
+export declare namespace CreatePublicDnsNamespaceResponse {
+    
+    const filterSensitiveLog: (obj: CreatePublicDnsNamespaceResponse) => any;
+}
+export declare enum RecordType {
+    A = "A",
+    AAAA = "AAAA",
+    CNAME = "CNAME",
+    SRV = "SRV"
+}
+
+export interface DnsRecord {
+    
+    Type: RecordType | string | undefined;
+    
+    TTL: number | undefined;
+}
+export declare namespace DnsRecord {
+    
+    const filterSensitiveLog: (obj: DnsRecord) => any;
+}
+export declare enum RoutingPolicy {
+    MULTIVALUE = "MULTIVALUE",
+    WEIGHTED = "WEIGHTED"
+}
+
+export interface DnsConfig {
+    
+    NamespaceId?: string;
+    
+    RoutingPolicy?: RoutingPolicy | string;
+    
+    DnsRecords: DnsRecord[] | undefined;
+}
+export declare namespace DnsConfig {
+    
+    const filterSensitiveLog: (obj: DnsConfig) => any;
+}
+export declare enum HealthCheckType {
+    HTTP = "HTTP",
+    HTTPS = "HTTPS",
+    TCP = "TCP"
+}
+
+export interface HealthCheckConfig {
+    
+    Type: HealthCheckType | string | undefined;
+    
+    ResourcePath?: string;
+    
+    FailureThreshold?: number;
+}
+export declare namespace HealthCheckConfig {
+    
+    const filterSensitiveLog: (obj: HealthCheckConfig) => any;
+}
+
+export interface HealthCheckCustomConfig {
+    
+    FailureThreshold?: number;
+}
+export declare namespace HealthCheckCustomConfig {
+    
+    const filterSensitiveLog: (obj: HealthCheckCustomConfig) => any;
+}
+export declare enum ServiceTypeOption {
+    HTTP = "HTTP"
+}
+export interface CreateServiceRequest {
+    
+    Name: string | undefined;
+    
+    NamespaceId?: string;
+    
+    CreatorRequestId?: string;
+    
+    Description?: string;
+    
+    DnsConfig?: DnsConfig;
+    
+    HealthCheckConfig?: HealthCheckConfig;
+    
+    HealthCheckCustomConfig?: HealthCheckCustomConfig;
+    
+    Tags?: Tag[];
+    
+    Type?: ServiceTypeOption | string;
+}
+export declare namespace CreateServiceRequest {
+    
+    const filterSensitiveLog: (obj: CreateServiceRequest) => any;
+}
+export declare enum ServiceType {
+    DNS = "DNS",
+    DNS_HTTP = "DNS_HTTP",
+    HTTP = "HTTP"
+}
+
+export interface Service {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Name?: string;
+    
+    NamespaceId?: string;
+    
+    Description?: string;
+    
+    InstanceCount?: number;
+    
+    DnsConfig?: DnsConfig;
+    
+    Type?: ServiceType | string;
+    
+    HealthCheckConfig?: HealthCheckConfig;
+    
+    HealthCheckCustomConfig?: HealthCheckCustomConfig;
+    
+    CreateDate?: Date;
+    
+    CreatorRequestId?: string;
+}
+export declare namespace Service {
+    
+    const filterSensitiveLog: (obj: Service) => any;
+}
+export interface CreateServiceResponse {
+    
+    Service?: Service;
+}
+export declare namespace CreateServiceResponse {
+    
+    const filterSensitiveLog: (obj: CreateServiceResponse) => any;
+}
+
+export declare class NamespaceNotFound extends __BaseException {
+    readonly name: "NamespaceNotFound";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<NamespaceNotFound, __BaseException>);
+}
+
+export declare class ServiceAlreadyExists extends __BaseException {
+    readonly name: "ServiceAlreadyExists";
+    readonly $fault: "client";
+    Message?: string;
+    
+    CreatorRequestId?: string;
+    
+    ServiceId?: string;
+    
+    constructor(opts: __ExceptionOptionType<ServiceAlreadyExists, __BaseException>);
+}
+
+export declare class CustomHealthNotFound extends __BaseException {
+    readonly name: "CustomHealthNotFound";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<CustomHealthNotFound, __BaseException>);
+}
+export declare enum CustomHealthStatus {
+    HEALTHY = "HEALTHY",
+    UNHEALTHY = "UNHEALTHY"
+}
+export interface DeleteNamespaceRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace DeleteNamespaceRequest {
+    
+    const filterSensitiveLog: (obj: DeleteNamespaceRequest) => any;
+}
+export interface DeleteNamespaceResponse {
+    
+    OperationId?: string;
+}
+export declare namespace DeleteNamespaceResponse {
+    
+    const filterSensitiveLog: (obj: DeleteNamespaceResponse) => any;
+}
+
+export declare class ResourceInUse extends __BaseException {
+    readonly name: "ResourceInUse";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceInUse, __BaseException>);
+}
+export interface DeleteServiceRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace DeleteServiceRequest {
+    
+    const filterSensitiveLog: (obj: DeleteServiceRequest) => any;
+}
+export interface DeleteServiceResponse {
+}
+export declare namespace DeleteServiceResponse {
+    
+    const filterSensitiveLog: (obj: DeleteServiceResponse) => any;
+}
+
+export declare class ServiceNotFound extends __BaseException {
+    readonly name: "ServiceNotFound";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ServiceNotFound, __BaseException>);
+}
+export interface DeregisterInstanceRequest {
+    
+    ServiceId: string | undefined;
+    
+    InstanceId: string | undefined;
+}
+export declare namespace DeregisterInstanceRequest {
+    
+    const filterSensitiveLog: (obj: DeregisterInstanceRequest) => any;
+}
+export interface DeregisterInstanceResponse {
+    
+    OperationId?: string;
+}
+export declare namespace DeregisterInstanceResponse {
+    
+    const filterSensitiveLog: (obj: DeregisterInstanceResponse) => any;
+}
+
+export declare class InstanceNotFound extends __BaseException {
+    readonly name: "InstanceNotFound";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<InstanceNotFound, __BaseException>);
+}
+export declare enum HealthStatusFilter {
+    ALL = "ALL",
+    HEALTHY = "HEALTHY",
+    HEALTHY_OR_ELSE_ALL = "HEALTHY_OR_ELSE_ALL",
+    UNHEALTHY = "UNHEALTHY"
+}
+export interface DiscoverInstancesRequest {
+    
+    NamespaceName: string | undefined;
+    
+    ServiceName: string | undefined;
+    
+    MaxResults?: number;
+    
+    QueryParameters?: {
+        [key: string]: string;
+    };
+    
+    OptionalParameters?: {
+        [key: string]: string;
+    };
+    
+    HealthStatus?: HealthStatusFilter | string;
+}
+export declare namespace DiscoverInstancesRequest {
+    
+    const filterSensitiveLog: (obj: DiscoverInstancesRequest) => any;
+}
+export declare enum HealthStatus {
+    HEALTHY = "HEALTHY",
+    UNHEALTHY = "UNHEALTHY",
+    UNKNOWN = "UNKNOWN"
+}
+
+export interface HttpInstanceSummary {
+    
+    InstanceId?: string;
+    
+    NamespaceName?: string;
+    
+    ServiceName?: string;
+    
+    HealthStatus?: HealthStatus | string;
+    
+    Attributes?: {
+        [key: string]: string;
+    };
+}
+export declare namespace HttpInstanceSummary {
+    
+    const filterSensitiveLog: (obj: HttpInstanceSummary) => any;
+}
+export interface DiscoverInstancesResponse {
+    
+    Instances?: HttpInstanceSummary[];
+}
+export declare namespace DiscoverInstancesResponse {
+    
+    const filterSensitiveLog: (obj: DiscoverInstancesResponse) => any;
+}
+
+export declare class RequestLimitExceeded extends __BaseException {
+    readonly name: "RequestLimitExceeded";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<RequestLimitExceeded, __BaseException>);
+}
+
+export interface DnsConfigChange {
+    
+    DnsRecords: DnsRecord[] | undefined;
+}
+export declare namespace DnsConfigChange {
+    
+    const filterSensitiveLog: (obj: DnsConfigChange) => any;
+}
+
+export interface DnsProperties {
+    
+    HostedZoneId?: string;
+    
+    SOA?: SOA;
+}
+export declare namespace DnsProperties {
+    
+    const filterSensitiveLog: (obj: DnsProperties) => any;
+}
+export declare enum FilterCondition {
+    BETWEEN = "BETWEEN",
+    EQ = "EQ",
+    IN = "IN"
+}
+export interface GetInstanceRequest {
+    
+    ServiceId: string | undefined;
+    
+    InstanceId: string | undefined;
+}
+export declare namespace GetInstanceRequest {
+    
+    const filterSensitiveLog: (obj: GetInstanceRequest) => any;
+}
+
+export interface Instance {
+    
+    Id: string | undefined;
+    
+    CreatorRequestId?: string;
+    
+    Attributes?: {
+        [key: string]: string;
+    };
+}
+export declare namespace Instance {
+    
+    const filterSensitiveLog: (obj: Instance) => any;
+}
+export interface GetInstanceResponse {
+    
+    Instance?: Instance;
+}
+export declare namespace GetInstanceResponse {
+    
+    const filterSensitiveLog: (obj: GetInstanceResponse) => any;
+}
+export interface GetInstancesHealthStatusRequest {
+    
+    ServiceId: string | undefined;
+    
+    Instances?: string[];
+    
+    MaxResults?: number;
+    
+    NextToken?: string;
+}
+export declare namespace GetInstancesHealthStatusRequest {
+    
+    const filterSensitiveLog: (obj: GetInstancesHealthStatusRequest) => any;
+}
+export interface GetInstancesHealthStatusResponse {
+    
+    Status?: {
+        [key: string]: HealthStatus | string;
+    };
+    
+    NextToken?: string;
+}
+export declare namespace GetInstancesHealthStatusResponse {
+    
+    const filterSensitiveLog: (obj: GetInstancesHealthStatusResponse) => any;
+}
+export interface GetNamespaceRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace GetNamespaceRequest {
+    
+    const filterSensitiveLog: (obj: GetNamespaceRequest) => any;
+}
+
+export interface HttpProperties {
+    
+    HttpName?: string;
+}
+export declare namespace HttpProperties {
+    
+    const filterSensitiveLog: (obj: HttpProperties) => any;
+}
+
+export interface NamespaceProperties {
+    
+    DnsProperties?: DnsProperties;
+    
+    HttpProperties?: HttpProperties;
+}
+export declare namespace NamespaceProperties {
+    
+    const filterSensitiveLog: (obj: NamespaceProperties) => any;
+}
+export declare enum NamespaceType {
+    DNS_PRIVATE = "DNS_PRIVATE",
+    DNS_PUBLIC = "DNS_PUBLIC",
+    HTTP = "HTTP"
+}
+
+export interface Namespace {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Name?: string;
+    
+    Type?: NamespaceType | string;
+    
+    Description?: string;
+    
+    ServiceCount?: number;
+    
+    Properties?: NamespaceProperties;
+    
+    CreateDate?: Date;
+    
+    CreatorRequestId?: string;
+}
+export declare namespace Namespace {
+    
+    const filterSensitiveLog: (obj: Namespace) => any;
+}
+export interface GetNamespaceResponse {
+    
+    Namespace?: Namespace;
+}
+export declare namespace GetNamespaceResponse {
+    
+    const filterSensitiveLog: (obj: GetNamespaceResponse) => any;
+}
+export interface GetOperationRequest {
+    
+    OperationId: string | undefined;
+}
+export declare namespace GetOperationRequest {
+    
+    const filterSensitiveLog: (obj: GetOperationRequest) => any;
+}
+export declare enum OperationStatus {
+    FAIL = "FAIL",
+    PENDING = "PENDING",
+    SUBMITTED = "SUBMITTED",
+    SUCCESS = "SUCCESS"
+}
+export declare enum OperationTargetType {
+    INSTANCE = "INSTANCE",
+    NAMESPACE = "NAMESPACE",
+    SERVICE = "SERVICE"
+}
+export declare enum OperationType {
+    CREATE_NAMESPACE = "CREATE_NAMESPACE",
+    DELETE_NAMESPACE = "DELETE_NAMESPACE",
+    DEREGISTER_INSTANCE = "DEREGISTER_INSTANCE",
+    REGISTER_INSTANCE = "REGISTER_INSTANCE",
+    UPDATE_NAMESPACE = "UPDATE_NAMESPACE",
+    UPDATE_SERVICE = "UPDATE_SERVICE"
+}
+
+export interface Operation {
+    
+    Id?: string;
+    
+    Type?: OperationType | string;
+    
+    Status?: OperationStatus | string;
+    
+    ErrorMessage?: string;
+    
+    ErrorCode?: string;
+    
+    CreateDate?: Date;
+    
+    UpdateDate?: Date;
+    
+    Targets?: {
+        [key: string]: string;
+    };
+}
+export declare namespace Operation {
+    
+    const filterSensitiveLog: (obj: Operation) => any;
+}
+export interface GetOperationResponse {
+    
+    Operation?: Operation;
+}
+export declare namespace GetOperationResponse {
+    
+    const filterSensitiveLog: (obj: GetOperationResponse) => any;
+}
+
+export declare class OperationNotFound extends __BaseException {
+    readonly name: "OperationNotFound";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<OperationNotFound, __BaseException>);
+}
+export interface GetServiceRequest {
+    
+    Id: string | undefined;
+}
+export declare namespace GetServiceRequest {
+    
+    const filterSensitiveLog: (obj: GetServiceRequest) => any;
+}
+export interface GetServiceResponse {
+    
+    Service?: Service;
+}
+export declare namespace GetServiceResponse {
+    
+    const filterSensitiveLog: (obj: GetServiceResponse) => any;
+}
+
+export interface HttpNamespaceChange {
+    
+    Description: string | undefined;
+}
+export declare namespace HttpNamespaceChange {
+    
+    const filterSensitiveLog: (obj: HttpNamespaceChange) => any;
+}
+
+export interface InstanceSummary {
+    
+    Id?: string;
+    
+    Attributes?: {
+        [key: string]: string;
+    };
+}
+export declare namespace InstanceSummary {
+    
+    const filterSensitiveLog: (obj: InstanceSummary) => any;
+}
+export interface ListInstancesRequest {
+    
+    ServiceId: string | undefined;
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+}
+export declare namespace ListInstancesRequest {
+    
+    const filterSensitiveLog: (obj: ListInstancesRequest) => any;
+}
+export interface ListInstancesResponse {
+    
+    Instances?: InstanceSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListInstancesResponse {
+    
+    const filterSensitiveLog: (obj: ListInstancesResponse) => any;
+}
+export declare enum NamespaceFilterName {
+    TYPE = "TYPE"
+}
+
+export interface NamespaceFilter {
+    
+    Name: NamespaceFilterName | string | undefined;
+    
+    Values: string[] | undefined;
+    
+    Condition?: FilterCondition | string;
+}
+export declare namespace NamespaceFilter {
+    
+    const filterSensitiveLog: (obj: NamespaceFilter) => any;
+}
+export interface ListNamespacesRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    Filters?: NamespaceFilter[];
+}
+export declare namespace ListNamespacesRequest {
+    
+    const filterSensitiveLog: (obj: ListNamespacesRequest) => any;
+}
+
+export interface NamespaceSummary {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Name?: string;
+    
+    Type?: NamespaceType | string;
+    
+    Description?: string;
+    
+    ServiceCount?: number;
+    
+    Properties?: NamespaceProperties;
+    
+    CreateDate?: Date;
+}
+export declare namespace NamespaceSummary {
+    
+    const filterSensitiveLog: (obj: NamespaceSummary) => any;
+}
+export interface ListNamespacesResponse {
+    
+    Namespaces?: NamespaceSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListNamespacesResponse {
+    
+    const filterSensitiveLog: (obj: ListNamespacesResponse) => any;
+}
+export declare enum OperationFilterName {
+    NAMESPACE_ID = "NAMESPACE_ID",
+    SERVICE_ID = "SERVICE_ID",
+    STATUS = "STATUS",
+    TYPE = "TYPE",
+    UPDATE_DATE = "UPDATE_DATE"
+}
+
+export interface OperationFilter {
+    
+    Name: OperationFilterName | string | undefined;
+    
+    Values: string[] | undefined;
+    
+    Condition?: FilterCondition | string;
+}
+export declare namespace OperationFilter {
+    
+    const filterSensitiveLog: (obj: OperationFilter) => any;
+}
+export interface ListOperationsRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    Filters?: OperationFilter[];
+}
+export declare namespace ListOperationsRequest {
+    
+    const filterSensitiveLog: (obj: ListOperationsRequest) => any;
+}
+
+export interface OperationSummary {
+    
+    Id?: string;
+    
+    Status?: OperationStatus | string;
+}
+export declare namespace OperationSummary {
+    
+    const filterSensitiveLog: (obj: OperationSummary) => any;
+}
+export interface ListOperationsResponse {
+    
+    Operations?: OperationSummary[];
+    
+    NextToken?: string;
+}
+export declare namespace ListOperationsResponse {
+    
+    const filterSensitiveLog: (obj: ListOperationsResponse) => any;
+}
+export declare enum ServiceFilterName {
+    NAMESPACE_ID = "NAMESPACE_ID"
+}
+
+export interface ServiceFilter {
+    
+    Name: ServiceFilterName | string | undefined;
+    
+    Values: string[] | undefined;
+    
+    Condition?: FilterCondition | string;
+}
+export declare namespace ServiceFilter {
+    
+    const filterSensitiveLog: (obj: ServiceFilter) => any;
+}
+export interface ListServicesRequest {
+    
+    NextToken?: string;
+    
+    MaxResults?: number;
+    
+    Filters?: ServiceFilter[];
+}
+export declare namespace ListServicesRequest {
+    
+    const filterSensitiveLog: (obj: ListServicesRequest) => any;
+}
+
+export interface ServiceSummary {
+    
+    Id?: string;
+    
+    Arn?: string;
+    
+    Name?: string;
+    
+    Type?: ServiceType | string;
+    
+    Description?: string;
+    
+    InstanceCount?: number;
+    
+    DnsConfig?: DnsConfig;
+    
+    HealthCheckConfig?: HealthCheckConfig;
+    
+    HealthCheckCustomConfig?: HealthCheckCustomConfig;
+    
+    CreateDate?: Date;
+}
+export declare namespace ServiceSummary {
+    
+    const filterSensitiveLog: (obj: ServiceSummary) => any;
+}
+export interface ListServicesResponse {
+    
+    Services?: ServiceSummary[];
+    
+    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 declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    Message?: string;
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+
+export interface SOAChange {
+    
+    TTL: number | undefined;
+}
+export declare namespace SOAChange {
+    
+    const filterSensitiveLog: (obj: SOAChange) => any;
+}
+
+export interface PrivateDnsPropertiesMutableChange {
+    
+    SOA: SOAChange | undefined;
+}
+export declare namespace PrivateDnsPropertiesMutableChange {
+    
+    const filterSensitiveLog: (obj: PrivateDnsPropertiesMutableChange) => any;
+}
+
+export interface PrivateDnsNamespacePropertiesChange {
+    
+    DnsProperties: PrivateDnsPropertiesMutableChange | undefined;
+}
+export declare namespace PrivateDnsNamespacePropertiesChange {
+    
+    const filterSensitiveLog: (obj: PrivateDnsNamespacePropertiesChange) => any;
+}
+
+export interface PrivateDnsNamespaceChange {
+    
+    Description?: string;
+    
+    Properties?: PrivateDnsNamespacePropertiesChange;
+}
+export declare namespace PrivateDnsNamespaceChange {
+    
+    const filterSensitiveLog: (obj: PrivateDnsNamespaceChange) => any;
+}
+
+export interface PublicDnsPropertiesMutableChange {
+    
+    SOA: SOAChange | undefined;
+}
+export declare namespace PublicDnsPropertiesMutableChange {
+    
+    const filterSensitiveLog: (obj: PublicDnsPropertiesMutableChange) => any;
+}
+
+export interface PublicDnsNamespacePropertiesChange {
+    
+    DnsProperties: PublicDnsPropertiesMutableChange | undefined;
+}
+export declare namespace PublicDnsNamespacePropertiesChange {
+    
+    const filterSensitiveLog: (obj: PublicDnsNamespacePropertiesChange) => any;
+}
+
+export interface PublicDnsNamespaceChange {
+    
+    Description?: string;
+    
+    Properties?: PublicDnsNamespacePropertiesChange;
+}
+export declare namespace PublicDnsNamespaceChange {
+    
+    const filterSensitiveLog: (obj: PublicDnsNamespaceChange) => any;
+}
+export interface RegisterInstanceRequest {
+    
+    ServiceId: string | undefined;
+    
+    InstanceId: string | undefined;
+    
+    CreatorRequestId?: string;
+    
+    Attributes: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace RegisterInstanceRequest {
+    
+    const filterSensitiveLog: (obj: RegisterInstanceRequest) => any;
+}
+export interface RegisterInstanceResponse {
+    
+    OperationId?: string;
+}
+export declare namespace RegisterInstanceResponse {
+    
+    const filterSensitiveLog: (obj: RegisterInstanceResponse) => 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 UpdateHttpNamespaceRequest {
+    
+    Id: string | undefined;
+    
+    UpdaterRequestId?: string;
+    
+    Namespace: HttpNamespaceChange | undefined;
+}
+export declare namespace UpdateHttpNamespaceRequest {
+    
+    const filterSensitiveLog: (obj: UpdateHttpNamespaceRequest) => any;
+}
+export interface UpdateHttpNamespaceResponse {
+    
+    OperationId?: string;
+}
+export declare namespace UpdateHttpNamespaceResponse {
+    
+    const filterSensitiveLog: (obj: UpdateHttpNamespaceResponse) => any;
+}
+export interface UpdateInstanceCustomHealthStatusRequest {
+    
+    ServiceId: string | undefined;
+    
+    InstanceId: string | undefined;
+    
+    Status: CustomHealthStatus | string | undefined;
+}
+export declare namespace UpdateInstanceCustomHealthStatusRequest {
+    
+    const filterSensitiveLog: (obj: UpdateInstanceCustomHealthStatusRequest) => any;
+}
+export interface UpdatePrivateDnsNamespaceRequest {
+    
+    Id: string | undefined;
+    
+    UpdaterRequestId?: string;
+    
+    Namespace: PrivateDnsNamespaceChange | undefined;
+}
+export declare namespace UpdatePrivateDnsNamespaceRequest {
+    
+    const filterSensitiveLog: (obj: UpdatePrivateDnsNamespaceRequest) => any;
+}
+export interface UpdatePrivateDnsNamespaceResponse {
+    
+    OperationId?: string;
+}
+export declare namespace UpdatePrivateDnsNamespaceResponse {
+    
+    const filterSensitiveLog: (obj: UpdatePrivateDnsNamespaceResponse) => any;
+}
+export interface UpdatePublicDnsNamespaceRequest {
+    
+    Id: string | undefined;
+    
+    UpdaterRequestId?: string;
+    
+    Namespace: PublicDnsNamespaceChange | undefined;
+}
+export declare namespace UpdatePublicDnsNamespaceRequest {
+    
+    const filterSensitiveLog: (obj: UpdatePublicDnsNamespaceRequest) => any;
+}
+export interface UpdatePublicDnsNamespaceResponse {
+    
+    OperationId?: string;
+}
+export declare namespace UpdatePublicDnsNamespaceResponse {
+    
+    const filterSensitiveLog: (obj: UpdatePublicDnsNamespaceResponse) => any;
+}
+
+export interface ServiceChange {
+    
+    Description?: string;
+    
+    DnsConfig?: DnsConfigChange;
+    
+    HealthCheckConfig?: HealthCheckConfig;
+}
+export declare namespace ServiceChange {
+    
+    const filterSensitiveLog: (obj: ServiceChange) => any;
+}
+export interface UpdateServiceRequest {
+    
+    Id: string | undefined;
+    
+    Service: ServiceChange | undefined;
+}
+export declare namespace UpdateServiceRequest {
+    
+    const filterSensitiveLog: (obj: UpdateServiceRequest) => any;
+}
+export interface UpdateServiceResponse {
+    
+    OperationId?: string;
+}
+export declare namespace UpdateServiceResponse {
+    
+    const filterSensitiveLog: (obj: UpdateServiceResponse) => any;
+}