export interface Access {
    /** A list of actions for the access permissions. Any strings that can be used as an action in an IAM policy can be used in the list of actions to check. */
    actions?: any[];
    /** A list of resources for the access permissions. Any strings that can be used as an Amazon Resource Name (ARN) in an IAM policy can be used in the list of resources to check. You can only use a wildcar */
    resources?: any[];
}
export interface Criterion {
    /** An "equals" operator to match for the filter used to create the rule. */
    eq?: any[];
    /** A "not equals" operator to match for the filter used to create the rule. */
    neq?: any[];
    /** A "contains" operator to match for the filter used to create the rule. */
    contains?: any[];
    /** An "exists" operator to match for the filter used to create the rule. */
    exists?: boolean;
}
export interface SortCriteria {
    /** The name of the attribute to sort on. */
    attributeName?: string;
    /** The sort order, ascending or descending. */
    orderBy?: 'ASC' | 'DESC';
}
export interface PolicyGenerationDetails {
    /** The ARN of the IAM entity (user or role) for which you are generating a policy. */
    principalArn: string;
}
export interface CloudTrailDetails {
    /** A Trail object that contains settings for a trail. */
    trails: any[];
    /** The ARN of the service role that IAM Access Analyzer uses to access your CloudTrail trail and service last accessed information. */
    accessRole: string;
    /** The start of the time range for which IAM Access Analyzer reviews your CloudTrail events. Events with a timestamp before this time are not considered to generate a policy. */
    startTime: string;
    /** The end of the time range for which IAM Access Analyzer reviews your CloudTrail events. Events with a timestamp after this time are not considered to generate a policy. If this is not included in the  */
    endTime?: string;
}
export interface UnusedAccessConfiguration {
    /** The specified access age in days for which to generate findings for unused access. For example, if you specify 90 days, the analyzer will generate findings for IAM entities within the accounts of the  */
    unusedAccessAge?: number;
    analysisRule?: any;
}
export interface InternalAccessConfiguration {
    /** Contains information about analysis rules for the internal access analyzer. These rules determine which resources and access patterns will be analyzed. */
    analysisRule?: any;
}
/** Retroactively applies an archive rule. */
export interface ApplyArchiveRuleInput {
    /** The Amazon resource name (ARN) of the analyzer. */
    analyzerArn: string;
    /** The name of the rule to apply. */
    ruleName: string;
    /** A client token. */
    clientToken?: string;
}
export interface CancelPolicyGenerationInput {
    /** The JobId that is returned by the StartPolicyGeneration operation. The JobId can be used with GetGeneratedPolicy to retrieve the generated policies or used with CancelPolicyGeneration to cancel the po */
    jobId: string;
}
export interface CheckAccessNotGrantedInput {
    /** An access object containing the permissions that shouldn't be granted by the specified policy. If only actions are specified, IAM Access Analyzer checks for access to peform at least one of the action */
    access: Access[];
    /** The JSON policy document to use as the content for the policy. */
    policyDocument: string;
    /** The type of policy. Identity policies grant permissions to IAM principals. Identity policies include managed and inline policies for IAM roles, users, and groups. Resource policies grant permissions o */
    policyType: 'IDENTITY_POLICY' | 'RESOURCE_POLICY';
}
export interface CheckNoNewAccessInput {
    /** The JSON policy document to use as the content for the existing policy. */
    existingPolicyDocument: string;
    /** The JSON policy document to use as the content for the updated policy. */
    newPolicyDocument: string;
    /** The type of policy to compare. Identity policies grant permissions to IAM principals. Identity policies include managed and inline policies for IAM roles, users, and groups. Resource policies grant pe */
    policyType: 'IDENTITY_POLICY' | 'RESOURCE_POLICY';
}
export interface CheckNoPublicAccessInput {
    /** The JSON policy document to evaluate for public access. */
    policyDocument: string;
    /** The type of resource to evaluate for public access. For example, to check for public access to Amazon S3 buckets, you can choose AWS::S3::Bucket for the resource type. For resource types not supported */
    resourceType: 'AWS::DynamoDB::Table' | 'AWS::DynamoDB::Stream' | 'AWS::EFS::FileSystem' | 'AWS::OpenSearchService::Domain' | 'AWS::Kinesis::Stream' | 'AWS::Kinesis::StreamConsumer' | 'AWS::KMS::Key' | 'AWS::Lambda::Function' | 'AWS::S3::Bucket' | 'AWS::S3::AccessPoint' | 'AWS::S3Express::DirectoryBucket' | 'AWS::S3::Glacier' | 'AWS::S3Outposts::Bucket' | 'AWS::S3Outposts::AccessPoint' | 'AWS::SecretsManager::Secret' | 'AWS::SNS::Topic' | 'AWS::SQS::Queue' | 'AWS::IAM::AssumeRolePolicyDocument' | 'AWS::S3Tables::TableBucket' | 'AWS::ApiGateway::RestApi' | 'AWS::CodeArtifact::Domain' | 'AWS::Backup::BackupVault' | 'AWS::CloudTrail::Dashboard' | 'AWS::CloudTrail::EventDataStore' | 'AWS::S3Tables::Table' | 'AWS::S3Express::AccessPoint';
}
export interface CreateAccessPreviewInput {
    /** The ARN of the account analyzer used to generate the access preview. You can only create an access preview for analyzers with an Account type and Active status. */
    analyzerArn: string;
    /** Access control configuration for your resource that is used to generate the access preview. The access preview includes findings for external access allowed to the resource with the proposed access co */
    configurations: Record<string, any>;
    /** A client token. */
    clientToken?: string;
}
/** Deletes an analyzer. */
export interface DeleteAnalyzerInput {
    /** The name of the analyzer to delete. */
    analyzerName: string;
    /** A client token. */
    clientToken?: string;
}
/** Deletes an archive rule. */
export interface DeleteArchiveRuleInput {
    /** The name of the analyzer that associated with the archive rule to delete. */
    analyzerName: string;
    /** The name of the rule to delete. */
    ruleName: string;
    /** A client token. */
    clientToken?: string;
}
export interface GenerateFindingRecommendationInput {
    /** The ARN of the analyzer used to generate the finding recommendation. */
    analyzerArn: string;
    /** The unique ID for the finding recommendation. */
    id: string;
}
export interface GetAccessPreviewInput {
    /** The unique ID for the access preview. */
    accessPreviewId: string;
    /** The ARN of the analyzer used to generate the access preview. */
    analyzerArn: string;
}
/** Retrieves an analyzed resource. */
export interface GetAnalyzedResourceInput {
    /** The ARN of the analyzer to retrieve information from. */
    analyzerArn: string;
    /** The ARN of the resource to retrieve information about. */
    resourceArn: string;
}
/** Retrieves an analyzer. */
export interface GetAnalyzerInput {
    /** The name of the analyzer retrieved. */
    analyzerName: string;
}
/** Retrieves an archive rule. */
export interface GetArchiveRuleInput {
    /** The name of the analyzer to retrieve rules from. */
    analyzerName: string;
    /** The name of the rule to retrieve. */
    ruleName: string;
}
/** Retrieves a finding. */
export interface GetFindingInput {
    /** The ARN of the analyzer that generated the finding. */
    analyzerArn: string;
    /** The ID of the finding to retrieve. */
    id: string;
}
export interface GetFindingRecommendationInput {
    /** The ARN of the analyzer used to generate the finding recommendation. */
    analyzerArn: string;
    /** The unique ID for the finding recommendation. */
    id: string;
    /** The maximum number of results to return in the response. */
    maxResults?: number;
    /** A token used for pagination of results returned. */
    nextToken?: string;
}
export interface GetFindingsStatisticsInput {
    /** The ARN of the analyzer used to generate the statistics. */
    analyzerArn: string;
}
export interface GetFindingV2Input {
    /** The ARN of the analyzer that generated the finding. */
    analyzerArn: string;
    /** The ID of the finding to retrieve. */
    id: string;
    /** The maximum number of results to return in the response. */
    maxResults?: number;
    /** A token used for pagination of results returned. */
    nextToken?: string;
}
export interface GetGeneratedPolicyInput {
    /** The JobId that is returned by the StartPolicyGeneration operation. The JobId can be used with GetGeneratedPolicy to retrieve the generated policies or used with CancelPolicyGeneration to cancel the po */
    jobId: string;
    /** The level of detail that you want to generate. You can specify whether to generate policies with placeholders for resource ARNs for actions that support resource level granularity in policies. For exa */
    includeResourcePlaceholders?: boolean;
    /** The level of detail that you want to generate. You can specify whether to generate service-level policies. IAM Access Analyzer uses iam:servicelastaccessed to identify services that have been used rec */
    includeServiceLevelTemplate?: boolean;
}
export interface ListAccessPreviewFindingsInput {
    /** The unique ID for the access preview. */
    accessPreviewId: string;
    /** The ARN of the analyzer used to generate the access. */
    analyzerArn: string;
    /** Criteria to filter the returned findings. */
    filter?: Record<string, Criterion>;
    /** The maximum number of results to return in the response. */
    maxResults?: number;
    /** A token used for pagination of results returned. */
    nextToken?: string;
}
export interface ListAccessPreviewsInput {
    /** The ARN of the analyzer used to generate the access preview. */
    analyzerArn: string;
    /** The maximum number of results to return in the response. */
    maxResults?: number;
    /** A token used for pagination of results returned. */
    nextToken?: string;
}
/** Retrieves a list of resources that have been analyzed. */
export interface ListAnalyzedResourcesInput {
    /** The ARN of the analyzer to retrieve a list of analyzed resources from. */
    analyzerArn: string;
    /** The maximum number of results to return in the response. */
    maxResults?: number;
    /** A token used for pagination of results returned. */
    nextToken?: string;
    /** The type of resource. */
    resourceType?: 'AWS::S3::Bucket' | 'AWS::IAM::Role' | 'AWS::SQS::Queue' | 'AWS::Lambda::Function' | 'AWS::Lambda::LayerVersion' | 'AWS::KMS::Key' | 'AWS::SecretsManager::Secret' | 'AWS::EFS::FileSystem' | 'AWS::EC2::Snapshot' | 'AWS::ECR::Repository' | 'AWS::RDS::DBSnapshot' | 'AWS::RDS::DBClusterSnapshot' | 'AWS::SNS::Topic' | 'AWS::S3Express::DirectoryBucket' | 'AWS::DynamoDB::Table' | 'AWS::DynamoDB::Stream' | 'AWS::IAM::User';
}
/** Retrieves a list of analyzers. */
export interface ListAnalyzersInput {
    /** The maximum number of results to return in the response. */
    maxResults?: number;
    /** A token used for pagination of results returned. */
    nextToken?: string;
    /** The type of analyzer. */
    type?: 'ACCOUNT' | 'ORGANIZATION' | 'ACCOUNT_UNUSED_ACCESS' | 'ORGANIZATION_UNUSED_ACCESS' | 'ACCOUNT_INTERNAL_ACCESS' | 'ORGANIZATION_INTERNAL_ACCESS';
}
/** Retrieves a list of archive rules created for the specified analyzer. */
export interface ListArchiveRulesInput {
    /** The name of the analyzer to retrieve rules from. */
    analyzerName: string;
    /** The maximum number of results to return in the request. */
    maxResults?: number;
    /** A token used for pagination of results returned. */
    nextToken?: string;
}
/** Retrieves a list of findings generated by the specified analyzer. */
export interface ListFindingsInput {
    /** The ARN of the analyzer to retrieve findings from. */
    analyzerArn: string;
    /** A filter to match for the findings to return. */
    filter?: Record<string, Criterion>;
    /** The maximum number of results to return in the response. */
    maxResults?: number;
    /** A token used for pagination of results returned. */
    nextToken?: string;
    /** The sort order for the findings returned. */
    sort?: SortCriteria;
}
export interface ListFindingsV2Input {
    /** The ARN of the analyzer to retrieve findings from. */
    analyzerArn: string;
    /** A filter to match for the findings to return. */
    filter?: Record<string, Criterion>;
    /** The maximum number of results to return in the response. */
    maxResults?: number;
    /** A token used for pagination of results returned. */
    nextToken?: string;
    sort?: SortCriteria;
}
export interface ListPolicyGenerationsInput {
    /** The maximum number of results to return in the response. */
    maxResults?: number;
    /** A token used for pagination of results returned. */
    nextToken?: string;
    /** The ARN of the IAM entity (user or role) for which you are generating a policy. Use this with ListGeneratedPolicies to filter the results to only include results for a specific principal. */
    principalArn?: string;
}
/** Retrieves a list of tags applied to the specified resource. */
export interface ListTagsForResourceInput {
    /** The ARN of the resource to retrieve tags from. */
    resourceArn: string;
}
export interface StartPolicyGenerationInput {
    /** Contains the ARN of the IAM entity (user or role) for which you are generating a policy. */
    policyGenerationDetails: PolicyGenerationDetails;
    /** A unique, case-sensitive identifier that you provide to ensure the idempotency of the request. Idempotency ensures that an API request completes only once. With an idempotent request, if the original  */
    clientToken?: string;
    /** A CloudTrailDetails object that contains details about a Trail that you want to analyze to generate policies. */
    cloudTrailDetails?: CloudTrailDetails;
}
/** Starts a scan of the policies applied to the specified resource. */
export interface StartResourceScanInput {
    /** The ARN of the analyzer to use to scan the policies applied to the specified resource. */
    analyzerArn: string;
    /** The ARN of the resource to scan. */
    resourceArn: string;
    /** The Amazon Web Services account ID that owns the resource. For most Amazon Web Services resources, the owning account is the account in which the resource was created. */
    resourceOwnerAccount?: string;
}
/** Adds a tag to the specified resource. */
export interface TagResourceInput {
    /** The ARN of the resource to add the tag to. */
    resourceArn: string;
    /** The tags to add to the resource. */
    tags: Record<string, string>;
}
/** Removes a tag from the specified resource. */
export interface UntagResourceInput {
    /** The ARN of the resource to remove the tag from. */
    resourceArn: string;
    /** The key for the tag to add. */
    tagKeys: string[];
}
export interface UpdateAnalyzerInput {
    /** The name of the analyzer to modify. */
    analyzerName: string;
    configuration?: {
        unusedAccess?: UnusedAccessConfiguration;
    } | {
        internalAccess?: InternalAccessConfiguration;
    };
}
/** Updates the specified archive rule. */
export interface UpdateArchiveRuleInput {
    /** The name of the analyzer to update the archive rules for. */
    analyzerName: string;
    /** A filter to match for the rules to update. Only rules that match the filter are updated. */
    filter: Record<string, Criterion>;
    /** The name of the rule to update. */
    ruleName: string;
    /** A client token. */
    clientToken?: string;
}
/** Updates findings with the new values provided in the request. */
export interface UpdateFindingsInput {
    /** The ARN of the analyzer that generated the findings to update. */
    analyzerArn: string;
    /** The state represents the action to take to update the finding Status. Use ARCHIVE to change an Active finding to an Archived finding. Use ACTIVE to change an Archived finding to an Active finding. */
    status: 'ACTIVE' | 'ARCHIVED';
    /** A client token. */
    clientToken?: string;
    /** The IDs of the findings to update. */
    ids?: string[];
    /** The ARN of the resource identified in the finding. */
    resourceArn?: string;
}
export interface ValidatePolicyInput {
    /** The JSON policy document to use as the content for the policy. */
    policyDocument: string;
    /** The type of policy to validate. Identity policies grant permissions to IAM principals. Identity policies include managed and inline policies for IAM roles, users, and groups. Resource policies grant p */
    policyType: 'IDENTITY_POLICY' | 'RESOURCE_POLICY' | 'SERVICE_CONTROL_POLICY' | 'RESOURCE_CONTROL_POLICY';
    /** The locale to use for localizing the findings. */
    locale?: 'DE' | 'EN' | 'ES' | 'FR' | 'IT' | 'JA' | 'KO' | 'PT_BR' | 'ZH_CN' | 'ZH_TW';
    /** The maximum number of results to return in the response. */
    maxResults?: number;
    /** A token used for pagination of results returned. */
    nextToken?: string;
    /** The type of resource to attach to your resource policy. Specify a value for the policy validation resource type only if the policy type is RESOURCE_POLICY. For example, to validate a resource policy t */
    validatePolicyResourceType?: 'AWS::S3::Bucket' | 'AWS::S3::AccessPoint' | 'AWS::S3::MultiRegionAccessPoint' | 'AWS::S3ObjectLambda::AccessPoint' | 'AWS::IAM::AssumeRolePolicyDocument' | 'AWS::DynamoDB::Table';
}
/** AccessAnalyzer service binding for Step Functions SDK integrations. */
export declare class AccessAnalyzer {
    constructor();
    applyArchiveRule<T>(params: ApplyArchiveRuleInput): Promise<T>;
    cancelPolicyGeneration<T>(params: CancelPolicyGenerationInput): Promise<T>;
    checkAccessNotGranted<T>(params: CheckAccessNotGrantedInput): Promise<T>;
    checkNoNewAccess<T>(params: CheckNoNewAccessInput): Promise<T>;
    checkNoPublicAccess<T>(params: CheckNoPublicAccessInput): Promise<T>;
    createAccessPreview<T>(params: CreateAccessPreviewInput): Promise<T>;
    deleteAnalyzer<T>(params: DeleteAnalyzerInput): Promise<T>;
    deleteArchiveRule<T>(params: DeleteArchiveRuleInput): Promise<T>;
    generateFindingRecommendation<T>(params: GenerateFindingRecommendationInput): Promise<T>;
    getAccessPreview<T>(params: GetAccessPreviewInput): Promise<T>;
    getAnalyzedResource<T>(params: GetAnalyzedResourceInput): Promise<T>;
    getAnalyzer<T>(params: GetAnalyzerInput): Promise<T>;
    getArchiveRule<T>(params: GetArchiveRuleInput): Promise<T>;
    getFinding<T>(params: GetFindingInput): Promise<T>;
    getFindingRecommendation<T>(params: GetFindingRecommendationInput): Promise<T>;
    getFindingsStatistics<T>(params: GetFindingsStatisticsInput): Promise<T>;
    getFindingV2<T>(params: GetFindingV2Input): Promise<T>;
    getGeneratedPolicy<T>(params: GetGeneratedPolicyInput): Promise<T>;
    listAccessPreviewFindings<T>(params: ListAccessPreviewFindingsInput): Promise<T>;
    listAccessPreviews<T>(params: ListAccessPreviewsInput): Promise<T>;
    listAnalyzedResources<T>(params: ListAnalyzedResourcesInput): Promise<T>;
    listAnalyzers<T>(params: ListAnalyzersInput): Promise<T>;
    listArchiveRules<T>(params: ListArchiveRulesInput): Promise<T>;
    listFindings<T>(params: ListFindingsInput): Promise<T>;
    listFindingsV2<T>(params: ListFindingsV2Input): Promise<T>;
    listPolicyGenerations<T>(params: ListPolicyGenerationsInput): Promise<T>;
    listTagsForResource<T>(params: ListTagsForResourceInput): Promise<T>;
    startPolicyGeneration<T>(params: StartPolicyGenerationInput): Promise<T>;
    startResourceScan<T>(params: StartResourceScanInput): Promise<T>;
    tagResource<T>(params: TagResourceInput): Promise<T>;
    untagResource<T>(params: UntagResourceInput): Promise<T>;
    updateAnalyzer<T>(params: UpdateAnalyzerInput): Promise<T>;
    updateArchiveRule<T>(params: UpdateArchiveRuleInput): Promise<T>;
    updateFindings<T>(params: UpdateFindingsInput): Promise<T>;
    validatePolicy<T>(params: ValidatePolicyInput): Promise<T>;
}
//# sourceMappingURL=AccessAnalyzer.d.ts.map