@aws-sdk/client-service-catalog 3.33.0 → 3.36.1

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

@@ -0,0 +1,3195 @@
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+export declare enum PortfolioShareType {
+    AWS_ORGANIZATIONS = "AWS_ORGANIZATIONS",
+    AWS_SERVICECATALOG = "AWS_SERVICECATALOG",
+    IMPORTED = "IMPORTED"
+}
+export interface AcceptPortfolioShareInput {
+    
+    AcceptLanguage?: string;
+    
+    PortfolioId: string | undefined;
+    
+    PortfolioShareType?: PortfolioShareType | string;
+}
+export declare namespace AcceptPortfolioShareInput {
+    
+    const filterSensitiveLog: (obj: AcceptPortfolioShareInput) => any;
+}
+export interface AcceptPortfolioShareOutput {
+}
+export declare namespace AcceptPortfolioShareOutput {
+    
+    const filterSensitiveLog: (obj: AcceptPortfolioShareOutput) => any;
+}
+
+export interface InvalidParametersException extends __SmithyException, $MetadataBearer {
+    name: "InvalidParametersException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidParametersException {
+    
+    const filterSensitiveLog: (obj: InvalidParametersException) => any;
+}
+
+export interface LimitExceededException extends __SmithyException, $MetadataBearer {
+    name: "LimitExceededException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace LimitExceededException {
+    
+    const filterSensitiveLog: (obj: LimitExceededException) => any;
+}
+
+export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace ResourceNotFoundException {
+    
+    const filterSensitiveLog: (obj: ResourceNotFoundException) => any;
+}
+export declare enum AccessLevelFilterKey {
+    ACCOUNT = "Account",
+    ROLE = "Role",
+    USER = "User"
+}
+
+export interface AccessLevelFilter {
+    
+    Key?: AccessLevelFilterKey | string;
+    
+    Value?: string;
+}
+export declare namespace AccessLevelFilter {
+    
+    const filterSensitiveLog: (obj: AccessLevelFilter) => any;
+}
+export declare enum AccessStatus {
+    DISABLED = "DISABLED",
+    ENABLED = "ENABLED",
+    UNDER_CHANGE = "UNDER_CHANGE"
+}
+
+export interface Tag {
+    
+    Key: string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace Tag {
+    
+    const filterSensitiveLog: (obj: Tag) => any;
+}
+export interface AssociateBudgetWithResourceInput {
+    
+    BudgetName: string | undefined;
+    
+    ResourceId: string | undefined;
+}
+export declare namespace AssociateBudgetWithResourceInput {
+    
+    const filterSensitiveLog: (obj: AssociateBudgetWithResourceInput) => any;
+}
+export interface AssociateBudgetWithResourceOutput {
+}
+export declare namespace AssociateBudgetWithResourceOutput {
+    
+    const filterSensitiveLog: (obj: AssociateBudgetWithResourceOutput) => any;
+}
+
+export interface DuplicateResourceException extends __SmithyException, $MetadataBearer {
+    name: "DuplicateResourceException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace DuplicateResourceException {
+    
+    const filterSensitiveLog: (obj: DuplicateResourceException) => any;
+}
+export declare enum PrincipalType {
+    IAM = "IAM"
+}
+export interface AssociatePrincipalWithPortfolioInput {
+    
+    AcceptLanguage?: string;
+    
+    PortfolioId: string | undefined;
+    
+    PrincipalARN: string | undefined;
+    
+    PrincipalType: PrincipalType | string | undefined;
+}
+export declare namespace AssociatePrincipalWithPortfolioInput {
+    
+    const filterSensitiveLog: (obj: AssociatePrincipalWithPortfolioInput) => any;
+}
+export interface AssociatePrincipalWithPortfolioOutput {
+}
+export declare namespace AssociatePrincipalWithPortfolioOutput {
+    
+    const filterSensitiveLog: (obj: AssociatePrincipalWithPortfolioOutput) => any;
+}
+export interface AssociateProductWithPortfolioInput {
+    
+    AcceptLanguage?: string;
+    
+    ProductId: string | undefined;
+    
+    PortfolioId: string | undefined;
+    
+    SourcePortfolioId?: string;
+}
+export declare namespace AssociateProductWithPortfolioInput {
+    
+    const filterSensitiveLog: (obj: AssociateProductWithPortfolioInput) => any;
+}
+export interface AssociateProductWithPortfolioOutput {
+}
+export declare namespace AssociateProductWithPortfolioOutput {
+    
+    const filterSensitiveLog: (obj: AssociateProductWithPortfolioOutput) => any;
+}
+export interface AssociateServiceActionWithProvisioningArtifactInput {
+    
+    ProductId: string | undefined;
+    
+    ProvisioningArtifactId: string | undefined;
+    
+    ServiceActionId: string | undefined;
+    
+    AcceptLanguage?: string;
+}
+export declare namespace AssociateServiceActionWithProvisioningArtifactInput {
+    
+    const filterSensitiveLog: (obj: AssociateServiceActionWithProvisioningArtifactInput) => any;
+}
+export interface AssociateServiceActionWithProvisioningArtifactOutput {
+}
+export declare namespace AssociateServiceActionWithProvisioningArtifactOutput {
+    
+    const filterSensitiveLog: (obj: AssociateServiceActionWithProvisioningArtifactOutput) => any;
+}
+export interface AssociateTagOptionWithResourceInput {
+    
+    ResourceId: string | undefined;
+    
+    TagOptionId: string | undefined;
+}
+export declare namespace AssociateTagOptionWithResourceInput {
+    
+    const filterSensitiveLog: (obj: AssociateTagOptionWithResourceInput) => any;
+}
+export interface AssociateTagOptionWithResourceOutput {
+}
+export declare namespace AssociateTagOptionWithResourceOutput {
+    
+    const filterSensitiveLog: (obj: AssociateTagOptionWithResourceOutput) => any;
+}
+
+export interface InvalidStateException extends __SmithyException, $MetadataBearer {
+    name: "InvalidStateException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace InvalidStateException {
+    
+    const filterSensitiveLog: (obj: InvalidStateException) => any;
+}
+
+export interface TagOptionNotMigratedException extends __SmithyException, $MetadataBearer {
+    name: "TagOptionNotMigratedException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace TagOptionNotMigratedException {
+    
+    const filterSensitiveLog: (obj: TagOptionNotMigratedException) => any;
+}
+
+export interface ServiceActionAssociation {
+    
+    ServiceActionId: string | undefined;
+    
+    ProductId: string | undefined;
+    
+    ProvisioningArtifactId: string | undefined;
+}
+export declare namespace ServiceActionAssociation {
+    
+    const filterSensitiveLog: (obj: ServiceActionAssociation) => any;
+}
+export interface BatchAssociateServiceActionWithProvisioningArtifactInput {
+    
+    ServiceActionAssociations: ServiceActionAssociation[] | undefined;
+    
+    AcceptLanguage?: string;
+}
+export declare namespace BatchAssociateServiceActionWithProvisioningArtifactInput {
+    
+    const filterSensitiveLog: (obj: BatchAssociateServiceActionWithProvisioningArtifactInput) => any;
+}
+export declare enum ServiceActionAssociationErrorCode {
+    DuplicateResourceException = "DUPLICATE_RESOURCE",
+    InternalFailure = "INTERNAL_FAILURE",
+    LimitExceededException = "LIMIT_EXCEEDED",
+    ResourceNotFoundException = "RESOURCE_NOT_FOUND",
+    ThrottlingException = "THROTTLING"
+}
+
+export interface FailedServiceActionAssociation {
+    
+    ServiceActionId?: string;
+    
+    ProductId?: string;
+    
+    ProvisioningArtifactId?: string;
+    
+    ErrorCode?: ServiceActionAssociationErrorCode | string;
+    
+    ErrorMessage?: string;
+}
+export declare namespace FailedServiceActionAssociation {
+    
+    const filterSensitiveLog: (obj: FailedServiceActionAssociation) => any;
+}
+export interface BatchAssociateServiceActionWithProvisioningArtifactOutput {
+    
+    FailedServiceActionAssociations?: FailedServiceActionAssociation[];
+}
+export declare namespace BatchAssociateServiceActionWithProvisioningArtifactOutput {
+    
+    const filterSensitiveLog: (obj: BatchAssociateServiceActionWithProvisioningArtifactOutput) => any;
+}
+export interface BatchDisassociateServiceActionFromProvisioningArtifactInput {
+    
+    ServiceActionAssociations: ServiceActionAssociation[] | undefined;
+    
+    AcceptLanguage?: string;
+}
+export declare namespace BatchDisassociateServiceActionFromProvisioningArtifactInput {
+    
+    const filterSensitiveLog: (obj: BatchDisassociateServiceActionFromProvisioningArtifactInput) => any;
+}
+export interface BatchDisassociateServiceActionFromProvisioningArtifactOutput {
+    
+    FailedServiceActionAssociations?: FailedServiceActionAssociation[];
+}
+export declare namespace BatchDisassociateServiceActionFromProvisioningArtifactOutput {
+    
+    const filterSensitiveLog: (obj: BatchDisassociateServiceActionFromProvisioningArtifactOutput) => any;
+}
+export declare enum CopyOption {
+    CopyTags = "CopyTags"
+}
+export declare enum ProvisioningArtifactPropertyName {
+    Id = "Id"
+}
+export interface CopyProductInput {
+    
+    AcceptLanguage?: string;
+    
+    SourceProductArn: string | undefined;
+    
+    TargetProductId?: string;
+    
+    TargetProductName?: string;
+    
+    SourceProvisioningArtifactIdentifiers?: {
+        [key: string]: string;
+    }[];
+    
+    CopyOptions?: (CopyOption | string)[];
+    
+    IdempotencyToken?: string;
+}
+export declare namespace CopyProductInput {
+    
+    const filterSensitiveLog: (obj: CopyProductInput) => any;
+}
+export interface CopyProductOutput {
+    
+    CopyProductToken?: string;
+}
+export declare namespace CopyProductOutput {
+    
+    const filterSensitiveLog: (obj: CopyProductOutput) => any;
+}
+export interface CreateConstraintInput {
+    
+    AcceptLanguage?: string;
+    
+    PortfolioId: string | undefined;
+    
+    ProductId: string | undefined;
+    
+    Parameters: string | undefined;
+    
+    Type: string | undefined;
+    
+    Description?: string;
+    
+    IdempotencyToken?: string;
+}
+export declare namespace CreateConstraintInput {
+    
+    const filterSensitiveLog: (obj: CreateConstraintInput) => any;
+}
+
+export interface ConstraintDetail {
+    
+    ConstraintId?: string;
+    
+    Type?: string;
+    
+    Description?: string;
+    
+    Owner?: string;
+    
+    ProductId?: string;
+    
+    PortfolioId?: string;
+}
+export declare namespace ConstraintDetail {
+    
+    const filterSensitiveLog: (obj: ConstraintDetail) => any;
+}
+export declare enum Status {
+    AVAILABLE = "AVAILABLE",
+    CREATING = "CREATING",
+    FAILED = "FAILED"
+}
+export interface CreateConstraintOutput {
+    
+    ConstraintDetail?: ConstraintDetail;
+    
+    ConstraintParameters?: string;
+    
+    Status?: Status | string;
+}
+export declare namespace CreateConstraintOutput {
+    
+    const filterSensitiveLog: (obj: CreateConstraintOutput) => any;
+}
+export interface CreatePortfolioInput {
+    
+    AcceptLanguage?: string;
+    
+    DisplayName: string | undefined;
+    
+    Description?: string;
+    
+    ProviderName: string | undefined;
+    
+    Tags?: Tag[];
+    
+    IdempotencyToken?: string;
+}
+export declare namespace CreatePortfolioInput {
+    
+    const filterSensitiveLog: (obj: CreatePortfolioInput) => any;
+}
+
+export interface PortfolioDetail {
+    
+    Id?: string;
+    
+    ARN?: string;
+    
+    DisplayName?: string;
+    
+    Description?: string;
+    
+    CreatedTime?: Date;
+    
+    ProviderName?: string;
+}
+export declare namespace PortfolioDetail {
+    
+    const filterSensitiveLog: (obj: PortfolioDetail) => any;
+}
+export interface CreatePortfolioOutput {
+    
+    PortfolioDetail?: PortfolioDetail;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreatePortfolioOutput {
+    
+    const filterSensitiveLog: (obj: CreatePortfolioOutput) => any;
+}
+export declare enum OrganizationNodeType {
+    ACCOUNT = "ACCOUNT",
+    ORGANIZATION = "ORGANIZATION",
+    ORGANIZATIONAL_UNIT = "ORGANIZATIONAL_UNIT"
+}
+
+export interface OrganizationNode {
+    
+    Type?: OrganizationNodeType | string;
+    
+    Value?: string;
+}
+export declare namespace OrganizationNode {
+    
+    const filterSensitiveLog: (obj: OrganizationNode) => any;
+}
+export interface CreatePortfolioShareInput {
+    
+    AcceptLanguage?: string;
+    
+    PortfolioId: string | undefined;
+    
+    AccountId?: string;
+    
+    OrganizationNode?: OrganizationNode;
+    
+    ShareTagOptions?: boolean;
+}
+export declare namespace CreatePortfolioShareInput {
+    
+    const filterSensitiveLog: (obj: CreatePortfolioShareInput) => any;
+}
+export interface CreatePortfolioShareOutput {
+    
+    PortfolioShareToken?: string;
+}
+export declare namespace CreatePortfolioShareOutput {
+    
+    const filterSensitiveLog: (obj: CreatePortfolioShareOutput) => any;
+}
+
+export interface OperationNotSupportedException extends __SmithyException, $MetadataBearer {
+    name: "OperationNotSupportedException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace OperationNotSupportedException {
+    
+    const filterSensitiveLog: (obj: OperationNotSupportedException) => any;
+}
+export declare enum ProductType {
+    CLOUD_FORMATION_TEMPLATE = "CLOUD_FORMATION_TEMPLATE",
+    MARKETPLACE = "MARKETPLACE"
+}
+export declare enum ProvisioningArtifactType {
+    CLOUD_FORMATION_TEMPLATE = "CLOUD_FORMATION_TEMPLATE",
+    MARKETPLACE_AMI = "MARKETPLACE_AMI",
+    MARKETPLACE_CAR = "MARKETPLACE_CAR"
+}
+
+export interface ProvisioningArtifactProperties {
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    Info: {
+        [key: string]: string;
+    } | undefined;
+    
+    Type?: ProvisioningArtifactType | string;
+    
+    DisableTemplateValidation?: boolean;
+}
+export declare namespace ProvisioningArtifactProperties {
+    
+    const filterSensitiveLog: (obj: ProvisioningArtifactProperties) => any;
+}
+export interface CreateProductInput {
+    
+    AcceptLanguage?: string;
+    
+    Name: string | undefined;
+    
+    Owner: string | undefined;
+    
+    Description?: string;
+    
+    Distributor?: string;
+    
+    SupportDescription?: string;
+    
+    SupportEmail?: string;
+    
+    SupportUrl?: string;
+    
+    ProductType: ProductType | string | undefined;
+    
+    Tags?: Tag[];
+    
+    ProvisioningArtifactParameters: ProvisioningArtifactProperties | undefined;
+    
+    IdempotencyToken?: string;
+}
+export declare namespace CreateProductInput {
+    
+    const filterSensitiveLog: (obj: CreateProductInput) => any;
+}
+
+export interface ProductViewSummary {
+    
+    Id?: string;
+    
+    ProductId?: string;
+    
+    Name?: string;
+    
+    Owner?: string;
+    
+    ShortDescription?: string;
+    
+    Type?: ProductType | string;
+    
+    Distributor?: string;
+    
+    HasDefaultPath?: boolean;
+    
+    SupportEmail?: string;
+    
+    SupportDescription?: string;
+    
+    SupportUrl?: string;
+}
+export declare namespace ProductViewSummary {
+    
+    const filterSensitiveLog: (obj: ProductViewSummary) => any;
+}
+
+export interface ProductViewDetail {
+    
+    ProductViewSummary?: ProductViewSummary;
+    
+    Status?: Status | string;
+    
+    ProductARN?: string;
+    
+    CreatedTime?: Date;
+}
+export declare namespace ProductViewDetail {
+    
+    const filterSensitiveLog: (obj: ProductViewDetail) => any;
+}
+export declare enum ProvisioningArtifactGuidance {
+    DEFAULT = "DEFAULT",
+    DEPRECATED = "DEPRECATED"
+}
+
+export interface ProvisioningArtifactDetail {
+    
+    Id?: string;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    Type?: ProvisioningArtifactType | string;
+    
+    CreatedTime?: Date;
+    
+    Active?: boolean;
+    
+    Guidance?: ProvisioningArtifactGuidance | string;
+}
+export declare namespace ProvisioningArtifactDetail {
+    
+    const filterSensitiveLog: (obj: ProvisioningArtifactDetail) => any;
+}
+export interface CreateProductOutput {
+    
+    ProductViewDetail?: ProductViewDetail;
+    
+    ProvisioningArtifactDetail?: ProvisioningArtifactDetail;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateProductOutput {
+    
+    const filterSensitiveLog: (obj: CreateProductOutput) => any;
+}
+export declare enum ProvisionedProductPlanType {
+    CLOUDFORMATION = "CLOUDFORMATION"
+}
+
+export interface UpdateProvisioningParameter {
+    
+    Key?: string;
+    
+    Value?: string;
+    
+    UsePreviousValue?: boolean;
+}
+export declare namespace UpdateProvisioningParameter {
+    
+    const filterSensitiveLog: (obj: UpdateProvisioningParameter) => any;
+}
+export interface CreateProvisionedProductPlanInput {
+    
+    AcceptLanguage?: string;
+    
+    PlanName: string | undefined;
+    
+    PlanType: ProvisionedProductPlanType | string | undefined;
+    
+    NotificationArns?: string[];
+    
+    PathId?: string;
+    
+    ProductId: string | undefined;
+    
+    ProvisionedProductName: string | undefined;
+    
+    ProvisioningArtifactId: string | undefined;
+    
+    ProvisioningParameters?: UpdateProvisioningParameter[];
+    
+    IdempotencyToken?: string;
+    
+    Tags?: Tag[];
+}
+export declare namespace CreateProvisionedProductPlanInput {
+    
+    const filterSensitiveLog: (obj: CreateProvisionedProductPlanInput) => any;
+}
+export interface CreateProvisionedProductPlanOutput {
+    
+    PlanName?: string;
+    
+    PlanId?: string;
+    
+    ProvisionProductId?: string;
+    
+    ProvisionedProductName?: string;
+    
+    ProvisioningArtifactId?: string;
+}
+export declare namespace CreateProvisionedProductPlanOutput {
+    
+    const filterSensitiveLog: (obj: CreateProvisionedProductPlanOutput) => any;
+}
+export interface CreateProvisioningArtifactInput {
+    
+    AcceptLanguage?: string;
+    
+    ProductId: string | undefined;
+    
+    Parameters: ProvisioningArtifactProperties | undefined;
+    
+    IdempotencyToken?: string;
+}
+export declare namespace CreateProvisioningArtifactInput {
+    
+    const filterSensitiveLog: (obj: CreateProvisioningArtifactInput) => any;
+}
+export interface CreateProvisioningArtifactOutput {
+    
+    ProvisioningArtifactDetail?: ProvisioningArtifactDetail;
+    
+    Info?: {
+        [key: string]: string;
+    };
+    
+    Status?: Status | string;
+}
+export declare namespace CreateProvisioningArtifactOutput {
+    
+    const filterSensitiveLog: (obj: CreateProvisioningArtifactOutput) => any;
+}
+export declare enum ServiceActionDefinitionKey {
+    AssumeRole = "AssumeRole",
+    Name = "Name",
+    Parameters = "Parameters",
+    Version = "Version"
+}
+export declare enum ServiceActionDefinitionType {
+    SsmAutomation = "SSM_AUTOMATION"
+}
+export interface CreateServiceActionInput {
+    
+    Name: string | undefined;
+    
+    DefinitionType: ServiceActionDefinitionType | string | undefined;
+    
+    Definition: {
+        [key: string]: string;
+    } | undefined;
+    
+    Description?: string;
+    
+    AcceptLanguage?: string;
+    
+    IdempotencyToken?: string;
+}
+export declare namespace CreateServiceActionInput {
+    
+    const filterSensitiveLog: (obj: CreateServiceActionInput) => any;
+}
+
+export interface ServiceActionSummary {
+    
+    Id?: string;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    DefinitionType?: ServiceActionDefinitionType | string;
+}
+export declare namespace ServiceActionSummary {
+    
+    const filterSensitiveLog: (obj: ServiceActionSummary) => any;
+}
+
+export interface ServiceActionDetail {
+    
+    ServiceActionSummary?: ServiceActionSummary;
+    
+    Definition?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ServiceActionDetail {
+    
+    const filterSensitiveLog: (obj: ServiceActionDetail) => any;
+}
+export interface CreateServiceActionOutput {
+    
+    ServiceActionDetail?: ServiceActionDetail;
+}
+export declare namespace CreateServiceActionOutput {
+    
+    const filterSensitiveLog: (obj: CreateServiceActionOutput) => any;
+}
+export interface CreateTagOptionInput {
+    
+    Key: string | undefined;
+    
+    Value: string | undefined;
+}
+export declare namespace CreateTagOptionInput {
+    
+    const filterSensitiveLog: (obj: CreateTagOptionInput) => any;
+}
+
+export interface TagOptionDetail {
+    
+    Key?: string;
+    
+    Value?: string;
+    
+    Active?: boolean;
+    
+    Id?: string;
+    
+    Owner?: string;
+}
+export declare namespace TagOptionDetail {
+    
+    const filterSensitiveLog: (obj: TagOptionDetail) => any;
+}
+export interface CreateTagOptionOutput {
+    
+    TagOptionDetail?: TagOptionDetail;
+}
+export declare namespace CreateTagOptionOutput {
+    
+    const filterSensitiveLog: (obj: CreateTagOptionOutput) => any;
+}
+export interface DeleteConstraintInput {
+    
+    AcceptLanguage?: string;
+    
+    Id: string | undefined;
+}
+export declare namespace DeleteConstraintInput {
+    
+    const filterSensitiveLog: (obj: DeleteConstraintInput) => any;
+}
+export interface DeleteConstraintOutput {
+}
+export declare namespace DeleteConstraintOutput {
+    
+    const filterSensitiveLog: (obj: DeleteConstraintOutput) => any;
+}
+export interface DeletePortfolioInput {
+    
+    AcceptLanguage?: string;
+    
+    Id: string | undefined;
+}
+export declare namespace DeletePortfolioInput {
+    
+    const filterSensitiveLog: (obj: DeletePortfolioInput) => any;
+}
+export interface DeletePortfolioOutput {
+}
+export declare namespace DeletePortfolioOutput {
+    
+    const filterSensitiveLog: (obj: DeletePortfolioOutput) => any;
+}
+
+export interface ResourceInUseException extends __SmithyException, $MetadataBearer {
+    name: "ResourceInUseException";
+    $fault: "client";
+    Message?: string;
+}
+export declare namespace ResourceInUseException {
+    
+    const filterSensitiveLog: (obj: ResourceInUseException) => any;
+}
+export interface DeletePortfolioShareInput {
+    
+    AcceptLanguage?: string;
+    
+    PortfolioId: string | undefined;
+    
+    AccountId?: string;
+    
+    OrganizationNode?: OrganizationNode;
+}
+export declare namespace DeletePortfolioShareInput {
+    
+    const filterSensitiveLog: (obj: DeletePortfolioShareInput) => any;
+}
+export interface DeletePortfolioShareOutput {
+    
+    PortfolioShareToken?: string;
+}
+export declare namespace DeletePortfolioShareOutput {
+    
+    const filterSensitiveLog: (obj: DeletePortfolioShareOutput) => any;
+}
+export interface DeleteProductInput {
+    
+    AcceptLanguage?: string;
+    
+    Id: string | undefined;
+}
+export declare namespace DeleteProductInput {
+    
+    const filterSensitiveLog: (obj: DeleteProductInput) => any;
+}
+export interface DeleteProductOutput {
+}
+export declare namespace DeleteProductOutput {
+    
+    const filterSensitiveLog: (obj: DeleteProductOutput) => any;
+}
+export interface DeleteProvisionedProductPlanInput {
+    
+    AcceptLanguage?: string;
+    
+    PlanId: string | undefined;
+    
+    IgnoreErrors?: boolean;
+}
+export declare namespace DeleteProvisionedProductPlanInput {
+    
+    const filterSensitiveLog: (obj: DeleteProvisionedProductPlanInput) => any;
+}
+export interface DeleteProvisionedProductPlanOutput {
+}
+export declare namespace DeleteProvisionedProductPlanOutput {
+    
+    const filterSensitiveLog: (obj: DeleteProvisionedProductPlanOutput) => any;
+}
+export interface DeleteProvisioningArtifactInput {
+    
+    AcceptLanguage?: string;
+    
+    ProductId: string | undefined;
+    
+    ProvisioningArtifactId: string | undefined;
+}
+export declare namespace DeleteProvisioningArtifactInput {
+    
+    const filterSensitiveLog: (obj: DeleteProvisioningArtifactInput) => any;
+}
+export interface DeleteProvisioningArtifactOutput {
+}
+export declare namespace DeleteProvisioningArtifactOutput {
+    
+    const filterSensitiveLog: (obj: DeleteProvisioningArtifactOutput) => any;
+}
+export interface DeleteServiceActionInput {
+    
+    Id: string | undefined;
+    
+    AcceptLanguage?: string;
+}
+export declare namespace DeleteServiceActionInput {
+    
+    const filterSensitiveLog: (obj: DeleteServiceActionInput) => any;
+}
+export interface DeleteServiceActionOutput {
+}
+export declare namespace DeleteServiceActionOutput {
+    
+    const filterSensitiveLog: (obj: DeleteServiceActionOutput) => any;
+}
+export interface DeleteTagOptionInput {
+    
+    Id: string | undefined;
+}
+export declare namespace DeleteTagOptionInput {
+    
+    const filterSensitiveLog: (obj: DeleteTagOptionInput) => any;
+}
+export interface DeleteTagOptionOutput {
+}
+export declare namespace DeleteTagOptionOutput {
+    
+    const filterSensitiveLog: (obj: DeleteTagOptionOutput) => any;
+}
+export interface DescribeConstraintInput {
+    
+    AcceptLanguage?: string;
+    
+    Id: string | undefined;
+}
+export declare namespace DescribeConstraintInput {
+    
+    const filterSensitiveLog: (obj: DescribeConstraintInput) => any;
+}
+export interface DescribeConstraintOutput {
+    
+    ConstraintDetail?: ConstraintDetail;
+    
+    ConstraintParameters?: string;
+    
+    Status?: Status | string;
+}
+export declare namespace DescribeConstraintOutput {
+    
+    const filterSensitiveLog: (obj: DescribeConstraintOutput) => any;
+}
+export interface DescribeCopyProductStatusInput {
+    
+    AcceptLanguage?: string;
+    
+    CopyProductToken: string | undefined;
+}
+export declare namespace DescribeCopyProductStatusInput {
+    
+    const filterSensitiveLog: (obj: DescribeCopyProductStatusInput) => any;
+}
+export declare enum CopyProductStatus {
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    SUCCEEDED = "SUCCEEDED"
+}
+export interface DescribeCopyProductStatusOutput {
+    
+    CopyProductStatus?: CopyProductStatus | string;
+    
+    TargetProductId?: string;
+    
+    StatusDetail?: string;
+}
+export declare namespace DescribeCopyProductStatusOutput {
+    
+    const filterSensitiveLog: (obj: DescribeCopyProductStatusOutput) => any;
+}
+export interface DescribePortfolioInput {
+    
+    AcceptLanguage?: string;
+    
+    Id: string | undefined;
+}
+export declare namespace DescribePortfolioInput {
+    
+    const filterSensitiveLog: (obj: DescribePortfolioInput) => any;
+}
+
+export interface BudgetDetail {
+    
+    BudgetName?: string;
+}
+export declare namespace BudgetDetail {
+    
+    const filterSensitiveLog: (obj: BudgetDetail) => any;
+}
+export interface DescribePortfolioOutput {
+    
+    PortfolioDetail?: PortfolioDetail;
+    
+    Tags?: Tag[];
+    
+    TagOptions?: TagOptionDetail[];
+    
+    Budgets?: BudgetDetail[];
+}
+export declare namespace DescribePortfolioOutput {
+    
+    const filterSensitiveLog: (obj: DescribePortfolioOutput) => any;
+}
+export declare enum DescribePortfolioShareType {
+    ACCOUNT = "ACCOUNT",
+    ORGANIZATION = "ORGANIZATION",
+    ORGANIZATIONAL_UNIT = "ORGANIZATIONAL_UNIT",
+    ORGANIZATION_MEMBER_ACCOUNT = "ORGANIZATION_MEMBER_ACCOUNT"
+}
+export interface DescribePortfolioSharesInput {
+    
+    PortfolioId: string | undefined;
+    
+    Type: DescribePortfolioShareType | string | undefined;
+    
+    PageToken?: string;
+    
+    PageSize?: number;
+}
+export declare namespace DescribePortfolioSharesInput {
+    
+    const filterSensitiveLog: (obj: DescribePortfolioSharesInput) => any;
+}
+
+export interface PortfolioShareDetail {
+    
+    PrincipalId?: string;
+    
+    Type?: DescribePortfolioShareType | string;
+    
+    Accepted?: boolean;
+    
+    ShareTagOptions?: boolean;
+}
+export declare namespace PortfolioShareDetail {
+    
+    const filterSensitiveLog: (obj: PortfolioShareDetail) => any;
+}
+export interface DescribePortfolioSharesOutput {
+    
+    NextPageToken?: string;
+    
+    PortfolioShareDetails?: PortfolioShareDetail[];
+}
+export declare namespace DescribePortfolioSharesOutput {
+    
+    const filterSensitiveLog: (obj: DescribePortfolioSharesOutput) => any;
+}
+export interface DescribePortfolioShareStatusInput {
+    
+    PortfolioShareToken: string | undefined;
+}
+export declare namespace DescribePortfolioShareStatusInput {
+    
+    const filterSensitiveLog: (obj: DescribePortfolioShareStatusInput) => any;
+}
+
+export interface ShareError {
+    
+    Accounts?: string[];
+    
+    Message?: string;
+    
+    Error?: string;
+}
+export declare namespace ShareError {
+    
+    const filterSensitiveLog: (obj: ShareError) => any;
+}
+
+export interface ShareDetails {
+    
+    SuccessfulShares?: string[];
+    
+    ShareErrors?: ShareError[];
+}
+export declare namespace ShareDetails {
+    
+    const filterSensitiveLog: (obj: ShareDetails) => any;
+}
+export declare enum ShareStatus {
+    COMPLETED = "COMPLETED",
+    COMPLETED_WITH_ERRORS = "COMPLETED_WITH_ERRORS",
+    ERROR = "ERROR",
+    IN_PROGRESS = "IN_PROGRESS",
+    NOT_STARTED = "NOT_STARTED"
+}
+export interface DescribePortfolioShareStatusOutput {
+    
+    PortfolioShareToken?: string;
+    
+    PortfolioId?: string;
+    
+    OrganizationNodeValue?: string;
+    
+    Status?: ShareStatus | string;
+    
+    ShareDetails?: ShareDetails;
+}
+export declare namespace DescribePortfolioShareStatusOutput {
+    
+    const filterSensitiveLog: (obj: DescribePortfolioShareStatusOutput) => any;
+}
+export interface DescribeProductInput {
+    
+    AcceptLanguage?: string;
+    
+    Id?: string;
+    
+    Name?: string;
+}
+export declare namespace DescribeProductInput {
+    
+    const filterSensitiveLog: (obj: DescribeProductInput) => any;
+}
+
+export interface LaunchPath {
+    
+    Id?: string;
+    
+    Name?: string;
+}
+export declare namespace LaunchPath {
+    
+    const filterSensitiveLog: (obj: LaunchPath) => any;
+}
+
+export interface ProvisioningArtifact {
+    
+    Id?: string;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    CreatedTime?: Date;
+    
+    Guidance?: ProvisioningArtifactGuidance | string;
+}
+export declare namespace ProvisioningArtifact {
+    
+    const filterSensitiveLog: (obj: ProvisioningArtifact) => any;
+}
+export interface DescribeProductOutput {
+    
+    ProductViewSummary?: ProductViewSummary;
+    
+    ProvisioningArtifacts?: ProvisioningArtifact[];
+    
+    Budgets?: BudgetDetail[];
+    
+    LaunchPaths?: LaunchPath[];
+}
+export declare namespace DescribeProductOutput {
+    
+    const filterSensitiveLog: (obj: DescribeProductOutput) => any;
+}
+export interface DescribeProductAsAdminInput {
+    
+    AcceptLanguage?: string;
+    
+    Id?: string;
+    
+    Name?: string;
+    
+    SourcePortfolioId?: string;
+}
+export declare namespace DescribeProductAsAdminInput {
+    
+    const filterSensitiveLog: (obj: DescribeProductAsAdminInput) => any;
+}
+
+export interface ProvisioningArtifactSummary {
+    
+    Id?: string;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    CreatedTime?: Date;
+    
+    ProvisioningArtifactMetadata?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ProvisioningArtifactSummary {
+    
+    const filterSensitiveLog: (obj: ProvisioningArtifactSummary) => any;
+}
+export interface DescribeProductAsAdminOutput {
+    
+    ProductViewDetail?: ProductViewDetail;
+    
+    ProvisioningArtifactSummaries?: ProvisioningArtifactSummary[];
+    
+    Tags?: Tag[];
+    
+    TagOptions?: TagOptionDetail[];
+    
+    Budgets?: BudgetDetail[];
+}
+export declare namespace DescribeProductAsAdminOutput {
+    
+    const filterSensitiveLog: (obj: DescribeProductAsAdminOutput) => any;
+}
+export interface DescribeProductViewInput {
+    
+    AcceptLanguage?: string;
+    
+    Id: string | undefined;
+}
+export declare namespace DescribeProductViewInput {
+    
+    const filterSensitiveLog: (obj: DescribeProductViewInput) => any;
+}
+export interface DescribeProductViewOutput {
+    
+    ProductViewSummary?: ProductViewSummary;
+    
+    ProvisioningArtifacts?: ProvisioningArtifact[];
+}
+export declare namespace DescribeProductViewOutput {
+    
+    const filterSensitiveLog: (obj: DescribeProductViewOutput) => any;
+}
+
+export interface DescribeProvisionedProductInput {
+    
+    AcceptLanguage?: string;
+    
+    Id?: string;
+    
+    Name?: string;
+}
+export declare namespace DescribeProvisionedProductInput {
+    
+    const filterSensitiveLog: (obj: DescribeProvisionedProductInput) => any;
+}
+
+export interface CloudWatchDashboard {
+    
+    Name?: string;
+}
+export declare namespace CloudWatchDashboard {
+    
+    const filterSensitiveLog: (obj: CloudWatchDashboard) => any;
+}
+export declare enum ProvisionedProductStatus {
+    AVAILABLE = "AVAILABLE",
+    ERROR = "ERROR",
+    PLAN_IN_PROGRESS = "PLAN_IN_PROGRESS",
+    TAINTED = "TAINTED",
+    UNDER_CHANGE = "UNDER_CHANGE"
+}
+
+export interface ProvisionedProductDetail {
+    
+    Name?: string;
+    
+    Arn?: string;
+    
+    Type?: string;
+    
+    Id?: string;
+    
+    Status?: ProvisionedProductStatus | string;
+    
+    StatusMessage?: string;
+    
+    CreatedTime?: Date;
+    
+    IdempotencyToken?: string;
+    
+    LastRecordId?: string;
+    
+    LastProvisioningRecordId?: string;
+    
+    LastSuccessfulProvisioningRecordId?: string;
+    
+    ProductId?: string;
+    
+    ProvisioningArtifactId?: string;
+    
+    LaunchRoleArn?: string;
+}
+export declare namespace ProvisionedProductDetail {
+    
+    const filterSensitiveLog: (obj: ProvisionedProductDetail) => any;
+}
+export interface DescribeProvisionedProductOutput {
+    
+    ProvisionedProductDetail?: ProvisionedProductDetail;
+    
+    CloudWatchDashboards?: CloudWatchDashboard[];
+}
+export declare namespace DescribeProvisionedProductOutput {
+    
+    const filterSensitiveLog: (obj: DescribeProvisionedProductOutput) => any;
+}
+export interface DescribeProvisionedProductPlanInput {
+    
+    AcceptLanguage?: string;
+    
+    PlanId: string | undefined;
+    
+    PageSize?: number;
+    
+    PageToken?: string;
+}
+export declare namespace DescribeProvisionedProductPlanInput {
+    
+    const filterSensitiveLog: (obj: DescribeProvisionedProductPlanInput) => any;
+}
+export declare enum ProvisionedProductPlanStatus {
+    CREATE_FAILED = "CREATE_FAILED",
+    CREATE_IN_PROGRESS = "CREATE_IN_PROGRESS",
+    CREATE_SUCCESS = "CREATE_SUCCESS",
+    EXECUTE_FAILED = "EXECUTE_FAILED",
+    EXECUTE_IN_PROGRESS = "EXECUTE_IN_PROGRESS",
+    EXECUTE_SUCCESS = "EXECUTE_SUCCESS"
+}
+
+export interface ProvisionedProductPlanDetails {
+    
+    CreatedTime?: Date;
+    
+    PathId?: string;
+    
+    ProductId?: string;
+    
+    PlanName?: string;
+    
+    PlanId?: string;
+    
+    ProvisionProductId?: string;
+    
+    ProvisionProductName?: string;
+    
+    PlanType?: ProvisionedProductPlanType | string;
+    
+    ProvisioningArtifactId?: string;
+    
+    Status?: ProvisionedProductPlanStatus | string;
+    
+    UpdatedTime?: Date;
+    
+    NotificationArns?: string[];
+    
+    ProvisioningParameters?: UpdateProvisioningParameter[];
+    
+    Tags?: Tag[];
+    
+    StatusMessage?: string;
+}
+export declare namespace ProvisionedProductPlanDetails {
+    
+    const filterSensitiveLog: (obj: ProvisionedProductPlanDetails) => any;
+}
+export declare enum ChangeAction {
+    ADD = "ADD",
+    MODIFY = "MODIFY",
+    REMOVE = "REMOVE"
+}
+export declare enum EvaluationType {
+    DYNAMIC = "DYNAMIC",
+    STATIC = "STATIC"
+}
+export declare enum ResourceAttribute {
+    CREATIONPOLICY = "CREATIONPOLICY",
+    DELETIONPOLICY = "DELETIONPOLICY",
+    METADATA = "METADATA",
+    PROPERTIES = "PROPERTIES",
+    TAGS = "TAGS",
+    UPDATEPOLICY = "UPDATEPOLICY"
+}
+export declare enum RequiresRecreation {
+    ALWAYS = "ALWAYS",
+    CONDITIONALLY = "CONDITIONALLY",
+    NEVER = "NEVER"
+}
+
+export interface ResourceTargetDefinition {
+    
+    Attribute?: ResourceAttribute | string;
+    
+    Name?: string;
+    
+    RequiresRecreation?: RequiresRecreation | string;
+}
+export declare namespace ResourceTargetDefinition {
+    
+    const filterSensitiveLog: (obj: ResourceTargetDefinition) => any;
+}
+
+export interface ResourceChangeDetail {
+    
+    Target?: ResourceTargetDefinition;
+    
+    Evaluation?: EvaluationType | string;
+    
+    CausingEntity?: string;
+}
+export declare namespace ResourceChangeDetail {
+    
+    const filterSensitiveLog: (obj: ResourceChangeDetail) => any;
+}
+export declare enum Replacement {
+    CONDITIONAL = "CONDITIONAL",
+    FALSE = "FALSE",
+    TRUE = "TRUE"
+}
+
+export interface ResourceChange {
+    
+    Action?: ChangeAction | string;
+    
+    LogicalResourceId?: string;
+    
+    PhysicalResourceId?: string;
+    
+    ResourceType?: string;
+    
+    Replacement?: Replacement | string;
+    
+    Scope?: (ResourceAttribute | string)[];
+    
+    Details?: ResourceChangeDetail[];
+}
+export declare namespace ResourceChange {
+    
+    const filterSensitiveLog: (obj: ResourceChange) => any;
+}
+export interface DescribeProvisionedProductPlanOutput {
+    
+    ProvisionedProductPlanDetails?: ProvisionedProductPlanDetails;
+    
+    ResourceChanges?: ResourceChange[];
+    
+    NextPageToken?: string;
+}
+export declare namespace DescribeProvisionedProductPlanOutput {
+    
+    const filterSensitiveLog: (obj: DescribeProvisionedProductPlanOutput) => any;
+}
+export interface DescribeProvisioningArtifactInput {
+    
+    AcceptLanguage?: string;
+    
+    ProvisioningArtifactId?: string;
+    
+    ProductId?: string;
+    
+    ProvisioningArtifactName?: string;
+    
+    ProductName?: string;
+    
+    Verbose?: boolean;
+}
+export declare namespace DescribeProvisioningArtifactInput {
+    
+    const filterSensitiveLog: (obj: DescribeProvisioningArtifactInput) => any;
+}
+export interface DescribeProvisioningArtifactOutput {
+    
+    ProvisioningArtifactDetail?: ProvisioningArtifactDetail;
+    
+    Info?: {
+        [key: string]: string;
+    };
+    
+    Status?: Status | string;
+}
+export declare namespace DescribeProvisioningArtifactOutput {
+    
+    const filterSensitiveLog: (obj: DescribeProvisioningArtifactOutput) => any;
+}
+export interface DescribeProvisioningParametersInput {
+    
+    AcceptLanguage?: string;
+    
+    ProductId?: string;
+    
+    ProductName?: string;
+    
+    ProvisioningArtifactId?: string;
+    
+    ProvisioningArtifactName?: string;
+    
+    PathId?: string;
+    
+    PathName?: string;
+}
+export declare namespace DescribeProvisioningParametersInput {
+    
+    const filterSensitiveLog: (obj: DescribeProvisioningParametersInput) => any;
+}
+
+export interface ConstraintSummary {
+    
+    Type?: string;
+    
+    Description?: string;
+}
+export declare namespace ConstraintSummary {
+    
+    const filterSensitiveLog: (obj: ConstraintSummary) => any;
+}
+
+export interface ProvisioningArtifactOutput {
+    
+    Key?: string;
+    
+    Description?: string;
+}
+export declare namespace ProvisioningArtifactOutput {
+    
+    const filterSensitiveLog: (obj: ProvisioningArtifactOutput) => any;
+}
+
+export interface ParameterConstraints {
+    
+    AllowedValues?: string[];
+    
+    AllowedPattern?: string;
+    
+    ConstraintDescription?: string;
+    
+    MaxLength?: string;
+    
+    MinLength?: string;
+    
+    MaxValue?: string;
+    
+    MinValue?: string;
+}
+export declare namespace ParameterConstraints {
+    
+    const filterSensitiveLog: (obj: ParameterConstraints) => any;
+}
+
+export interface ProvisioningArtifactParameter {
+    
+    ParameterKey?: string;
+    
+    DefaultValue?: string;
+    
+    ParameterType?: string;
+    
+    IsNoEcho?: boolean;
+    
+    Description?: string;
+    
+    ParameterConstraints?: ParameterConstraints;
+}
+export declare namespace ProvisioningArtifactParameter {
+    
+    const filterSensitiveLog: (obj: ProvisioningArtifactParameter) => any;
+}
+
+export interface ProvisioningArtifactPreferences {
+    
+    StackSetAccounts?: string[];
+    
+    StackSetRegions?: string[];
+}
+export declare namespace ProvisioningArtifactPreferences {
+    
+    const filterSensitiveLog: (obj: ProvisioningArtifactPreferences) => any;
+}
+
+export interface TagOptionSummary {
+    
+    Key?: string;
+    
+    Values?: string[];
+}
+export declare namespace TagOptionSummary {
+    
+    const filterSensitiveLog: (obj: TagOptionSummary) => any;
+}
+
+export interface UsageInstruction {
+    
+    Type?: string;
+    
+    Value?: string;
+}
+export declare namespace UsageInstruction {
+    
+    const filterSensitiveLog: (obj: UsageInstruction) => any;
+}
+export interface DescribeProvisioningParametersOutput {
+    
+    ProvisioningArtifactParameters?: ProvisioningArtifactParameter[];
+    
+    ConstraintSummaries?: ConstraintSummary[];
+    
+    UsageInstructions?: UsageInstruction[];
+    
+    TagOptions?: TagOptionSummary[];
+    
+    ProvisioningArtifactPreferences?: ProvisioningArtifactPreferences;
+    
+    ProvisioningArtifactOutputs?: ProvisioningArtifactOutput[];
+}
+export declare namespace DescribeProvisioningParametersOutput {
+    
+    const filterSensitiveLog: (obj: DescribeProvisioningParametersOutput) => any;
+}
+export interface DescribeRecordInput {
+    
+    AcceptLanguage?: string;
+    
+    Id: string | undefined;
+    
+    PageToken?: string;
+    
+    PageSize?: number;
+}
+export declare namespace DescribeRecordInput {
+    
+    const filterSensitiveLog: (obj: DescribeRecordInput) => any;
+}
+
+export interface RecordError {
+    
+    Code?: string;
+    
+    Description?: string;
+}
+export declare namespace RecordError {
+    
+    const filterSensitiveLog: (obj: RecordError) => any;
+}
+
+export interface RecordTag {
+    
+    Key?: string;
+    
+    Value?: string;
+}
+export declare namespace RecordTag {
+    
+    const filterSensitiveLog: (obj: RecordTag) => any;
+}
+export declare enum RecordStatus {
+    CREATED = "CREATED",
+    FAILED = "FAILED",
+    IN_PROGRESS = "IN_PROGRESS",
+    IN_PROGRESS_IN_ERROR = "IN_PROGRESS_IN_ERROR",
+    SUCCEEDED = "SUCCEEDED"
+}
+
+export interface RecordDetail {
+    
+    RecordId?: string;
+    
+    ProvisionedProductName?: string;
+    
+    Status?: RecordStatus | string;
+    
+    CreatedTime?: Date;
+    
+    UpdatedTime?: Date;
+    
+    ProvisionedProductType?: string;
+    
+    RecordType?: string;
+    
+    ProvisionedProductId?: string;
+    
+    ProductId?: string;
+    
+    ProvisioningArtifactId?: string;
+    
+    PathId?: string;
+    
+    RecordErrors?: RecordError[];
+    
+    RecordTags?: RecordTag[];
+    
+    LaunchRoleArn?: string;
+}
+export declare namespace RecordDetail {
+    
+    const filterSensitiveLog: (obj: RecordDetail) => any;
+}
+
+export interface RecordOutput {
+    
+    OutputKey?: string;
+    
+    OutputValue?: string;
+    
+    Description?: string;
+}
+export declare namespace RecordOutput {
+    
+    const filterSensitiveLog: (obj: RecordOutput) => any;
+}
+export interface DescribeRecordOutput {
+    
+    RecordDetail?: RecordDetail;
+    
+    RecordOutputs?: RecordOutput[];
+    
+    NextPageToken?: string;
+}
+export declare namespace DescribeRecordOutput {
+    
+    const filterSensitiveLog: (obj: DescribeRecordOutput) => any;
+}
+export interface DescribeServiceActionInput {
+    
+    Id: string | undefined;
+    
+    AcceptLanguage?: string;
+}
+export declare namespace DescribeServiceActionInput {
+    
+    const filterSensitiveLog: (obj: DescribeServiceActionInput) => any;
+}
+export interface DescribeServiceActionOutput {
+    
+    ServiceActionDetail?: ServiceActionDetail;
+}
+export declare namespace DescribeServiceActionOutput {
+    
+    const filterSensitiveLog: (obj: DescribeServiceActionOutput) => any;
+}
+export interface DescribeServiceActionExecutionParametersInput {
+    
+    ProvisionedProductId: string | undefined;
+    
+    ServiceActionId: string | undefined;
+    
+    AcceptLanguage?: string;
+}
+export declare namespace DescribeServiceActionExecutionParametersInput {
+    
+    const filterSensitiveLog: (obj: DescribeServiceActionExecutionParametersInput) => any;
+}
+
+export interface ExecutionParameter {
+    
+    Name?: string;
+    
+    Type?: string;
+    
+    DefaultValues?: string[];
+}
+export declare namespace ExecutionParameter {
+    
+    const filterSensitiveLog: (obj: ExecutionParameter) => any;
+}
+export interface DescribeServiceActionExecutionParametersOutput {
+    
+    ServiceActionParameters?: ExecutionParameter[];
+}
+export declare namespace DescribeServiceActionExecutionParametersOutput {
+    
+    const filterSensitiveLog: (obj: DescribeServiceActionExecutionParametersOutput) => any;
+}
+export interface DescribeTagOptionInput {
+    
+    Id: string | undefined;
+}
+export declare namespace DescribeTagOptionInput {
+    
+    const filterSensitiveLog: (obj: DescribeTagOptionInput) => any;
+}
+export interface DescribeTagOptionOutput {
+    
+    TagOptionDetail?: TagOptionDetail;
+}
+export declare namespace DescribeTagOptionOutput {
+    
+    const filterSensitiveLog: (obj: DescribeTagOptionOutput) => any;
+}
+export interface DisableAWSOrganizationsAccessInput {
+}
+export declare namespace DisableAWSOrganizationsAccessInput {
+    
+    const filterSensitiveLog: (obj: DisableAWSOrganizationsAccessInput) => any;
+}
+export interface DisableAWSOrganizationsAccessOutput {
+}
+export declare namespace DisableAWSOrganizationsAccessOutput {
+    
+    const filterSensitiveLog: (obj: DisableAWSOrganizationsAccessOutput) => any;
+}
+export interface DisassociateBudgetFromResourceInput {
+    
+    BudgetName: string | undefined;
+    
+    ResourceId: string | undefined;
+}
+export declare namespace DisassociateBudgetFromResourceInput {
+    
+    const filterSensitiveLog: (obj: DisassociateBudgetFromResourceInput) => any;
+}
+export interface DisassociateBudgetFromResourceOutput {
+}
+export declare namespace DisassociateBudgetFromResourceOutput {
+    
+    const filterSensitiveLog: (obj: DisassociateBudgetFromResourceOutput) => any;
+}
+export interface DisassociatePrincipalFromPortfolioInput {
+    
+    AcceptLanguage?: string;
+    
+    PortfolioId: string | undefined;
+    
+    PrincipalARN: string | undefined;
+}
+export declare namespace DisassociatePrincipalFromPortfolioInput {
+    
+    const filterSensitiveLog: (obj: DisassociatePrincipalFromPortfolioInput) => any;
+}
+export interface DisassociatePrincipalFromPortfolioOutput {
+}
+export declare namespace DisassociatePrincipalFromPortfolioOutput {
+    
+    const filterSensitiveLog: (obj: DisassociatePrincipalFromPortfolioOutput) => any;
+}
+export interface DisassociateProductFromPortfolioInput {
+    
+    AcceptLanguage?: string;
+    
+    ProductId: string | undefined;
+    
+    PortfolioId: string | undefined;
+}
+export declare namespace DisassociateProductFromPortfolioInput {
+    
+    const filterSensitiveLog: (obj: DisassociateProductFromPortfolioInput) => any;
+}
+export interface DisassociateProductFromPortfolioOutput {
+}
+export declare namespace DisassociateProductFromPortfolioOutput {
+    
+    const filterSensitiveLog: (obj: DisassociateProductFromPortfolioOutput) => any;
+}
+export interface DisassociateServiceActionFromProvisioningArtifactInput {
+    
+    ProductId: string | undefined;
+    
+    ProvisioningArtifactId: string | undefined;
+    
+    ServiceActionId: string | undefined;
+    
+    AcceptLanguage?: string;
+}
+export declare namespace DisassociateServiceActionFromProvisioningArtifactInput {
+    
+    const filterSensitiveLog: (obj: DisassociateServiceActionFromProvisioningArtifactInput) => any;
+}
+export interface DisassociateServiceActionFromProvisioningArtifactOutput {
+}
+export declare namespace DisassociateServiceActionFromProvisioningArtifactOutput {
+    
+    const filterSensitiveLog: (obj: DisassociateServiceActionFromProvisioningArtifactOutput) => any;
+}
+export interface DisassociateTagOptionFromResourceInput {
+    
+    ResourceId: string | undefined;
+    
+    TagOptionId: string | undefined;
+}
+export declare namespace DisassociateTagOptionFromResourceInput {
+    
+    const filterSensitiveLog: (obj: DisassociateTagOptionFromResourceInput) => any;
+}
+export interface DisassociateTagOptionFromResourceOutput {
+}
+export declare namespace DisassociateTagOptionFromResourceOutput {
+    
+    const filterSensitiveLog: (obj: DisassociateTagOptionFromResourceOutput) => any;
+}
+export interface EnableAWSOrganizationsAccessInput {
+}
+export declare namespace EnableAWSOrganizationsAccessInput {
+    
+    const filterSensitiveLog: (obj: EnableAWSOrganizationsAccessInput) => any;
+}
+export interface EnableAWSOrganizationsAccessOutput {
+}
+export declare namespace EnableAWSOrganizationsAccessOutput {
+    
+    const filterSensitiveLog: (obj: EnableAWSOrganizationsAccessOutput) => any;
+}
+export interface ExecuteProvisionedProductPlanInput {
+    
+    AcceptLanguage?: string;
+    
+    PlanId: string | undefined;
+    
+    IdempotencyToken?: string;
+}
+export declare namespace ExecuteProvisionedProductPlanInput {
+    
+    const filterSensitiveLog: (obj: ExecuteProvisionedProductPlanInput) => any;
+}
+export interface ExecuteProvisionedProductPlanOutput {
+    
+    RecordDetail?: RecordDetail;
+}
+export declare namespace ExecuteProvisionedProductPlanOutput {
+    
+    const filterSensitiveLog: (obj: ExecuteProvisionedProductPlanOutput) => any;
+}
+export interface ExecuteProvisionedProductServiceActionInput {
+    
+    ProvisionedProductId: string | undefined;
+    
+    ServiceActionId: string | undefined;
+    
+    ExecuteToken?: string;
+    
+    AcceptLanguage?: string;
+    
+    Parameters?: {
+        [key: string]: string[];
+    };
+}
+export declare namespace ExecuteProvisionedProductServiceActionInput {
+    
+    const filterSensitiveLog: (obj: ExecuteProvisionedProductServiceActionInput) => any;
+}
+export interface ExecuteProvisionedProductServiceActionOutput {
+    
+    RecordDetail?: RecordDetail;
+}
+export declare namespace ExecuteProvisionedProductServiceActionOutput {
+    
+    const filterSensitiveLog: (obj: ExecuteProvisionedProductServiceActionOutput) => any;
+}
+export interface GetAWSOrganizationsAccessStatusInput {
+}
+export declare namespace GetAWSOrganizationsAccessStatusInput {
+    
+    const filterSensitiveLog: (obj: GetAWSOrganizationsAccessStatusInput) => any;
+}
+export interface GetAWSOrganizationsAccessStatusOutput {
+    
+    AccessStatus?: AccessStatus | string;
+}
+export declare namespace GetAWSOrganizationsAccessStatusOutput {
+    
+    const filterSensitiveLog: (obj: GetAWSOrganizationsAccessStatusOutput) => any;
+}
+export interface GetProvisionedProductOutputsInput {
+    
+    AcceptLanguage?: string;
+    
+    ProvisionedProductId?: string;
+    
+    ProvisionedProductName?: string;
+    
+    OutputKeys?: string[];
+    
+    PageSize?: number;
+    
+    PageToken?: string;
+}
+export declare namespace GetProvisionedProductOutputsInput {
+    
+    const filterSensitiveLog: (obj: GetProvisionedProductOutputsInput) => any;
+}
+export interface GetProvisionedProductOutputsOutput {
+    
+    Outputs?: RecordOutput[];
+    
+    NextPageToken?: string;
+}
+export declare namespace GetProvisionedProductOutputsOutput {
+    
+    const filterSensitiveLog: (obj: GetProvisionedProductOutputsOutput) => any;
+}
+export interface ImportAsProvisionedProductInput {
+    
+    AcceptLanguage?: string;
+    
+    ProductId: string | undefined;
+    
+    ProvisioningArtifactId: string | undefined;
+    
+    ProvisionedProductName: string | undefined;
+    
+    PhysicalId: string | undefined;
+    
+    IdempotencyToken?: string;
+}
+export declare namespace ImportAsProvisionedProductInput {
+    
+    const filterSensitiveLog: (obj: ImportAsProvisionedProductInput) => any;
+}
+export interface ImportAsProvisionedProductOutput {
+    
+    RecordDetail?: RecordDetail;
+}
+export declare namespace ImportAsProvisionedProductOutput {
+    
+    const filterSensitiveLog: (obj: ImportAsProvisionedProductOutput) => any;
+}
+export interface ListAcceptedPortfolioSharesInput {
+    
+    AcceptLanguage?: string;
+    
+    PageToken?: string;
+    
+    PageSize?: number;
+    
+    PortfolioShareType?: PortfolioShareType | string;
+}
+export declare namespace ListAcceptedPortfolioSharesInput {
+    
+    const filterSensitiveLog: (obj: ListAcceptedPortfolioSharesInput) => any;
+}
+export interface ListAcceptedPortfolioSharesOutput {
+    
+    PortfolioDetails?: PortfolioDetail[];
+    
+    NextPageToken?: string;
+}
+export declare namespace ListAcceptedPortfolioSharesOutput {
+    
+    const filterSensitiveLog: (obj: ListAcceptedPortfolioSharesOutput) => any;
+}
+export interface ListBudgetsForResourceInput {
+    
+    AcceptLanguage?: string;
+    
+    ResourceId: string | undefined;
+    
+    PageSize?: number;
+    
+    PageToken?: string;
+}
+export declare namespace ListBudgetsForResourceInput {
+    
+    const filterSensitiveLog: (obj: ListBudgetsForResourceInput) => any;
+}
+export interface ListBudgetsForResourceOutput {
+    
+    Budgets?: BudgetDetail[];
+    
+    NextPageToken?: string;
+}
+export declare namespace ListBudgetsForResourceOutput {
+    
+    const filterSensitiveLog: (obj: ListBudgetsForResourceOutput) => any;
+}
+export interface ListConstraintsForPortfolioInput {
+    
+    AcceptLanguage?: string;
+    
+    PortfolioId: string | undefined;
+    
+    ProductId?: string;
+    
+    PageSize?: number;
+    
+    PageToken?: string;
+}
+export declare namespace ListConstraintsForPortfolioInput {
+    
+    const filterSensitiveLog: (obj: ListConstraintsForPortfolioInput) => any;
+}
+export interface ListConstraintsForPortfolioOutput {
+    
+    ConstraintDetails?: ConstraintDetail[];
+    
+    NextPageToken?: string;
+}
+export declare namespace ListConstraintsForPortfolioOutput {
+    
+    const filterSensitiveLog: (obj: ListConstraintsForPortfolioOutput) => any;
+}
+export interface ListLaunchPathsInput {
+    
+    AcceptLanguage?: string;
+    
+    ProductId: string | undefined;
+    
+    PageSize?: number;
+    
+    PageToken?: string;
+}
+export declare namespace ListLaunchPathsInput {
+    
+    const filterSensitiveLog: (obj: ListLaunchPathsInput) => any;
+}
+
+export interface LaunchPathSummary {
+    
+    Id?: string;
+    
+    ConstraintSummaries?: ConstraintSummary[];
+    
+    Tags?: Tag[];
+    
+    Name?: string;
+}
+export declare namespace LaunchPathSummary {
+    
+    const filterSensitiveLog: (obj: LaunchPathSummary) => any;
+}
+export interface ListLaunchPathsOutput {
+    
+    LaunchPathSummaries?: LaunchPathSummary[];
+    
+    NextPageToken?: string;
+}
+export declare namespace ListLaunchPathsOutput {
+    
+    const filterSensitiveLog: (obj: ListLaunchPathsOutput) => any;
+}
+export interface ListOrganizationPortfolioAccessInput {
+    
+    AcceptLanguage?: string;
+    
+    PortfolioId: string | undefined;
+    
+    OrganizationNodeType: OrganizationNodeType | string | undefined;
+    
+    PageToken?: string;
+    
+    PageSize?: number;
+}
+export declare namespace ListOrganizationPortfolioAccessInput {
+    
+    const filterSensitiveLog: (obj: ListOrganizationPortfolioAccessInput) => any;
+}
+export interface ListOrganizationPortfolioAccessOutput {
+    
+    OrganizationNodes?: OrganizationNode[];
+    
+    NextPageToken?: string;
+}
+export declare namespace ListOrganizationPortfolioAccessOutput {
+    
+    const filterSensitiveLog: (obj: ListOrganizationPortfolioAccessOutput) => any;
+}
+export interface ListPortfolioAccessInput {
+    
+    AcceptLanguage?: string;
+    
+    PortfolioId: string | undefined;
+    
+    OrganizationParentId?: string;
+    
+    PageToken?: string;
+    
+    PageSize?: number;
+}
+export declare namespace ListPortfolioAccessInput {
+    
+    const filterSensitiveLog: (obj: ListPortfolioAccessInput) => any;
+}
+export interface ListPortfolioAccessOutput {
+    
+    AccountIds?: string[];
+    
+    NextPageToken?: string;
+}
+export declare namespace ListPortfolioAccessOutput {
+    
+    const filterSensitiveLog: (obj: ListPortfolioAccessOutput) => any;
+}
+export interface ListPortfoliosInput {
+    
+    AcceptLanguage?: string;
+    
+    PageToken?: string;
+    
+    PageSize?: number;
+}
+export declare namespace ListPortfoliosInput {
+    
+    const filterSensitiveLog: (obj: ListPortfoliosInput) => any;
+}
+export interface ListPortfoliosOutput {
+    
+    PortfolioDetails?: PortfolioDetail[];
+    
+    NextPageToken?: string;
+}
+export declare namespace ListPortfoliosOutput {
+    
+    const filterSensitiveLog: (obj: ListPortfoliosOutput) => any;
+}
+export interface ListPortfoliosForProductInput {
+    
+    AcceptLanguage?: string;
+    
+    ProductId: string | undefined;
+    
+    PageToken?: string;
+    
+    PageSize?: number;
+}
+export declare namespace ListPortfoliosForProductInput {
+    
+    const filterSensitiveLog: (obj: ListPortfoliosForProductInput) => any;
+}
+export interface ListPortfoliosForProductOutput {
+    
+    PortfolioDetails?: PortfolioDetail[];
+    
+    NextPageToken?: string;
+}
+export declare namespace ListPortfoliosForProductOutput {
+    
+    const filterSensitiveLog: (obj: ListPortfoliosForProductOutput) => any;
+}
+export interface ListPrincipalsForPortfolioInput {
+    
+    AcceptLanguage?: string;
+    
+    PortfolioId: string | undefined;
+    
+    PageSize?: number;
+    
+    PageToken?: string;
+}
+export declare namespace ListPrincipalsForPortfolioInput {
+    
+    const filterSensitiveLog: (obj: ListPrincipalsForPortfolioInput) => any;
+}
+
+export interface Principal {
+    
+    PrincipalARN?: string;
+    
+    PrincipalType?: PrincipalType | string;
+}
+export declare namespace Principal {
+    
+    const filterSensitiveLog: (obj: Principal) => any;
+}
+export interface ListPrincipalsForPortfolioOutput {
+    
+    Principals?: Principal[];
+    
+    NextPageToken?: string;
+}
+export declare namespace ListPrincipalsForPortfolioOutput {
+    
+    const filterSensitiveLog: (obj: ListPrincipalsForPortfolioOutput) => any;
+}
+export interface ListProvisionedProductPlansInput {
+    
+    AcceptLanguage?: string;
+    
+    ProvisionProductId?: string;
+    
+    PageSize?: number;
+    
+    PageToken?: string;
+    
+    AccessLevelFilter?: AccessLevelFilter;
+}
+export declare namespace ListProvisionedProductPlansInput {
+    
+    const filterSensitiveLog: (obj: ListProvisionedProductPlansInput) => any;
+}
+
+export interface ProvisionedProductPlanSummary {
+    
+    PlanName?: string;
+    
+    PlanId?: string;
+    
+    ProvisionProductId?: string;
+    
+    ProvisionProductName?: string;
+    
+    PlanType?: ProvisionedProductPlanType | string;
+    
+    ProvisioningArtifactId?: string;
+}
+export declare namespace ProvisionedProductPlanSummary {
+    
+    const filterSensitiveLog: (obj: ProvisionedProductPlanSummary) => any;
+}
+export interface ListProvisionedProductPlansOutput {
+    
+    ProvisionedProductPlans?: ProvisionedProductPlanSummary[];
+    
+    NextPageToken?: string;
+}
+export declare namespace ListProvisionedProductPlansOutput {
+    
+    const filterSensitiveLog: (obj: ListProvisionedProductPlansOutput) => any;
+}
+export interface ListProvisioningArtifactsInput {
+    
+    AcceptLanguage?: string;
+    
+    ProductId: string | undefined;
+}
+export declare namespace ListProvisioningArtifactsInput {
+    
+    const filterSensitiveLog: (obj: ListProvisioningArtifactsInput) => any;
+}
+export interface ListProvisioningArtifactsOutput {
+    
+    ProvisioningArtifactDetails?: ProvisioningArtifactDetail[];
+    
+    NextPageToken?: string;
+}
+export declare namespace ListProvisioningArtifactsOutput {
+    
+    const filterSensitiveLog: (obj: ListProvisioningArtifactsOutput) => any;
+}
+export interface ListProvisioningArtifactsForServiceActionInput {
+    
+    ServiceActionId: string | undefined;
+    
+    PageSize?: number;
+    
+    PageToken?: string;
+    
+    AcceptLanguage?: string;
+}
+export declare namespace ListProvisioningArtifactsForServiceActionInput {
+    
+    const filterSensitiveLog: (obj: ListProvisioningArtifactsForServiceActionInput) => any;
+}
+
+export interface ProvisioningArtifactView {
+    
+    ProductViewSummary?: ProductViewSummary;
+    
+    ProvisioningArtifact?: ProvisioningArtifact;
+}
+export declare namespace ProvisioningArtifactView {
+    
+    const filterSensitiveLog: (obj: ProvisioningArtifactView) => any;
+}
+export interface ListProvisioningArtifactsForServiceActionOutput {
+    
+    ProvisioningArtifactViews?: ProvisioningArtifactView[];
+    
+    NextPageToken?: string;
+}
+export declare namespace ListProvisioningArtifactsForServiceActionOutput {
+    
+    const filterSensitiveLog: (obj: ListProvisioningArtifactsForServiceActionOutput) => any;
+}
+
+export interface ListRecordHistorySearchFilter {
+    
+    Key?: string;
+    
+    Value?: string;
+}
+export declare namespace ListRecordHistorySearchFilter {
+    
+    const filterSensitiveLog: (obj: ListRecordHistorySearchFilter) => any;
+}
+export interface ListRecordHistoryInput {
+    
+    AcceptLanguage?: string;
+    
+    AccessLevelFilter?: AccessLevelFilter;
+    
+    SearchFilter?: ListRecordHistorySearchFilter;
+    
+    PageSize?: number;
+    
+    PageToken?: string;
+}
+export declare namespace ListRecordHistoryInput {
+    
+    const filterSensitiveLog: (obj: ListRecordHistoryInput) => any;
+}
+export interface ListRecordHistoryOutput {
+    
+    RecordDetails?: RecordDetail[];
+    
+    NextPageToken?: string;
+}
+export declare namespace ListRecordHistoryOutput {
+    
+    const filterSensitiveLog: (obj: ListRecordHistoryOutput) => any;
+}
+export interface ListResourcesForTagOptionInput {
+    
+    TagOptionId: string | undefined;
+    
+    ResourceType?: string;
+    
+    PageSize?: number;
+    
+    PageToken?: string;
+}
+export declare namespace ListResourcesForTagOptionInput {
+    
+    const filterSensitiveLog: (obj: ListResourcesForTagOptionInput) => any;
+}
+
+export interface ResourceDetail {
+    
+    Id?: string;
+    
+    ARN?: string;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    CreatedTime?: Date;
+}
+export declare namespace ResourceDetail {
+    
+    const filterSensitiveLog: (obj: ResourceDetail) => any;
+}
+export interface ListResourcesForTagOptionOutput {
+    
+    ResourceDetails?: ResourceDetail[];
+    
+    PageToken?: string;
+}
+export declare namespace ListResourcesForTagOptionOutput {
+    
+    const filterSensitiveLog: (obj: ListResourcesForTagOptionOutput) => any;
+}
+export interface ListServiceActionsInput {
+    
+    AcceptLanguage?: string;
+    
+    PageSize?: number;
+    
+    PageToken?: string;
+}
+export declare namespace ListServiceActionsInput {
+    
+    const filterSensitiveLog: (obj: ListServiceActionsInput) => any;
+}
+export interface ListServiceActionsOutput {
+    
+    ServiceActionSummaries?: ServiceActionSummary[];
+    
+    NextPageToken?: string;
+}
+export declare namespace ListServiceActionsOutput {
+    
+    const filterSensitiveLog: (obj: ListServiceActionsOutput) => any;
+}
+export interface ListServiceActionsForProvisioningArtifactInput {
+    
+    ProductId: string | undefined;
+    
+    ProvisioningArtifactId: string | undefined;
+    
+    PageSize?: number;
+    
+    PageToken?: string;
+    
+    AcceptLanguage?: string;
+}
+export declare namespace ListServiceActionsForProvisioningArtifactInput {
+    
+    const filterSensitiveLog: (obj: ListServiceActionsForProvisioningArtifactInput) => any;
+}
+export interface ListServiceActionsForProvisioningArtifactOutput {
+    
+    ServiceActionSummaries?: ServiceActionSummary[];
+    
+    NextPageToken?: string;
+}
+export declare namespace ListServiceActionsForProvisioningArtifactOutput {
+    
+    const filterSensitiveLog: (obj: ListServiceActionsForProvisioningArtifactOutput) => any;
+}
+export interface ListStackInstancesForProvisionedProductInput {
+    
+    AcceptLanguage?: string;
+    
+    ProvisionedProductId: string | undefined;
+    
+    PageToken?: string;
+    
+    PageSize?: number;
+}
+export declare namespace ListStackInstancesForProvisionedProductInput {
+    
+    const filterSensitiveLog: (obj: ListStackInstancesForProvisionedProductInput) => any;
+}
+export declare enum StackInstanceStatus {
+    CURRENT = "CURRENT",
+    INOPERABLE = "INOPERABLE",
+    OUTDATED = "OUTDATED"
+}
+
+export interface StackInstance {
+    
+    Account?: string;
+    
+    Region?: string;
+    
+    StackInstanceStatus?: StackInstanceStatus | string;
+}
+export declare namespace StackInstance {
+    
+    const filterSensitiveLog: (obj: StackInstance) => any;
+}
+export interface ListStackInstancesForProvisionedProductOutput {
+    
+    StackInstances?: StackInstance[];
+    
+    NextPageToken?: string;
+}
+export declare namespace ListStackInstancesForProvisionedProductOutput {
+    
+    const filterSensitiveLog: (obj: ListStackInstancesForProvisionedProductOutput) => any;
+}
+
+export interface ListTagOptionsFilters {
+    
+    Key?: string;
+    
+    Value?: string;
+    
+    Active?: boolean;
+}
+export declare namespace ListTagOptionsFilters {
+    
+    const filterSensitiveLog: (obj: ListTagOptionsFilters) => any;
+}
+export interface ListTagOptionsInput {
+    
+    Filters?: ListTagOptionsFilters;
+    
+    PageSize?: number;
+    
+    PageToken?: string;
+}
+export declare namespace ListTagOptionsInput {
+    
+    const filterSensitiveLog: (obj: ListTagOptionsInput) => any;
+}
+export interface ListTagOptionsOutput {
+    
+    TagOptionDetails?: TagOptionDetail[];
+    
+    PageToken?: string;
+}
+export declare namespace ListTagOptionsOutput {
+    
+    const filterSensitiveLog: (obj: ListTagOptionsOutput) => any;
+}
+
+export interface ProvisioningParameter {
+    
+    Key?: string;
+    
+    Value?: string;
+}
+export declare namespace ProvisioningParameter {
+    
+    const filterSensitiveLog: (obj: ProvisioningParameter) => any;
+}
+
+export interface ProvisioningPreferences {
+    
+    StackSetAccounts?: string[];
+    
+    StackSetRegions?: string[];
+    
+    StackSetFailureToleranceCount?: number;
+    
+    StackSetFailureTolerancePercentage?: number;
+    
+    StackSetMaxConcurrencyCount?: number;
+    
+    StackSetMaxConcurrencyPercentage?: number;
+}
+export declare namespace ProvisioningPreferences {
+    
+    const filterSensitiveLog: (obj: ProvisioningPreferences) => any;
+}
+export interface ProvisionProductInput {
+    
+    AcceptLanguage?: string;
+    
+    ProductId?: string;
+    
+    ProductName?: string;
+    
+    ProvisioningArtifactId?: string;
+    
+    ProvisioningArtifactName?: string;
+    
+    PathId?: string;
+    
+    PathName?: string;
+    
+    ProvisionedProductName: string | undefined;
+    
+    ProvisioningParameters?: ProvisioningParameter[];
+    
+    ProvisioningPreferences?: ProvisioningPreferences;
+    
+    Tags?: Tag[];
+    
+    NotificationArns?: string[];
+    
+    ProvisionToken?: string;
+}
+export declare namespace ProvisionProductInput {
+    
+    const filterSensitiveLog: (obj: ProvisionProductInput) => any;
+}
+export interface ProvisionProductOutput {
+    
+    RecordDetail?: RecordDetail;
+}
+export declare namespace ProvisionProductOutput {
+    
+    const filterSensitiveLog: (obj: ProvisionProductOutput) => any;
+}
+export interface RejectPortfolioShareInput {
+    
+    AcceptLanguage?: string;
+    
+    PortfolioId: string | undefined;
+    
+    PortfolioShareType?: PortfolioShareType | string;
+}
+export declare namespace RejectPortfolioShareInput {
+    
+    const filterSensitiveLog: (obj: RejectPortfolioShareInput) => any;
+}
+export interface RejectPortfolioShareOutput {
+}
+export declare namespace RejectPortfolioShareOutput {
+    
+    const filterSensitiveLog: (obj: RejectPortfolioShareOutput) => any;
+}
+export interface ScanProvisionedProductsInput {
+    
+    AcceptLanguage?: string;
+    
+    AccessLevelFilter?: AccessLevelFilter;
+    
+    PageSize?: number;
+    
+    PageToken?: string;
+}
+export declare namespace ScanProvisionedProductsInput {
+    
+    const filterSensitiveLog: (obj: ScanProvisionedProductsInput) => any;
+}
+export interface ScanProvisionedProductsOutput {
+    
+    ProvisionedProducts?: ProvisionedProductDetail[];
+    
+    NextPageToken?: string;
+}
+export declare namespace ScanProvisionedProductsOutput {
+    
+    const filterSensitiveLog: (obj: ScanProvisionedProductsOutput) => any;
+}
+export declare enum ProductViewFilterBy {
+    FullTextSearch = "FullTextSearch",
+    Owner = "Owner",
+    ProductType = "ProductType",
+    SourceProductId = "SourceProductId"
+}
+export declare enum ProductViewSortBy {
+    CreationDate = "CreationDate",
+    Title = "Title",
+    VersionCount = "VersionCount"
+}
+export declare enum SortOrder {
+    ASCENDING = "ASCENDING",
+    DESCENDING = "DESCENDING"
+}
+export interface SearchProductsInput {
+    
+    AcceptLanguage?: string;
+    
+    Filters?: {
+        [key: string]: string[];
+    };
+    
+    PageSize?: number;
+    
+    SortBy?: ProductViewSortBy | string;
+    
+    SortOrder?: SortOrder | string;
+    
+    PageToken?: string;
+}
+export declare namespace SearchProductsInput {
+    
+    const filterSensitiveLog: (obj: SearchProductsInput) => any;
+}
+
+export interface ProductViewAggregationValue {
+    
+    Value?: string;
+    
+    ApproximateCount?: number;
+}
+export declare namespace ProductViewAggregationValue {
+    
+    const filterSensitiveLog: (obj: ProductViewAggregationValue) => any;
+}
+export interface SearchProductsOutput {
+    
+    ProductViewSummaries?: ProductViewSummary[];
+    
+    ProductViewAggregations?: {
+        [key: string]: ProductViewAggregationValue[];
+    };
+    
+    NextPageToken?: string;
+}
+export declare namespace SearchProductsOutput {
+    
+    const filterSensitiveLog: (obj: SearchProductsOutput) => any;
+}
+export declare enum ProductSource {
+    ACCOUNT = "ACCOUNT"
+}
+export interface SearchProductsAsAdminInput {
+    
+    AcceptLanguage?: string;
+    
+    PortfolioId?: string;
+    
+    Filters?: {
+        [key: string]: string[];
+    };
+    
+    SortBy?: ProductViewSortBy | string;
+    
+    SortOrder?: SortOrder | string;
+    
+    PageToken?: string;
+    
+    PageSize?: number;
+    
+    ProductSource?: ProductSource | string;
+}
+export declare namespace SearchProductsAsAdminInput {
+    
+    const filterSensitiveLog: (obj: SearchProductsAsAdminInput) => any;
+}
+export interface SearchProductsAsAdminOutput {
+    
+    ProductViewDetails?: ProductViewDetail[];
+    
+    NextPageToken?: string;
+}
+export declare namespace SearchProductsAsAdminOutput {
+    
+    const filterSensitiveLog: (obj: SearchProductsAsAdminOutput) => any;
+}
+export declare enum ProvisionedProductViewFilterBy {
+    SearchQuery = "SearchQuery"
+}
+export interface SearchProvisionedProductsInput {
+    
+    AcceptLanguage?: string;
+    
+    AccessLevelFilter?: AccessLevelFilter;
+    
+    Filters?: {
+        [key: string]: string[];
+    };
+    
+    SortBy?: string;
+    
+    SortOrder?: SortOrder | string;
+    
+    PageSize?: number;
+    
+    PageToken?: string;
+}
+export declare namespace SearchProvisionedProductsInput {
+    
+    const filterSensitiveLog: (obj: SearchProvisionedProductsInput) => any;
+}
+
+export interface ProvisionedProductAttribute {
+    
+    Name?: string;
+    
+    Arn?: string;
+    
+    Type?: string;
+    
+    Id?: string;
+    
+    Status?: ProvisionedProductStatus | string;
+    
+    StatusMessage?: string;
+    
+    CreatedTime?: Date;
+    
+    IdempotencyToken?: string;
+    
+    LastRecordId?: string;
+    
+    LastProvisioningRecordId?: string;
+    
+    LastSuccessfulProvisioningRecordId?: string;
+    
+    Tags?: Tag[];
+    
+    PhysicalId?: string;
+    
+    ProductId?: string;
+    
+    ProductName?: string;
+    
+    ProvisioningArtifactId?: string;
+    
+    ProvisioningArtifactName?: string;
+    
+    UserArn?: string;
+    
+    UserArnSession?: string;
+}
+export declare namespace ProvisionedProductAttribute {
+    
+    const filterSensitiveLog: (obj: ProvisionedProductAttribute) => any;
+}
+export interface SearchProvisionedProductsOutput {
+    
+    ProvisionedProducts?: ProvisionedProductAttribute[];
+    
+    TotalResultsCount?: number;
+    
+    NextPageToken?: string;
+}
+export declare namespace SearchProvisionedProductsOutput {
+    
+    const filterSensitiveLog: (obj: SearchProvisionedProductsOutput) => any;
+}
+export interface TerminateProvisionedProductInput {
+    
+    ProvisionedProductName?: string;
+    
+    ProvisionedProductId?: string;
+    
+    TerminateToken?: string;
+    
+    IgnoreErrors?: boolean;
+    
+    AcceptLanguage?: string;
+    
+    RetainPhysicalResources?: boolean;
+}
+export declare namespace TerminateProvisionedProductInput {
+    
+    const filterSensitiveLog: (obj: TerminateProvisionedProductInput) => any;
+}
+export interface TerminateProvisionedProductOutput {
+    
+    RecordDetail?: RecordDetail;
+}
+export declare namespace TerminateProvisionedProductOutput {
+    
+    const filterSensitiveLog: (obj: TerminateProvisionedProductOutput) => any;
+}
+export interface UpdateConstraintInput {
+    
+    AcceptLanguage?: string;
+    
+    Id: string | undefined;
+    
+    Description?: string;
+    
+    Parameters?: string;
+}
+export declare namespace UpdateConstraintInput {
+    
+    const filterSensitiveLog: (obj: UpdateConstraintInput) => any;
+}
+export interface UpdateConstraintOutput {
+    
+    ConstraintDetail?: ConstraintDetail;
+    
+    ConstraintParameters?: string;
+    
+    Status?: Status | string;
+}
+export declare namespace UpdateConstraintOutput {
+    
+    const filterSensitiveLog: (obj: UpdateConstraintOutput) => any;
+}
+export interface UpdatePortfolioInput {
+    
+    AcceptLanguage?: string;
+    
+    Id: string | undefined;
+    
+    DisplayName?: string;
+    
+    Description?: string;
+    
+    ProviderName?: string;
+    
+    AddTags?: Tag[];
+    
+    RemoveTags?: string[];
+}
+export declare namespace UpdatePortfolioInput {
+    
+    const filterSensitiveLog: (obj: UpdatePortfolioInput) => any;
+}
+export interface UpdatePortfolioOutput {
+    
+    PortfolioDetail?: PortfolioDetail;
+    
+    Tags?: Tag[];
+}
+export declare namespace UpdatePortfolioOutput {
+    
+    const filterSensitiveLog: (obj: UpdatePortfolioOutput) => any;
+}
+export interface UpdatePortfolioShareInput {
+    
+    AcceptLanguage?: string;
+    
+    PortfolioId: string | undefined;
+    
+    AccountId?: string;
+    
+    OrganizationNode?: OrganizationNode;
+    
+    ShareTagOptions?: boolean;
+}
+export declare namespace UpdatePortfolioShareInput {
+    
+    const filterSensitiveLog: (obj: UpdatePortfolioShareInput) => any;
+}
+export interface UpdatePortfolioShareOutput {
+    
+    PortfolioShareToken?: string;
+    
+    Status?: ShareStatus | string;
+}
+export declare namespace UpdatePortfolioShareOutput {
+    
+    const filterSensitiveLog: (obj: UpdatePortfolioShareOutput) => any;
+}
+export interface UpdateProductInput {
+    
+    AcceptLanguage?: string;
+    
+    Id: string | undefined;
+    
+    Name?: string;
+    
+    Owner?: string;
+    
+    Description?: string;
+    
+    Distributor?: string;
+    
+    SupportDescription?: string;
+    
+    SupportEmail?: string;
+    
+    SupportUrl?: string;
+    
+    AddTags?: Tag[];
+    
+    RemoveTags?: string[];
+}
+export declare namespace UpdateProductInput {
+    
+    const filterSensitiveLog: (obj: UpdateProductInput) => any;
+}
+export interface UpdateProductOutput {
+    
+    ProductViewDetail?: ProductViewDetail;
+    
+    Tags?: Tag[];
+}
+export declare namespace UpdateProductOutput {
+    
+    const filterSensitiveLog: (obj: UpdateProductOutput) => any;
+}
+export declare type StackSetOperationType = "CREATE" | "DELETE" | "UPDATE";
+
+export interface UpdateProvisioningPreferences {
+    
+    StackSetAccounts?: string[];
+    
+    StackSetRegions?: string[];
+    
+    StackSetFailureToleranceCount?: number;
+    
+    StackSetFailureTolerancePercentage?: number;
+    
+    StackSetMaxConcurrencyCount?: number;
+    
+    StackSetMaxConcurrencyPercentage?: number;
+    
+    StackSetOperationType?: StackSetOperationType | string;
+}
+export declare namespace UpdateProvisioningPreferences {
+    
+    const filterSensitiveLog: (obj: UpdateProvisioningPreferences) => any;
+}
+export interface UpdateProvisionedProductInput {
+    
+    AcceptLanguage?: string;
+    
+    ProvisionedProductName?: string;
+    
+    ProvisionedProductId?: string;
+    
+    ProductId?: string;
+    
+    ProductName?: string;
+    
+    ProvisioningArtifactId?: string;
+    
+    ProvisioningArtifactName?: string;
+    
+    PathId?: string;
+    
+    PathName?: string;
+    
+    ProvisioningParameters?: UpdateProvisioningParameter[];
+    
+    ProvisioningPreferences?: UpdateProvisioningPreferences;
+    
+    Tags?: Tag[];
+    
+    UpdateToken?: string;
+}
+export declare namespace UpdateProvisionedProductInput {
+    
+    const filterSensitiveLog: (obj: UpdateProvisionedProductInput) => any;
+}
+export interface UpdateProvisionedProductOutput {
+    
+    RecordDetail?: RecordDetail;
+}
+export declare namespace UpdateProvisionedProductOutput {
+    
+    const filterSensitiveLog: (obj: UpdateProvisionedProductOutput) => any;
+}
+export declare enum PropertyKey {
+    LaunchRole = "LAUNCH_ROLE",
+    Owner = "OWNER"
+}
+export interface UpdateProvisionedProductPropertiesInput {
+    
+    AcceptLanguage?: string;
+    
+    ProvisionedProductId: string | undefined;
+    
+    ProvisionedProductProperties: {
+        [key: string]: string;
+    } | undefined;
+    
+    IdempotencyToken?: string;
+}
+export declare namespace UpdateProvisionedProductPropertiesInput {
+    
+    const filterSensitiveLog: (obj: UpdateProvisionedProductPropertiesInput) => any;
+}
+export interface UpdateProvisionedProductPropertiesOutput {
+    
+    ProvisionedProductId?: string;
+    
+    ProvisionedProductProperties?: {
+        [key: string]: string;
+    };
+    
+    RecordId?: string;
+    
+    Status?: RecordStatus | string;
+}
+export declare namespace UpdateProvisionedProductPropertiesOutput {
+    
+    const filterSensitiveLog: (obj: UpdateProvisionedProductPropertiesOutput) => any;
+}
+export interface UpdateProvisioningArtifactInput {
+    
+    AcceptLanguage?: string;
+    
+    ProductId: string | undefined;
+    
+    ProvisioningArtifactId: string | undefined;
+    
+    Name?: string;
+    
+    Description?: string;
+    
+    Active?: boolean;
+    
+    Guidance?: ProvisioningArtifactGuidance | string;
+}
+export declare namespace UpdateProvisioningArtifactInput {
+    
+    const filterSensitiveLog: (obj: UpdateProvisioningArtifactInput) => any;
+}
+export interface UpdateProvisioningArtifactOutput {
+    
+    ProvisioningArtifactDetail?: ProvisioningArtifactDetail;
+    
+    Info?: {
+        [key: string]: string;
+    };
+    
+    Status?: Status | string;
+}
+export declare namespace UpdateProvisioningArtifactOutput {
+    
+    const filterSensitiveLog: (obj: UpdateProvisioningArtifactOutput) => any;
+}
+export interface UpdateServiceActionInput {
+    
+    Id: string | undefined;
+    
+    Name?: string;
+    
+    Definition?: {
+        [key: string]: string;
+    };
+    
+    Description?: string;
+    
+    AcceptLanguage?: string;
+}
+export declare namespace UpdateServiceActionInput {
+    
+    const filterSensitiveLog: (obj: UpdateServiceActionInput) => any;
+}
+export interface UpdateServiceActionOutput {
+    
+    ServiceActionDetail?: ServiceActionDetail;
+}
+export declare namespace UpdateServiceActionOutput {
+    
+    const filterSensitiveLog: (obj: UpdateServiceActionOutput) => any;
+}
+export interface UpdateTagOptionInput {
+    
+    Id: string | undefined;
+    
+    Value?: string;
+    
+    Active?: boolean;
+}
+export declare namespace UpdateTagOptionInput {
+    
+    const filterSensitiveLog: (obj: UpdateTagOptionInput) => any;
+}
+export interface UpdateTagOptionOutput {
+    
+    TagOptionDetail?: TagOptionDetail;
+}
+export declare namespace UpdateTagOptionOutput {
+    
+    const filterSensitiveLog: (obj: UpdateTagOptionOutput) => any;
+}