@aws-sdk/client-proton 3.34.0 → 3.37.0

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

@@ -0,0 +1,1699 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+export interface AcceptEnvironmentAccountConnectionInput {
+    
+    id: string | undefined;
+}
+export declare namespace AcceptEnvironmentAccountConnectionInput {
+    
+    const filterSensitiveLog: (obj: AcceptEnvironmentAccountConnectionInput) => any;
+}
+export declare enum EnvironmentAccountConnectionStatus {
+    CONNECTED = "CONNECTED",
+    PENDING = "PENDING",
+    REJECTED = "REJECTED"
+}
+
+export interface EnvironmentAccountConnection {
+    
+    id: string | undefined;
+    
+    arn: string | undefined;
+    
+    managementAccountId: string | undefined;
+    
+    environmentAccountId: string | undefined;
+    
+    roleArn: string | undefined;
+    
+    environmentName: string | undefined;
+    
+    requestedAt: Date | undefined;
+    
+    lastModifiedAt: Date | undefined;
+    
+    status: EnvironmentAccountConnectionStatus | string | undefined;
+}
+export declare namespace EnvironmentAccountConnection {
+    
+    const filterSensitiveLog: (obj: EnvironmentAccountConnection) => any;
+}
+export interface AcceptEnvironmentAccountConnectionOutput {
+    
+    environmentAccountConnection: EnvironmentAccountConnection | undefined;
+}
+export declare namespace AcceptEnvironmentAccountConnectionOutput {
+    
+    const filterSensitiveLog: (obj: AcceptEnvironmentAccountConnectionOutput) => any;
+}
+
+export interface AccessDeniedException extends __SmithyException, $MetadataBearer {
+    name: "AccessDeniedException";
+    $fault: "client";
+    message: string | undefined;
+}
+export declare namespace AccessDeniedException {
+    
+    const filterSensitiveLog: (obj: AccessDeniedException) => any;
+}
+
+export interface ConflictException extends __SmithyException, $MetadataBearer {
+    name: "ConflictException";
+    $fault: "client";
+    message: string | undefined;
+}
+export declare namespace ConflictException {
+    
+    const filterSensitiveLog: (obj: ConflictException) => any;
+}
+
+export interface InternalServerException extends __SmithyException, $MetadataBearer {
+    name: "InternalServerException";
+    $fault: "server";
+    $retryable: {};
+    message: string | undefined;
+}
+export declare namespace InternalServerException {
+    
+    const filterSensitiveLog: (obj: InternalServerException) => any;
+}
+
+export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    message: string | undefined;
+}
+export declare namespace ResourceNotFoundException {
+    
+    const filterSensitiveLog: (obj: ResourceNotFoundException) => any;
+}
+
+export interface ThrottlingException extends __SmithyException, $MetadataBearer {
+    name: "ThrottlingException";
+    $fault: "client";
+    $retryable: {
+        throttling: true;
+    };
+    message: string | undefined;
+}
+export declare namespace ThrottlingException {
+    
+    const filterSensitiveLog: (obj: ThrottlingException) => any;
+}
+
+export interface ValidationException extends __SmithyException, $MetadataBearer {
+    name: "ValidationException";
+    $fault: "client";
+    message: string | undefined;
+}
+export declare namespace ValidationException {
+    
+    const filterSensitiveLog: (obj: ValidationException) => any;
+}
+
+export interface AccountSettings {
+    
+    pipelineServiceRoleArn?: string;
+}
+export declare namespace AccountSettings {
+    
+    const filterSensitiveLog: (obj: AccountSettings) => any;
+}
+export interface GetAccountSettingsInput {
+}
+export declare namespace GetAccountSettingsInput {
+    
+    const filterSensitiveLog: (obj: GetAccountSettingsInput) => any;
+}
+export interface GetAccountSettingsOutput {
+    
+    accountSettings?: AccountSettings;
+}
+export declare namespace GetAccountSettingsOutput {
+    
+    const filterSensitiveLog: (obj: GetAccountSettingsOutput) => any;
+}
+export interface UpdateAccountSettingsInput {
+    
+    pipelineServiceRoleArn?: string;
+}
+export declare namespace UpdateAccountSettingsInput {
+    
+    const filterSensitiveLog: (obj: UpdateAccountSettingsInput) => any;
+}
+export interface UpdateAccountSettingsOutput {
+    
+    accountSettings: AccountSettings | undefined;
+}
+export declare namespace UpdateAccountSettingsOutput {
+    
+    const filterSensitiveLog: (obj: UpdateAccountSettingsOutput) => any;
+}
+export interface CancelEnvironmentDeploymentInput {
+    
+    environmentName: string | undefined;
+}
+export declare namespace CancelEnvironmentDeploymentInput {
+    
+    const filterSensitiveLog: (obj: CancelEnvironmentDeploymentInput) => any;
+}
+export declare enum DeploymentStatus {
+    CANCELLED = "CANCELLED",
+    CANCELLING = "CANCELLING",
+    DELETE_COMPLETE = "DELETE_COMPLETE",
+    DELETE_FAILED = "DELETE_FAILED",
+    DELETE_IN_PROGRESS = "DELETE_IN_PROGRESS",
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    SUCCEEDED = "SUCCEEDED"
+}
+export declare enum Provisioning {
+    CUSTOMER_MANAGED = "CUSTOMER_MANAGED"
+}
+
+export interface Environment {
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    createdAt: Date | undefined;
+    
+    lastDeploymentAttemptedAt: Date | undefined;
+    
+    lastDeploymentSucceededAt: Date | undefined;
+    
+    arn: string | undefined;
+    
+    templateName: string | undefined;
+    
+    templateMajorVersion: string | undefined;
+    
+    templateMinorVersion: string | undefined;
+    
+    deploymentStatus: DeploymentStatus | string | undefined;
+    
+    deploymentStatusMessage?: string;
+    
+    protonServiceRoleArn?: string;
+    
+    environmentAccountConnectionId?: string;
+    
+    environmentAccountId?: string;
+    
+    spec?: string;
+    
+    provisioning?: Provisioning | string;
+}
+export declare namespace Environment {
+    
+    const filterSensitiveLog: (obj: Environment) => any;
+}
+export interface CancelEnvironmentDeploymentOutput {
+    
+    environment: Environment | undefined;
+}
+export declare namespace CancelEnvironmentDeploymentOutput {
+    
+    const filterSensitiveLog: (obj: CancelEnvironmentDeploymentOutput) => any;
+}
+export interface CancelServiceInstanceDeploymentInput {
+    
+    serviceInstanceName: string | undefined;
+    
+    serviceName: string | undefined;
+}
+export declare namespace CancelServiceInstanceDeploymentInput {
+    
+    const filterSensitiveLog: (obj: CancelServiceInstanceDeploymentInput) => any;
+}
+
+export interface ServiceInstance {
+    
+    name: string | undefined;
+    
+    arn: string | undefined;
+    
+    createdAt: Date | undefined;
+    
+    lastDeploymentAttemptedAt: Date | undefined;
+    
+    lastDeploymentSucceededAt: Date | undefined;
+    
+    serviceName: string | undefined;
+    
+    environmentName: string | undefined;
+    
+    templateName: string | undefined;
+    
+    templateMajorVersion: string | undefined;
+    
+    templateMinorVersion: string | undefined;
+    
+    deploymentStatus: DeploymentStatus | string | undefined;
+    
+    deploymentStatusMessage?: string;
+    
+    spec?: string;
+}
+export declare namespace ServiceInstance {
+    
+    const filterSensitiveLog: (obj: ServiceInstance) => any;
+}
+export interface CancelServiceInstanceDeploymentOutput {
+    
+    serviceInstance: ServiceInstance | undefined;
+}
+export declare namespace CancelServiceInstanceDeploymentOutput {
+    
+    const filterSensitiveLog: (obj: CancelServiceInstanceDeploymentOutput) => any;
+}
+export interface CancelServicePipelineDeploymentInput {
+    
+    serviceName: string | undefined;
+}
+export declare namespace CancelServicePipelineDeploymentInput {
+    
+    const filterSensitiveLog: (obj: CancelServicePipelineDeploymentInput) => any;
+}
+
+export interface ServicePipeline {
+    
+    arn: string | undefined;
+    
+    createdAt: Date | undefined;
+    
+    lastDeploymentAttemptedAt: Date | undefined;
+    
+    lastDeploymentSucceededAt: Date | undefined;
+    
+    templateName: string | undefined;
+    
+    templateMajorVersion: string | undefined;
+    
+    templateMinorVersion: string | undefined;
+    
+    deploymentStatus: DeploymentStatus | string | undefined;
+    
+    deploymentStatusMessage?: string;
+    
+    spec?: string;
+}
+export declare namespace ServicePipeline {
+    
+    const filterSensitiveLog: (obj: ServicePipeline) => any;
+}
+export interface CancelServicePipelineDeploymentOutput {
+    
+    pipeline: ServicePipeline | undefined;
+}
+export declare namespace CancelServicePipelineDeploymentOutput {
+    
+    const filterSensitiveLog: (obj: CancelServicePipelineDeploymentOutput) => any;
+}
+export interface CreateEnvironmentAccountConnectionInput {
+    
+    clientToken?: string;
+    
+    managementAccountId: string | undefined;
+    
+    roleArn: string | undefined;
+    
+    environmentName: string | undefined;
+}
+export declare namespace CreateEnvironmentAccountConnectionInput {
+    
+    const filterSensitiveLog: (obj: CreateEnvironmentAccountConnectionInput) => any;
+}
+export interface CreateEnvironmentAccountConnectionOutput {
+    
+    environmentAccountConnection: EnvironmentAccountConnection | undefined;
+}
+export declare namespace CreateEnvironmentAccountConnectionOutput {
+    
+    const filterSensitiveLog: (obj: CreateEnvironmentAccountConnectionOutput) => any;
+}
+
+export interface ServiceQuotaExceededException extends __SmithyException, $MetadataBearer {
+    name: "ServiceQuotaExceededException";
+    $fault: "client";
+    message: string | undefined;
+}
+export declare namespace ServiceQuotaExceededException {
+    
+    const filterSensitiveLog: (obj: ServiceQuotaExceededException) => any;
+}
+export interface DeleteEnvironmentAccountConnectionInput {
+    
+    id: string | undefined;
+}
+export declare namespace DeleteEnvironmentAccountConnectionInput {
+    
+    const filterSensitiveLog: (obj: DeleteEnvironmentAccountConnectionInput) => any;
+}
+export interface DeleteEnvironmentAccountConnectionOutput {
+    
+    environmentAccountConnection?: EnvironmentAccountConnection;
+}
+export declare namespace DeleteEnvironmentAccountConnectionOutput {
+    
+    const filterSensitiveLog: (obj: DeleteEnvironmentAccountConnectionOutput) => any;
+}
+export interface GetEnvironmentAccountConnectionInput {
+    
+    id: string | undefined;
+}
+export declare namespace GetEnvironmentAccountConnectionInput {
+    
+    const filterSensitiveLog: (obj: GetEnvironmentAccountConnectionInput) => any;
+}
+export interface GetEnvironmentAccountConnectionOutput {
+    
+    environmentAccountConnection: EnvironmentAccountConnection | undefined;
+}
+export declare namespace GetEnvironmentAccountConnectionOutput {
+    
+    const filterSensitiveLog: (obj: GetEnvironmentAccountConnectionOutput) => any;
+}
+export declare enum EnvironmentAccountConnectionRequesterAccountType {
+    ENVIRONMENT_ACCOUNT = "ENVIRONMENT_ACCOUNT",
+    MANAGEMENT_ACCOUNT = "MANAGEMENT_ACCOUNT"
+}
+export interface ListEnvironmentAccountConnectionsInput {
+    
+    requestedBy: EnvironmentAccountConnectionRequesterAccountType | string | undefined;
+    
+    environmentName?: string;
+    
+    statuses?: (EnvironmentAccountConnectionStatus | string)[];
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListEnvironmentAccountConnectionsInput {
+    
+    const filterSensitiveLog: (obj: ListEnvironmentAccountConnectionsInput) => any;
+}
+
+export interface EnvironmentAccountConnectionSummary {
+    
+    id: string | undefined;
+    
+    arn: string | undefined;
+    
+    managementAccountId: string | undefined;
+    
+    environmentAccountId: string | undefined;
+    
+    roleArn: string | undefined;
+    
+    environmentName: string | undefined;
+    
+    requestedAt: Date | undefined;
+    
+    lastModifiedAt: Date | undefined;
+    
+    status: EnvironmentAccountConnectionStatus | string | undefined;
+}
+export declare namespace EnvironmentAccountConnectionSummary {
+    
+    const filterSensitiveLog: (obj: EnvironmentAccountConnectionSummary) => any;
+}
+export interface ListEnvironmentAccountConnectionsOutput {
+    
+    environmentAccountConnections: EnvironmentAccountConnectionSummary[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListEnvironmentAccountConnectionsOutput {
+    
+    const filterSensitiveLog: (obj: ListEnvironmentAccountConnectionsOutput) => any;
+}
+export interface RejectEnvironmentAccountConnectionInput {
+    
+    id: string | undefined;
+}
+export declare namespace RejectEnvironmentAccountConnectionInput {
+    
+    const filterSensitiveLog: (obj: RejectEnvironmentAccountConnectionInput) => any;
+}
+export interface RejectEnvironmentAccountConnectionOutput {
+    
+    environmentAccountConnection: EnvironmentAccountConnection | undefined;
+}
+export declare namespace RejectEnvironmentAccountConnectionOutput {
+    
+    const filterSensitiveLog: (obj: RejectEnvironmentAccountConnectionOutput) => any;
+}
+export interface UpdateEnvironmentAccountConnectionInput {
+    
+    id: string | undefined;
+    
+    roleArn: string | undefined;
+}
+export declare namespace UpdateEnvironmentAccountConnectionInput {
+    
+    const filterSensitiveLog: (obj: UpdateEnvironmentAccountConnectionInput) => any;
+}
+export interface UpdateEnvironmentAccountConnectionOutput {
+    
+    environmentAccountConnection: EnvironmentAccountConnection | undefined;
+}
+export declare namespace UpdateEnvironmentAccountConnectionOutput {
+    
+    const filterSensitiveLog: (obj: UpdateEnvironmentAccountConnectionOutput) => any;
+}
+
+export interface Tag {
+    
+    key: string | undefined;
+    
+    value: string | undefined;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+export interface CreateEnvironmentInput {
+    
+    name: string | undefined;
+    
+    templateName: string | undefined;
+    
+    templateMajorVersion: string | undefined;
+    
+    templateMinorVersion?: string;
+    
+    description?: string;
+    
+    spec: string | undefined;
+    
+    protonServiceRoleArn?: string;
+    
+    environmentAccountConnectionId?: string;
+    
+    tags?: Tag[];
+}
+export declare namespace CreateEnvironmentInput {
+    
+    const filterSensitiveLog: (obj: CreateEnvironmentInput) => any;
+}
+export interface CreateEnvironmentOutput {
+    
+    environment: Environment | undefined;
+}
+export declare namespace CreateEnvironmentOutput {
+    
+    const filterSensitiveLog: (obj: CreateEnvironmentOutput) => any;
+}
+export interface DeleteEnvironmentInput {
+    
+    name: string | undefined;
+}
+export declare namespace DeleteEnvironmentInput {
+    
+    const filterSensitiveLog: (obj: DeleteEnvironmentInput) => any;
+}
+export interface DeleteEnvironmentOutput {
+    
+    environment?: Environment;
+}
+export declare namespace DeleteEnvironmentOutput {
+    
+    const filterSensitiveLog: (obj: DeleteEnvironmentOutput) => any;
+}
+export interface GetEnvironmentInput {
+    
+    name: string | undefined;
+}
+export declare namespace GetEnvironmentInput {
+    
+    const filterSensitiveLog: (obj: GetEnvironmentInput) => any;
+}
+export interface GetEnvironmentOutput {
+    
+    environment: Environment | undefined;
+}
+export declare namespace GetEnvironmentOutput {
+    
+    const filterSensitiveLog: (obj: GetEnvironmentOutput) => any;
+}
+
+export interface EnvironmentTemplateFilter {
+    
+    templateName: string | undefined;
+    
+    majorVersion: string | undefined;
+}
+export declare namespace EnvironmentTemplateFilter {
+    
+    const filterSensitiveLog: (obj: EnvironmentTemplateFilter) => any;
+}
+export interface ListEnvironmentsInput {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    environmentTemplates?: EnvironmentTemplateFilter[];
+}
+export declare namespace ListEnvironmentsInput {
+    
+    const filterSensitiveLog: (obj: ListEnvironmentsInput) => any;
+}
+
+export interface EnvironmentSummary {
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    createdAt: Date | undefined;
+    
+    lastDeploymentAttemptedAt: Date | undefined;
+    
+    lastDeploymentSucceededAt: Date | undefined;
+    
+    arn: string | undefined;
+    
+    templateName: string | undefined;
+    
+    templateMajorVersion: string | undefined;
+    
+    templateMinorVersion: string | undefined;
+    
+    deploymentStatus: DeploymentStatus | string | undefined;
+    
+    deploymentStatusMessage?: string;
+    
+    protonServiceRoleArn?: string;
+    
+    environmentAccountConnectionId?: string;
+    
+    environmentAccountId?: string;
+    
+    provisioning?: Provisioning | string;
+}
+export declare namespace EnvironmentSummary {
+    
+    const filterSensitiveLog: (obj: EnvironmentSummary) => any;
+}
+export interface ListEnvironmentsOutput {
+    
+    nextToken?: string;
+    
+    environments: EnvironmentSummary[] | undefined;
+}
+export declare namespace ListEnvironmentsOutput {
+    
+    const filterSensitiveLog: (obj: ListEnvironmentsOutput) => any;
+}
+export declare enum DeploymentUpdateType {
+    CURRENT_VERSION = "CURRENT_VERSION",
+    MAJOR_VERSION = "MAJOR_VERSION",
+    MINOR_VERSION = "MINOR_VERSION",
+    NONE = "NONE"
+}
+export interface UpdateEnvironmentInput {
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    spec?: string;
+    
+    templateMajorVersion?: string;
+    
+    templateMinorVersion?: string;
+    
+    protonServiceRoleArn?: string;
+    
+    deploymentType: DeploymentUpdateType | string | undefined;
+    
+    environmentAccountConnectionId?: string;
+}
+export declare namespace UpdateEnvironmentInput {
+    
+    const filterSensitiveLog: (obj: UpdateEnvironmentInput) => any;
+}
+export interface UpdateEnvironmentOutput {
+    
+    environment: Environment | undefined;
+}
+export declare namespace UpdateEnvironmentOutput {
+    
+    const filterSensitiveLog: (obj: UpdateEnvironmentOutput) => any;
+}
+export interface CreateEnvironmentTemplateInput {
+    
+    name: string | undefined;
+    
+    displayName?: string;
+    
+    description?: string;
+    
+    encryptionKey?: string;
+    
+    provisioning?: Provisioning | string;
+    
+    tags?: Tag[];
+}
+export declare namespace CreateEnvironmentTemplateInput {
+    
+    const filterSensitiveLog: (obj: CreateEnvironmentTemplateInput) => any;
+}
+
+export interface EnvironmentTemplate {
+    
+    name: string | undefined;
+    
+    arn: string | undefined;
+    
+    createdAt: Date | undefined;
+    
+    lastModifiedAt: Date | undefined;
+    
+    displayName?: string;
+    
+    description?: string;
+    
+    recommendedVersion?: string;
+    
+    encryptionKey?: string;
+    
+    provisioning?: Provisioning | string;
+}
+export declare namespace EnvironmentTemplate {
+    
+    const filterSensitiveLog: (obj: EnvironmentTemplate) => any;
+}
+export interface CreateEnvironmentTemplateOutput {
+    
+    environmentTemplate: EnvironmentTemplate | undefined;
+}
+export declare namespace CreateEnvironmentTemplateOutput {
+    
+    const filterSensitiveLog: (obj: CreateEnvironmentTemplateOutput) => any;
+}
+export interface DeleteEnvironmentTemplateInput {
+    
+    name: string | undefined;
+}
+export declare namespace DeleteEnvironmentTemplateInput {
+    
+    const filterSensitiveLog: (obj: DeleteEnvironmentTemplateInput) => any;
+}
+export interface DeleteEnvironmentTemplateOutput {
+    
+    environmentTemplate?: EnvironmentTemplate;
+}
+export declare namespace DeleteEnvironmentTemplateOutput {
+    
+    const filterSensitiveLog: (obj: DeleteEnvironmentTemplateOutput) => any;
+}
+export interface GetEnvironmentTemplateInput {
+    
+    name: string | undefined;
+}
+export declare namespace GetEnvironmentTemplateInput {
+    
+    const filterSensitiveLog: (obj: GetEnvironmentTemplateInput) => any;
+}
+export interface GetEnvironmentTemplateOutput {
+    
+    environmentTemplate: EnvironmentTemplate | undefined;
+}
+export declare namespace GetEnvironmentTemplateOutput {
+    
+    const filterSensitiveLog: (obj: GetEnvironmentTemplateOutput) => any;
+}
+export interface ListEnvironmentTemplatesInput {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListEnvironmentTemplatesInput {
+    
+    const filterSensitiveLog: (obj: ListEnvironmentTemplatesInput) => any;
+}
+
+export interface EnvironmentTemplateSummary {
+    
+    name: string | undefined;
+    
+    arn: string | undefined;
+    
+    createdAt: Date | undefined;
+    
+    lastModifiedAt: Date | undefined;
+    
+    displayName?: string;
+    
+    description?: string;
+    
+    recommendedVersion?: string;
+    
+    provisioning?: Provisioning | string;
+}
+export declare namespace EnvironmentTemplateSummary {
+    
+    const filterSensitiveLog: (obj: EnvironmentTemplateSummary) => any;
+}
+export interface ListEnvironmentTemplatesOutput {
+    
+    nextToken?: string;
+    
+    templates: EnvironmentTemplateSummary[] | undefined;
+}
+export declare namespace ListEnvironmentTemplatesOutput {
+    
+    const filterSensitiveLog: (obj: ListEnvironmentTemplatesOutput) => any;
+}
+export interface UpdateEnvironmentTemplateInput {
+    
+    name: string | undefined;
+    
+    displayName?: string;
+    
+    description?: string;
+}
+export declare namespace UpdateEnvironmentTemplateInput {
+    
+    const filterSensitiveLog: (obj: UpdateEnvironmentTemplateInput) => any;
+}
+export interface UpdateEnvironmentTemplateOutput {
+    
+    environmentTemplate: EnvironmentTemplate | undefined;
+}
+export declare namespace UpdateEnvironmentTemplateOutput {
+    
+    const filterSensitiveLog: (obj: UpdateEnvironmentTemplateOutput) => any;
+}
+
+export interface S3ObjectSource {
+    
+    bucket: string | undefined;
+    
+    key: string | undefined;
+}
+export declare namespace S3ObjectSource {
+    
+    const filterSensitiveLog: (obj: S3ObjectSource) => any;
+}
+
+export declare type TemplateVersionSourceInput = TemplateVersionSourceInput.S3Member | TemplateVersionSourceInput.$UnknownMember;
+export declare namespace TemplateVersionSourceInput {
+    
+    interface S3Member {
+        s3: S3ObjectSource;
+        $unknown?: never;
+    }
+    interface $UnknownMember {
+        s3?: never;
+        $unknown: [
+            string,
+            any
+        ];
+    }
+    interface Visitor<T> {
+        s3: (value: S3ObjectSource) => T;
+        _: (name: string, value: any) => T;
+    }
+    const visit: <T>(value: TemplateVersionSourceInput, visitor: Visitor<T>) => T;
+    
+    const filterSensitiveLog: (obj: TemplateVersionSourceInput) => any;
+}
+export interface CreateEnvironmentTemplateVersionInput {
+    
+    clientToken?: string;
+    
+    templateName: string | undefined;
+    
+    description?: string;
+    
+    majorVersion?: string;
+    
+    source: TemplateVersionSourceInput | undefined;
+    
+    tags?: Tag[];
+}
+export declare namespace CreateEnvironmentTemplateVersionInput {
+    
+    const filterSensitiveLog: (obj: CreateEnvironmentTemplateVersionInput) => any;
+}
+export declare enum TemplateVersionStatus {
+    DRAFT = "DRAFT",
+    PUBLISHED = "PUBLISHED",
+    REGISTRATION_FAILED = "REGISTRATION_FAILED",
+    REGISTRATION_IN_PROGRESS = "REGISTRATION_IN_PROGRESS"
+}
+
+export interface EnvironmentTemplateVersion {
+    
+    templateName: string | undefined;
+    
+    majorVersion: string | undefined;
+    
+    minorVersion: string | undefined;
+    
+    recommendedMinorVersion?: string;
+    
+    status: TemplateVersionStatus | string | undefined;
+    
+    statusMessage?: string;
+    
+    description?: string;
+    
+    arn: string | undefined;
+    
+    createdAt: Date | undefined;
+    
+    lastModifiedAt: Date | undefined;
+    
+    schema?: string;
+}
+export declare namespace EnvironmentTemplateVersion {
+    
+    const filterSensitiveLog: (obj: EnvironmentTemplateVersion) => any;
+}
+export interface CreateEnvironmentTemplateVersionOutput {
+    
+    environmentTemplateVersion: EnvironmentTemplateVersion | undefined;
+}
+export declare namespace CreateEnvironmentTemplateVersionOutput {
+    
+    const filterSensitiveLog: (obj: CreateEnvironmentTemplateVersionOutput) => any;
+}
+export interface DeleteEnvironmentTemplateVersionInput {
+    
+    templateName: string | undefined;
+    
+    majorVersion: string | undefined;
+    
+    minorVersion: string | undefined;
+}
+export declare namespace DeleteEnvironmentTemplateVersionInput {
+    
+    const filterSensitiveLog: (obj: DeleteEnvironmentTemplateVersionInput) => any;
+}
+export interface DeleteEnvironmentTemplateVersionOutput {
+    
+    environmentTemplateVersion?: EnvironmentTemplateVersion;
+}
+export declare namespace DeleteEnvironmentTemplateVersionOutput {
+    
+    const filterSensitiveLog: (obj: DeleteEnvironmentTemplateVersionOutput) => any;
+}
+export interface GetEnvironmentTemplateVersionInput {
+    
+    templateName: string | undefined;
+    
+    majorVersion: string | undefined;
+    
+    minorVersion: string | undefined;
+}
+export declare namespace GetEnvironmentTemplateVersionInput {
+    
+    const filterSensitiveLog: (obj: GetEnvironmentTemplateVersionInput) => any;
+}
+export interface GetEnvironmentTemplateVersionOutput {
+    
+    environmentTemplateVersion: EnvironmentTemplateVersion | undefined;
+}
+export declare namespace GetEnvironmentTemplateVersionOutput {
+    
+    const filterSensitiveLog: (obj: GetEnvironmentTemplateVersionOutput) => any;
+}
+export interface ListEnvironmentTemplateVersionsInput {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    templateName: string | undefined;
+    
+    majorVersion?: string;
+}
+export declare namespace ListEnvironmentTemplateVersionsInput {
+    
+    const filterSensitiveLog: (obj: ListEnvironmentTemplateVersionsInput) => any;
+}
+
+export interface EnvironmentTemplateVersionSummary {
+    
+    templateName: string | undefined;
+    
+    majorVersion: string | undefined;
+    
+    minorVersion: string | undefined;
+    
+    recommendedMinorVersion?: string;
+    
+    status: TemplateVersionStatus | string | undefined;
+    
+    statusMessage?: string;
+    
+    description?: string;
+    
+    arn: string | undefined;
+    
+    createdAt: Date | undefined;
+    
+    lastModifiedAt: Date | undefined;
+}
+export declare namespace EnvironmentTemplateVersionSummary {
+    
+    const filterSensitiveLog: (obj: EnvironmentTemplateVersionSummary) => any;
+}
+export interface ListEnvironmentTemplateVersionsOutput {
+    
+    nextToken?: string;
+    
+    templateVersions: EnvironmentTemplateVersionSummary[] | undefined;
+}
+export declare namespace ListEnvironmentTemplateVersionsOutput {
+    
+    const filterSensitiveLog: (obj: ListEnvironmentTemplateVersionsOutput) => any;
+}
+export interface UpdateEnvironmentTemplateVersionInput {
+    
+    templateName: string | undefined;
+    
+    majorVersion: string | undefined;
+    
+    minorVersion: string | undefined;
+    
+    description?: string;
+    
+    status?: TemplateVersionStatus | string;
+}
+export declare namespace UpdateEnvironmentTemplateVersionInput {
+    
+    const filterSensitiveLog: (obj: UpdateEnvironmentTemplateVersionInput) => any;
+}
+export interface UpdateEnvironmentTemplateVersionOutput {
+    
+    environmentTemplateVersion: EnvironmentTemplateVersion | undefined;
+}
+export declare namespace UpdateEnvironmentTemplateVersionOutput {
+    
+    const filterSensitiveLog: (obj: UpdateEnvironmentTemplateVersionOutput) => any;
+}
+export interface ListTagsForResourceInput {
+    
+    resourceArn: string | undefined;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListTagsForResourceInput {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceInput) => any;
+}
+export interface ListTagsForResourceOutput {
+    
+    tags: Tag[] | undefined;
+    
+    nextToken?: string;
+}
+export declare namespace ListTagsForResourceOutput {
+    
+    const filterSensitiveLog: (obj: ListTagsForResourceOutput) => any;
+}
+export interface GetServiceInstanceInput {
+    
+    name: string | undefined;
+    
+    serviceName: string | undefined;
+}
+export declare namespace GetServiceInstanceInput {
+    
+    const filterSensitiveLog: (obj: GetServiceInstanceInput) => any;
+}
+export interface GetServiceInstanceOutput {
+    
+    serviceInstance: ServiceInstance | undefined;
+}
+export declare namespace GetServiceInstanceOutput {
+    
+    const filterSensitiveLog: (obj: GetServiceInstanceOutput) => any;
+}
+export interface ListServiceInstancesInput {
+    
+    serviceName?: string;
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListServiceInstancesInput {
+    
+    const filterSensitiveLog: (obj: ListServiceInstancesInput) => any;
+}
+
+export interface ServiceInstanceSummary {
+    
+    name: string | undefined;
+    
+    arn: string | undefined;
+    
+    createdAt: Date | undefined;
+    
+    lastDeploymentAttemptedAt: Date | undefined;
+    
+    lastDeploymentSucceededAt: Date | undefined;
+    
+    serviceName: string | undefined;
+    
+    environmentName: string | undefined;
+    
+    templateName: string | undefined;
+    
+    templateMajorVersion: string | undefined;
+    
+    templateMinorVersion: string | undefined;
+    
+    deploymentStatus: DeploymentStatus | string | undefined;
+    
+    deploymentStatusMessage?: string;
+}
+export declare namespace ServiceInstanceSummary {
+    
+    const filterSensitiveLog: (obj: ServiceInstanceSummary) => any;
+}
+export interface ListServiceInstancesOutput {
+    
+    nextToken?: string;
+    
+    serviceInstances: ServiceInstanceSummary[] | undefined;
+}
+export declare namespace ListServiceInstancesOutput {
+    
+    const filterSensitiveLog: (obj: ListServiceInstancesOutput) => any;
+}
+export interface UpdateServiceInstanceInput {
+    
+    name: string | undefined;
+    
+    serviceName: string | undefined;
+    
+    deploymentType: DeploymentUpdateType | string | undefined;
+    
+    spec?: string;
+    
+    templateMajorVersion?: string;
+    
+    templateMinorVersion?: string;
+}
+export declare namespace UpdateServiceInstanceInput {
+    
+    const filterSensitiveLog: (obj: UpdateServiceInstanceInput) => any;
+}
+export interface UpdateServiceInstanceOutput {
+    
+    serviceInstance: ServiceInstance | undefined;
+}
+export declare namespace UpdateServiceInstanceOutput {
+    
+    const filterSensitiveLog: (obj: UpdateServiceInstanceOutput) => any;
+}
+export interface UpdateServicePipelineInput {
+    
+    serviceName: string | undefined;
+    
+    spec: string | undefined;
+    
+    deploymentType: DeploymentUpdateType | string | undefined;
+    
+    templateMajorVersion?: string;
+    
+    templateMinorVersion?: string;
+}
+export declare namespace UpdateServicePipelineInput {
+    
+    const filterSensitiveLog: (obj: UpdateServicePipelineInput) => any;
+}
+export interface UpdateServicePipelineOutput {
+    
+    pipeline: ServicePipeline | undefined;
+}
+export declare namespace UpdateServicePipelineOutput {
+    
+    const filterSensitiveLog: (obj: UpdateServicePipelineOutput) => any;
+}
+export interface CreateServiceInput {
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    templateName: string | undefined;
+    
+    templateMajorVersion: string | undefined;
+    
+    templateMinorVersion?: string;
+    
+    spec: string | undefined;
+    
+    repositoryConnectionArn?: string;
+    
+    repositoryId?: string;
+    
+    branchName?: string;
+    
+    tags?: Tag[];
+}
+export declare namespace CreateServiceInput {
+    
+    const filterSensitiveLog: (obj: CreateServiceInput) => any;
+}
+export declare enum ServiceStatus {
+    ACTIVE = "ACTIVE",
+    CREATE_FAILED = "CREATE_FAILED",
+    CREATE_FAILED_CLEANUP_COMPLETE = "CREATE_FAILED_CLEANUP_COMPLETE",
+    CREATE_FAILED_CLEANUP_FAILED = "CREATE_FAILED_CLEANUP_FAILED",
+    CREATE_FAILED_CLEANUP_IN_PROGRESS = "CREATE_FAILED_CLEANUP_IN_PROGRESS",
+    CREATE_IN_PROGRESS = "CREATE_IN_PROGRESS",
+    DELETE_FAILED = "DELETE_FAILED",
+    DELETE_IN_PROGRESS = "DELETE_IN_PROGRESS",
+    UPDATE_COMPLETE_CLEANUP_FAILED = "UPDATE_COMPLETE_CLEANUP_FAILED",
+    UPDATE_FAILED = "UPDATE_FAILED",
+    UPDATE_FAILED_CLEANUP_COMPLETE = "UPDATE_FAILED_CLEANUP_COMPLETE",
+    UPDATE_FAILED_CLEANUP_FAILED = "UPDATE_FAILED_CLEANUP_FAILED",
+    UPDATE_FAILED_CLEANUP_IN_PROGRESS = "UPDATE_FAILED_CLEANUP_IN_PROGRESS",
+    UPDATE_IN_PROGRESS = "UPDATE_IN_PROGRESS"
+}
+
+export interface Service {
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    arn: string | undefined;
+    
+    templateName: string | undefined;
+    
+    createdAt: Date | undefined;
+    
+    lastModifiedAt: Date | undefined;
+    
+    status: ServiceStatus | string | undefined;
+    
+    statusMessage?: string;
+    
+    spec: string | undefined;
+    
+    pipeline?: ServicePipeline;
+    
+    repositoryConnectionArn?: string;
+    
+    repositoryId?: string;
+    
+    branchName?: string;
+}
+export declare namespace Service {
+    
+    const filterSensitiveLog: (obj: Service) => any;
+}
+export interface CreateServiceOutput {
+    
+    service: Service | undefined;
+}
+export declare namespace CreateServiceOutput {
+    
+    const filterSensitiveLog: (obj: CreateServiceOutput) => any;
+}
+export interface DeleteServiceInput {
+    
+    name: string | undefined;
+}
+export declare namespace DeleteServiceInput {
+    
+    const filterSensitiveLog: (obj: DeleteServiceInput) => any;
+}
+export interface DeleteServiceOutput {
+    
+    service?: Service;
+}
+export declare namespace DeleteServiceOutput {
+    
+    const filterSensitiveLog: (obj: DeleteServiceOutput) => any;
+}
+export interface GetServiceInput {
+    
+    name: string | undefined;
+}
+export declare namespace GetServiceInput {
+    
+    const filterSensitiveLog: (obj: GetServiceInput) => any;
+}
+export interface GetServiceOutput {
+    
+    service?: Service;
+}
+export declare namespace GetServiceOutput {
+    
+    const filterSensitiveLog: (obj: GetServiceOutput) => any;
+}
+export interface ListServicesInput {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListServicesInput {
+    
+    const filterSensitiveLog: (obj: ListServicesInput) => any;
+}
+
+export interface ServiceSummary {
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    arn: string | undefined;
+    
+    templateName: string | undefined;
+    
+    createdAt: Date | undefined;
+    
+    lastModifiedAt: Date | undefined;
+    
+    status: ServiceStatus | string | undefined;
+    
+    statusMessage?: string;
+}
+export declare namespace ServiceSummary {
+    
+    const filterSensitiveLog: (obj: ServiceSummary) => any;
+}
+export interface ListServicesOutput {
+    
+    nextToken?: string;
+    
+    services: ServiceSummary[] | undefined;
+}
+export declare namespace ListServicesOutput {
+    
+    const filterSensitiveLog: (obj: ListServicesOutput) => any;
+}
+export interface UpdateServiceInput {
+    
+    name: string | undefined;
+    
+    description?: string;
+    
+    spec?: string;
+}
+export declare namespace UpdateServiceInput {
+    
+    const filterSensitiveLog: (obj: UpdateServiceInput) => any;
+}
+export interface UpdateServiceOutput {
+    
+    service: Service | undefined;
+}
+export declare namespace UpdateServiceOutput {
+    
+    const filterSensitiveLog: (obj: UpdateServiceOutput) => any;
+}
+export interface CreateServiceTemplateInput {
+    
+    name: string | undefined;
+    
+    displayName?: string;
+    
+    description?: string;
+    
+    encryptionKey?: string;
+    
+    pipelineProvisioning?: Provisioning | string;
+    
+    tags?: Tag[];
+}
+export declare namespace CreateServiceTemplateInput {
+    
+    const filterSensitiveLog: (obj: CreateServiceTemplateInput) => any;
+}
+
+export interface ServiceTemplate {
+    
+    name: string | undefined;
+    
+    arn: string | undefined;
+    
+    createdAt: Date | undefined;
+    
+    lastModifiedAt: Date | undefined;
+    
+    displayName?: string;
+    
+    description?: string;
+    
+    recommendedVersion?: string;
+    
+    encryptionKey?: string;
+    
+    pipelineProvisioning?: Provisioning | string;
+}
+export declare namespace ServiceTemplate {
+    
+    const filterSensitiveLog: (obj: ServiceTemplate) => any;
+}
+export interface CreateServiceTemplateOutput {
+    
+    serviceTemplate: ServiceTemplate | undefined;
+}
+export declare namespace CreateServiceTemplateOutput {
+    
+    const filterSensitiveLog: (obj: CreateServiceTemplateOutput) => any;
+}
+export interface DeleteServiceTemplateInput {
+    
+    name: string | undefined;
+}
+export declare namespace DeleteServiceTemplateInput {
+    
+    const filterSensitiveLog: (obj: DeleteServiceTemplateInput) => any;
+}
+export interface DeleteServiceTemplateOutput {
+    
+    serviceTemplate?: ServiceTemplate;
+}
+export declare namespace DeleteServiceTemplateOutput {
+    
+    const filterSensitiveLog: (obj: DeleteServiceTemplateOutput) => any;
+}
+export interface GetServiceTemplateInput {
+    
+    name: string | undefined;
+}
+export declare namespace GetServiceTemplateInput {
+    
+    const filterSensitiveLog: (obj: GetServiceTemplateInput) => any;
+}
+export interface GetServiceTemplateOutput {
+    
+    serviceTemplate: ServiceTemplate | undefined;
+}
+export declare namespace GetServiceTemplateOutput {
+    
+    const filterSensitiveLog: (obj: GetServiceTemplateOutput) => any;
+}
+export interface ListServiceTemplatesInput {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+}
+export declare namespace ListServiceTemplatesInput {
+    
+    const filterSensitiveLog: (obj: ListServiceTemplatesInput) => any;
+}
+
+export interface ServiceTemplateSummary {
+    
+    name: string | undefined;
+    
+    arn: string | undefined;
+    
+    createdAt: Date | undefined;
+    
+    lastModifiedAt: Date | undefined;
+    
+    displayName?: string;
+    
+    description?: string;
+    
+    recommendedVersion?: string;
+    
+    pipelineProvisioning?: Provisioning | string;
+}
+export declare namespace ServiceTemplateSummary {
+    
+    const filterSensitiveLog: (obj: ServiceTemplateSummary) => any;
+}
+export interface ListServiceTemplatesOutput {
+    
+    nextToken?: string;
+    
+    templates: ServiceTemplateSummary[] | undefined;
+}
+export declare namespace ListServiceTemplatesOutput {
+    
+    const filterSensitiveLog: (obj: ListServiceTemplatesOutput) => any;
+}
+export interface UpdateServiceTemplateInput {
+    
+    name: string | undefined;
+    
+    displayName?: string;
+    
+    description?: string;
+}
+export declare namespace UpdateServiceTemplateInput {
+    
+    const filterSensitiveLog: (obj: UpdateServiceTemplateInput) => any;
+}
+export interface UpdateServiceTemplateOutput {
+    
+    serviceTemplate: ServiceTemplate | undefined;
+}
+export declare namespace UpdateServiceTemplateOutput {
+    
+    const filterSensitiveLog: (obj: UpdateServiceTemplateOutput) => any;
+}
+
+export interface CompatibleEnvironmentTemplateInput {
+    
+    templateName: string | undefined;
+    
+    majorVersion: string | undefined;
+}
+export declare namespace CompatibleEnvironmentTemplateInput {
+    
+    const filterSensitiveLog: (obj: CompatibleEnvironmentTemplateInput) => any;
+}
+export interface CreateServiceTemplateVersionInput {
+    
+    clientToken?: string;
+    
+    templateName: string | undefined;
+    
+    description?: string;
+    
+    majorVersion?: string;
+    
+    source: TemplateVersionSourceInput | undefined;
+    
+    compatibleEnvironmentTemplates: CompatibleEnvironmentTemplateInput[] | undefined;
+    
+    tags?: Tag[];
+}
+export declare namespace CreateServiceTemplateVersionInput {
+    
+    const filterSensitiveLog: (obj: CreateServiceTemplateVersionInput) => any;
+}
+
+export interface CompatibleEnvironmentTemplate {
+    
+    templateName: string | undefined;
+    
+    majorVersion: string | undefined;
+}
+export declare namespace CompatibleEnvironmentTemplate {
+    
+    const filterSensitiveLog: (obj: CompatibleEnvironmentTemplate) => any;
+}
+
+export interface ServiceTemplateVersion {
+    
+    templateName: string | undefined;
+    
+    majorVersion: string | undefined;
+    
+    minorVersion: string | undefined;
+    
+    recommendedMinorVersion?: string;
+    
+    status: TemplateVersionStatus | string | undefined;
+    
+    statusMessage?: string;
+    
+    description?: string;
+    
+    arn: string | undefined;
+    
+    createdAt: Date | undefined;
+    
+    lastModifiedAt: Date | undefined;
+    
+    compatibleEnvironmentTemplates: CompatibleEnvironmentTemplate[] | undefined;
+    
+    schema?: string;
+}
+export declare namespace ServiceTemplateVersion {
+    
+    const filterSensitiveLog: (obj: ServiceTemplateVersion) => any;
+}
+export interface CreateServiceTemplateVersionOutput {
+    
+    serviceTemplateVersion: ServiceTemplateVersion | undefined;
+}
+export declare namespace CreateServiceTemplateVersionOutput {
+    
+    const filterSensitiveLog: (obj: CreateServiceTemplateVersionOutput) => any;
+}
+export interface DeleteServiceTemplateVersionInput {
+    
+    templateName: string | undefined;
+    
+    majorVersion: string | undefined;
+    
+    minorVersion: string | undefined;
+}
+export declare namespace DeleteServiceTemplateVersionInput {
+    
+    const filterSensitiveLog: (obj: DeleteServiceTemplateVersionInput) => any;
+}
+export interface DeleteServiceTemplateVersionOutput {
+    
+    serviceTemplateVersion?: ServiceTemplateVersion;
+}
+export declare namespace DeleteServiceTemplateVersionOutput {
+    
+    const filterSensitiveLog: (obj: DeleteServiceTemplateVersionOutput) => any;
+}
+export interface GetServiceTemplateVersionInput {
+    
+    templateName: string | undefined;
+    
+    majorVersion: string | undefined;
+    
+    minorVersion: string | undefined;
+}
+export declare namespace GetServiceTemplateVersionInput {
+    
+    const filterSensitiveLog: (obj: GetServiceTemplateVersionInput) => any;
+}
+export interface GetServiceTemplateVersionOutput {
+    
+    serviceTemplateVersion: ServiceTemplateVersion | undefined;
+}
+export declare namespace GetServiceTemplateVersionOutput {
+    
+    const filterSensitiveLog: (obj: GetServiceTemplateVersionOutput) => any;
+}
+export interface ListServiceTemplateVersionsInput {
+    
+    nextToken?: string;
+    
+    maxResults?: number;
+    
+    templateName: string | undefined;
+    
+    majorVersion?: string;
+}
+export declare namespace ListServiceTemplateVersionsInput {
+    
+    const filterSensitiveLog: (obj: ListServiceTemplateVersionsInput) => any;
+}
+
+export interface ServiceTemplateVersionSummary {
+    
+    templateName: string | undefined;
+    
+    majorVersion: string | undefined;
+    
+    minorVersion: string | undefined;
+    
+    recommendedMinorVersion?: string;
+    
+    status: TemplateVersionStatus | string | undefined;
+    
+    statusMessage?: string;
+    
+    description?: string;
+    
+    arn: string | undefined;
+    
+    createdAt: Date | undefined;
+    
+    lastModifiedAt: Date | undefined;
+}
+export declare namespace ServiceTemplateVersionSummary {
+    
+    const filterSensitiveLog: (obj: ServiceTemplateVersionSummary) => any;
+}
+export interface ListServiceTemplateVersionsOutput {
+    
+    nextToken?: string;
+    
+    templateVersions: ServiceTemplateVersionSummary[] | undefined;
+}
+export declare namespace ListServiceTemplateVersionsOutput {
+    
+    const filterSensitiveLog: (obj: ListServiceTemplateVersionsOutput) => any;
+}
+export interface UpdateServiceTemplateVersionInput {
+    
+    templateName: string | undefined;
+    
+    majorVersion: string | undefined;
+    
+    minorVersion: string | undefined;
+    
+    description?: string;
+    
+    status?: TemplateVersionStatus | string;
+    
+    compatibleEnvironmentTemplates?: CompatibleEnvironmentTemplateInput[];
+}
+export declare namespace UpdateServiceTemplateVersionInput {
+    
+    const filterSensitiveLog: (obj: UpdateServiceTemplateVersionInput) => any;
+}
+export interface UpdateServiceTemplateVersionOutput {
+    
+    serviceTemplateVersion: ServiceTemplateVersion | undefined;
+}
+export declare namespace UpdateServiceTemplateVersionOutput {
+    
+    const filterSensitiveLog: (obj: UpdateServiceTemplateVersionOutput) => any;
+}
+export interface TagResourceInput {
+    
+    resourceArn: string | undefined;
+    
+    tags: Tag[] | undefined;
+}
+export declare namespace TagResourceInput {
+    
+    const filterSensitiveLog: (obj: TagResourceInput) => any;
+}
+export interface TagResourceOutput {
+}
+export declare namespace TagResourceOutput {
+    
+    const filterSensitiveLog: (obj: TagResourceOutput) => any;
+}
+export interface UntagResourceInput {
+    
+    resourceArn: string | undefined;
+    
+    tagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceInput {
+    
+    const filterSensitiveLog: (obj: UntagResourceInput) => any;
+}
+export interface UntagResourceOutput {
+}
+export declare namespace UntagResourceOutput {
+    
+    const filterSensitiveLog: (obj: UntagResourceOutput) => any;
+}