import * as HttpClient from "effect/unstable/http/HttpClient";
import * as redacted from "effect/Redacted";
import * as S from "effect/Schema";
import * as stream from "effect/Stream";
import * as API from "../client/api.ts";
import type { Credentials } from "../credentials.ts";
import type { CommonErrors } from "../errors.ts";
import type { Region } from "../region.ts";
export type AmazonResourceName = string;
export type TagKey = string | redacted.Redacted<string>;
export type TagValue = string | redacted.Redacted<string>;
export type Uuid = string;
export type NotificationEvent = string;
export type NotificationChannel = string;
export type ResourceName = string;
export type TrustAnchorType = string;
export type TrustAnchorArn = string;
export type RoleArn = string;
export type ProfileArn = string;
export type CertificateField = string;
export interface ListTagsForResourceRequest {
    resourceArn: string;
}
export declare const ListTagsForResourceRequest: S.Schema<ListTagsForResourceRequest>;
export interface Tag {
    key: string | redacted.Redacted<string>;
    value: string | redacted.Redacted<string>;
}
export declare const Tag: S.Schema<Tag>;
export type TagList = Tag[];
export declare const TagList: S.$Array<S.Schema<Tag>>;
export interface ListTagsForResourceResponse {
    tags?: Tag[];
}
export declare const ListTagsForResourceResponse: S.Schema<ListTagsForResourceResponse>;
export interface NotificationSetting {
    enabled: boolean;
    event: string;
    threshold?: number;
    channel?: string;
}
export declare const NotificationSetting: S.Schema<NotificationSetting>;
export type NotificationSettings = NotificationSetting[];
export declare const NotificationSettings: S.$Array<S.Schema<NotificationSetting>>;
export interface PutNotificationSettingsRequest {
    trustAnchorId: string;
    notificationSettings: NotificationSetting[];
}
export declare const PutNotificationSettingsRequest: S.Schema<PutNotificationSettingsRequest>;
export type SourceData = {
    x509CertificateData: string;
    acmPcaArn?: never;
} | {
    x509CertificateData?: never;
    acmPcaArn: string;
};
export declare const SourceData: S.Union<readonly [S.Struct<{
    readonly x509CertificateData: S.String;
}>, S.Struct<{
    readonly acmPcaArn: S.String;
}>]>;
export interface Source {
    sourceType?: string;
    sourceData?: SourceData;
}
export declare const Source: S.Schema<Source>;
export interface NotificationSettingDetail {
    enabled: boolean;
    event: string;
    threshold?: number;
    channel?: string;
    configuredBy?: string;
}
export declare const NotificationSettingDetail: S.Schema<NotificationSettingDetail>;
export type NotificationSettingDetails = NotificationSettingDetail[];
export declare const NotificationSettingDetails: S.$Array<S.Schema<NotificationSettingDetail>>;
export interface TrustAnchorDetail {
    trustAnchorId?: string;
    trustAnchorArn?: string;
    name?: string;
    source?: Source;
    enabled?: boolean;
    createdAt?: Date;
    updatedAt?: Date;
    notificationSettings?: NotificationSettingDetail[];
}
export declare const TrustAnchorDetail: S.Schema<TrustAnchorDetail>;
export interface PutNotificationSettingsResponse {
    trustAnchor: TrustAnchorDetail;
}
export declare const PutNotificationSettingsResponse: S.Schema<PutNotificationSettingsResponse>;
export interface NotificationSettingKey {
    event: string;
    channel?: string;
}
export declare const NotificationSettingKey: S.Schema<NotificationSettingKey>;
export type NotificationSettingKeys = NotificationSettingKey[];
export declare const NotificationSettingKeys: S.$Array<S.Schema<NotificationSettingKey>>;
export interface ResetNotificationSettingsRequest {
    trustAnchorId: string;
    notificationSettingKeys: NotificationSettingKey[];
}
export declare const ResetNotificationSettingsRequest: S.Schema<ResetNotificationSettingsRequest>;
export interface ResetNotificationSettingsResponse {
    trustAnchor: TrustAnchorDetail;
}
export declare const ResetNotificationSettingsResponse: S.Schema<ResetNotificationSettingsResponse>;
export interface TagResourceRequest {
    resourceArn: string;
    tags: Tag[];
}
export declare const TagResourceRequest: S.Schema<TagResourceRequest>;
export interface TagResourceResponse {
}
export declare const TagResourceResponse: S.Schema<TagResourceResponse>;
export type TagKeyList = string | redacted.Redacted<string>[];
export declare const TagKeyList: S.$Array<S.Schema<string | redacted.Redacted<string>>>;
export interface UntagResourceRequest {
    resourceArn: string;
    tagKeys: string | redacted.Redacted<string>[];
}
export declare const UntagResourceRequest: S.Schema<UntagResourceRequest>;
export interface UntagResourceResponse {
}
export declare const UntagResourceResponse: S.Schema<UntagResourceResponse>;
export interface ImportCrlRequest {
    name: string;
    crlData: Uint8Array;
    enabled?: boolean;
    tags?: Tag[];
    trustAnchorArn: string;
}
export declare const ImportCrlRequest: S.Schema<ImportCrlRequest>;
export interface CrlDetail {
    crlId?: string;
    crlArn?: string;
    name?: string;
    enabled?: boolean;
    crlData?: Uint8Array;
    trustAnchorArn?: string;
    createdAt?: Date;
    updatedAt?: Date;
}
export declare const CrlDetail: S.Schema<CrlDetail>;
export interface CrlDetailResponse {
    crl: CrlDetail;
}
export declare const CrlDetailResponse: S.Schema<CrlDetailResponse>;
export interface ScalarCrlRequest {
    crlId: string;
}
export declare const ScalarCrlRequest: S.Schema<ScalarCrlRequest>;
export interface UpdateCrlRequest {
    crlId: string;
    name?: string;
    crlData?: Uint8Array;
}
export declare const UpdateCrlRequest: S.Schema<UpdateCrlRequest>;
export interface ListRequest {
    nextToken?: string;
    pageSize?: number;
}
export declare const ListRequest: S.Schema<ListRequest>;
export type CrlDetails = CrlDetail[];
export declare const CrlDetails: S.$Array<S.Schema<CrlDetail>>;
export interface ListCrlsResponse {
    nextToken?: string;
    crls?: CrlDetail[];
}
export declare const ListCrlsResponse: S.Schema<ListCrlsResponse>;
export type RoleArnList = string[];
export declare const RoleArnList: S.$Array<S.String>;
export type ManagedPolicyList = string[];
export declare const ManagedPolicyList: S.$Array<S.String>;
export interface CreateProfileRequest {
    name: string;
    requireInstanceProperties?: boolean;
    sessionPolicy?: string;
    roleArns: string[];
    managedPolicyArns?: string[];
    durationSeconds?: number;
    enabled?: boolean;
    tags?: Tag[];
    acceptRoleSessionName?: boolean;
}
export declare const CreateProfileRequest: S.Schema<CreateProfileRequest>;
export interface MappingRule {
    specifier: string;
}
export declare const MappingRule: S.Schema<MappingRule>;
export type MappingRules = MappingRule[];
export declare const MappingRules: S.$Array<S.Schema<MappingRule>>;
export interface AttributeMapping {
    certificateField?: string;
    mappingRules?: MappingRule[];
}
export declare const AttributeMapping: S.Schema<AttributeMapping>;
export type AttributeMappings = AttributeMapping[];
export declare const AttributeMappings: S.$Array<S.Schema<AttributeMapping>>;
export interface ProfileDetail {
    profileId?: string;
    profileArn?: string;
    name?: string;
    requireInstanceProperties?: boolean;
    enabled?: boolean;
    createdBy?: string;
    sessionPolicy?: string;
    roleArns?: string[];
    managedPolicyArns?: string[];
    createdAt?: Date;
    updatedAt?: Date;
    durationSeconds?: number;
    acceptRoleSessionName?: boolean;
    attributeMappings?: AttributeMapping[];
}
export declare const ProfileDetail: S.Schema<ProfileDetail>;
export interface ProfileDetailResponse {
    profile?: ProfileDetail;
}
export declare const ProfileDetailResponse: S.Schema<ProfileDetailResponse>;
export interface ScalarProfileRequest {
    profileId: string;
}
export declare const ScalarProfileRequest: S.Schema<ScalarProfileRequest>;
export interface UpdateProfileRequest {
    profileId: string;
    name?: string;
    sessionPolicy?: string;
    roleArns?: string[];
    managedPolicyArns?: string[];
    durationSeconds?: number;
    acceptRoleSessionName?: boolean;
}
export declare const UpdateProfileRequest: S.Schema<UpdateProfileRequest>;
export type ProfileDetails = ProfileDetail[];
export declare const ProfileDetails: S.$Array<S.Schema<ProfileDetail>>;
export interface ListProfilesResponse {
    nextToken?: string;
    profiles?: ProfileDetail[];
}
export declare const ListProfilesResponse: S.Schema<ListProfilesResponse>;
export type SpecifierList = string[];
export declare const SpecifierList: S.$Array<S.String>;
export interface DeleteAttributeMappingRequest {
    profileId: string;
    certificateField: string;
    specifiers?: string[];
}
export declare const DeleteAttributeMappingRequest: S.Schema<DeleteAttributeMappingRequest>;
export interface DeleteAttributeMappingResponse {
    profile: ProfileDetail;
}
export declare const DeleteAttributeMappingResponse: S.Schema<DeleteAttributeMappingResponse>;
export interface PutAttributeMappingRequest {
    profileId: string;
    certificateField: string;
    mappingRules: MappingRule[];
}
export declare const PutAttributeMappingRequest: S.Schema<PutAttributeMappingRequest>;
export interface PutAttributeMappingResponse {
    profile: ProfileDetail;
}
export declare const PutAttributeMappingResponse: S.Schema<PutAttributeMappingResponse>;
export interface ScalarSubjectRequest {
    subjectId: string;
}
export declare const ScalarSubjectRequest: S.Schema<ScalarSubjectRequest>;
export interface CredentialSummary {
    seenAt?: Date;
    serialNumber?: string;
    issuer?: string;
    enabled?: boolean;
    x509CertificateData?: string;
    failed?: boolean;
}
export declare const CredentialSummary: S.Schema<CredentialSummary>;
export type CredentialSummaries = CredentialSummary[];
export declare const CredentialSummaries: S.$Array<S.Schema<CredentialSummary>>;
export type InstancePropertyMap = {
    [key: string]: string | undefined;
};
export declare const InstancePropertyMap: S.$Record<S.String, S.optional<S.String>>;
export interface InstanceProperty {
    seenAt?: Date;
    properties?: {
        [key: string]: string | undefined;
    };
    failed?: boolean;
}
export declare const InstanceProperty: S.Schema<InstanceProperty>;
export type InstanceProperties = InstanceProperty[];
export declare const InstanceProperties: S.$Array<S.Schema<InstanceProperty>>;
export interface SubjectDetail {
    subjectArn?: string;
    subjectId?: string;
    enabled?: boolean;
    x509Subject?: string;
    lastSeenAt?: Date;
    createdAt?: Date;
    updatedAt?: Date;
    credentials?: CredentialSummary[];
    instanceProperties?: InstanceProperty[];
}
export declare const SubjectDetail: S.Schema<SubjectDetail>;
export interface SubjectDetailResponse {
    subject?: SubjectDetail;
}
export declare const SubjectDetailResponse: S.Schema<SubjectDetailResponse>;
export interface SubjectSummary {
    subjectArn?: string;
    subjectId?: string;
    enabled?: boolean;
    x509Subject?: string;
    lastSeenAt?: Date;
    createdAt?: Date;
    updatedAt?: Date;
}
export declare const SubjectSummary: S.Schema<SubjectSummary>;
export type SubjectSummaries = SubjectSummary[];
export declare const SubjectSummaries: S.$Array<S.Schema<SubjectSummary>>;
export interface ListSubjectsResponse {
    subjects?: SubjectSummary[];
    nextToken?: string;
}
export declare const ListSubjectsResponse: S.Schema<ListSubjectsResponse>;
export interface CreateTrustAnchorRequest {
    name: string;
    source: Source;
    enabled?: boolean;
    tags?: Tag[];
    notificationSettings?: NotificationSetting[];
}
export declare const CreateTrustAnchorRequest: S.Schema<CreateTrustAnchorRequest>;
export interface TrustAnchorDetailResponse {
    trustAnchor: TrustAnchorDetail;
}
export declare const TrustAnchorDetailResponse: S.Schema<TrustAnchorDetailResponse>;
export interface ScalarTrustAnchorRequest {
    trustAnchorId: string;
}
export declare const ScalarTrustAnchorRequest: S.Schema<ScalarTrustAnchorRequest>;
export interface UpdateTrustAnchorRequest {
    trustAnchorId: string;
    name?: string;
    source?: Source;
}
export declare const UpdateTrustAnchorRequest: S.Schema<UpdateTrustAnchorRequest>;
export type TrustAnchorDetails = TrustAnchorDetail[];
export declare const TrustAnchorDetails: S.$Array<S.Schema<TrustAnchorDetail>>;
export interface ListTrustAnchorsResponse {
    nextToken?: string;
    trustAnchors?: TrustAnchorDetail[];
}
export declare const ListTrustAnchorsResponse: S.Schema<ListTrustAnchorsResponse>;
declare const AccessDeniedException_base: S.Class<AccessDeniedException, S.TaggedStruct<"AccessDeniedException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        AuthError: true;
    };
});
export declare class AccessDeniedException extends AccessDeniedException_base {
}
declare const ResourceNotFoundException_base: S.Class<ResourceNotFoundException, S.TaggedStruct<"ResourceNotFoundException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ResourceNotFoundException extends ResourceNotFoundException_base {
}
declare const ValidationException_base: S.Class<ValidationException, S.TaggedStruct<"ValidationException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class ValidationException extends ValidationException_base {
}
declare const TooManyTagsException_base: S.Class<TooManyTagsException, S.TaggedStruct<"TooManyTagsException", {
    readonly message: S.optional<S.String>;
}>, import("effect/Cause").YieldableError> & (new (...args: any[]) => {
    "@distilled.cloud/error/categories": {
        BadRequestError: true;
    };
});
export declare class TooManyTagsException extends TooManyTagsException_base {
}
export type ListTagsForResourceError = AccessDeniedException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Lists the tags attached to the resource.
 *
 * **Required permissions: ** `rolesanywhere:ListTagsForResource`.
 */
export declare const listTagsForResource: API.OperationMethod<ListTagsForResourceRequest, ListTagsForResourceResponse, ListTagsForResourceError, Credentials | Region | HttpClient.HttpClient>;
export type PutNotificationSettingsError = AccessDeniedException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Attaches a list of *notification settings* to a trust anchor.
 *
 * A notification setting includes information such as event name, threshold, status of the notification setting, and the channel to notify.
 *
 * **Required permissions: ** `rolesanywhere:PutNotificationSettings`.
 */
export declare const putNotificationSettings: API.OperationMethod<PutNotificationSettingsRequest, PutNotificationSettingsResponse, PutNotificationSettingsError, Credentials | Region | HttpClient.HttpClient>;
export type ResetNotificationSettingsError = AccessDeniedException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Resets the *custom notification setting* to IAM Roles Anywhere default setting.
 *
 * **Required permissions: ** `rolesanywhere:ResetNotificationSettings`.
 */
export declare const resetNotificationSettings: API.OperationMethod<ResetNotificationSettingsRequest, ResetNotificationSettingsResponse, ResetNotificationSettingsError, Credentials | Region | HttpClient.HttpClient>;
export type TagResourceError = AccessDeniedException | ResourceNotFoundException | TooManyTagsException | ValidationException | CommonErrors;
/**
 * Attaches tags to a resource.
 *
 * **Required permissions: ** `rolesanywhere:TagResource`.
 */
export declare const tagResource: API.OperationMethod<TagResourceRequest, TagResourceResponse, TagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type UntagResourceError = AccessDeniedException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Removes tags from the resource.
 *
 * **Required permissions: ** `rolesanywhere:UntagResource`.
 */
export declare const untagResource: API.OperationMethod<UntagResourceRequest, UntagResourceResponse, UntagResourceError, Credentials | Region | HttpClient.HttpClient>;
export type ImportCrlError = AccessDeniedException | ValidationException | CommonErrors;
/**
 * Imports the certificate revocation list (CRL). A CRL is a list of certificates that have been revoked by the issuing certificate Authority (CA).In order to be properly imported, a CRL must be in PEM format. IAM Roles Anywhere validates against the CRL before issuing credentials.
 *
 * **Required permissions: ** `rolesanywhere:ImportCrl`.
 */
export declare const importCrl: API.OperationMethod<ImportCrlRequest, CrlDetailResponse, ImportCrlError, Credentials | Region | HttpClient.HttpClient>;
export type GetCrlError = ResourceNotFoundException | CommonErrors;
/**
 * Gets a certificate revocation list (CRL).
 *
 * **Required permissions: ** `rolesanywhere:GetCrl`.
 */
export declare const getCrl: API.OperationMethod<ScalarCrlRequest, CrlDetailResponse, GetCrlError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateCrlError = AccessDeniedException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Updates the certificate revocation list (CRL). A CRL is a list of certificates that have been revoked by the issuing certificate authority (CA). IAM Roles Anywhere validates against the CRL before issuing credentials.
 *
 * **Required permissions: ** `rolesanywhere:UpdateCrl`.
 */
export declare const updateCrl: API.OperationMethod<UpdateCrlRequest, CrlDetailResponse, UpdateCrlError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteCrlError = AccessDeniedException | ResourceNotFoundException | CommonErrors;
/**
 * Deletes a certificate revocation list (CRL).
 *
 * **Required permissions: ** `rolesanywhere:DeleteCrl`.
 */
export declare const deleteCrl: API.OperationMethod<ScalarCrlRequest, CrlDetailResponse, DeleteCrlError, Credentials | Region | HttpClient.HttpClient>;
export type ListCrlsError = AccessDeniedException | ValidationException | CommonErrors;
/**
 * Lists all certificate revocation lists (CRL) in the authenticated account and Amazon Web Services Region.
 *
 * **Required permissions: ** `rolesanywhere:ListCrls`.
 */
export declare const listCrls: API.OperationMethod<ListRequest, ListCrlsResponse, ListCrlsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListRequest) => stream.Stream<ListCrlsResponse, ListCrlsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListRequest) => stream.Stream<CrlDetail, ListCrlsError, Credentials | Region | HttpClient.HttpClient>;
};
export type DisableCrlError = AccessDeniedException | ResourceNotFoundException | CommonErrors;
/**
 * Disables a certificate revocation list (CRL).
 *
 * **Required permissions: ** `rolesanywhere:DisableCrl`.
 */
export declare const disableCrl: API.OperationMethod<ScalarCrlRequest, CrlDetailResponse, DisableCrlError, Credentials | Region | HttpClient.HttpClient>;
export type EnableCrlError = AccessDeniedException | ResourceNotFoundException | CommonErrors;
/**
 * Enables a certificate revocation list (CRL). When enabled, certificates stored in the CRL are unauthorized to receive session credentials.
 *
 * **Required permissions: ** `rolesanywhere:EnableCrl`.
 */
export declare const enableCrl: API.OperationMethod<ScalarCrlRequest, CrlDetailResponse, EnableCrlError, Credentials | Region | HttpClient.HttpClient>;
export type CreateProfileError = AccessDeniedException | ValidationException | CommonErrors;
/**
 * Creates a *profile*, a list of the roles that Roles Anywhere service is trusted to assume. You use profiles to intersect permissions with IAM managed policies.
 *
 * **Required permissions: ** `rolesanywhere:CreateProfile`.
 */
export declare const createProfile: API.OperationMethod<CreateProfileRequest, ProfileDetailResponse, CreateProfileError, Credentials | Region | HttpClient.HttpClient>;
export type GetProfileError = AccessDeniedException | ResourceNotFoundException | CommonErrors;
/**
 * Gets a profile.
 *
 * **Required permissions: ** `rolesanywhere:GetProfile`.
 */
export declare const getProfile: API.OperationMethod<ScalarProfileRequest, ProfileDetailResponse, GetProfileError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateProfileError = AccessDeniedException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Updates a *profile*, a list of the roles that IAM Roles Anywhere service is trusted to assume. You use profiles to intersect permissions with IAM managed policies.
 *
 * **Required permissions: ** `rolesanywhere:UpdateProfile`.
 */
export declare const updateProfile: API.OperationMethod<UpdateProfileRequest, ProfileDetailResponse, UpdateProfileError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteProfileError = AccessDeniedException | ResourceNotFoundException | CommonErrors;
/**
 * Deletes a profile.
 *
 * **Required permissions: ** `rolesanywhere:DeleteProfile`.
 */
export declare const deleteProfile: API.OperationMethod<ScalarProfileRequest, ProfileDetailResponse, DeleteProfileError, Credentials | Region | HttpClient.HttpClient>;
export type ListProfilesError = AccessDeniedException | ValidationException | CommonErrors;
/**
 * Lists all profiles in the authenticated account and Amazon Web Services Region.
 *
 * **Required permissions: ** `rolesanywhere:ListProfiles`.
 */
export declare const listProfiles: API.OperationMethod<ListRequest, ListProfilesResponse, ListProfilesError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListRequest) => stream.Stream<ListProfilesResponse, ListProfilesError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListRequest) => stream.Stream<ProfileDetail, ListProfilesError, Credentials | Region | HttpClient.HttpClient>;
};
export type DeleteAttributeMappingError = AccessDeniedException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Delete an entry from the attribute mapping rules enforced by a given profile.
 */
export declare const deleteAttributeMapping: API.OperationMethod<DeleteAttributeMappingRequest, DeleteAttributeMappingResponse, DeleteAttributeMappingError, Credentials | Region | HttpClient.HttpClient>;
export type DisableProfileError = AccessDeniedException | ResourceNotFoundException | CommonErrors;
/**
 * Disables a profile. When disabled, temporary credential requests with this profile fail.
 *
 * **Required permissions: ** `rolesanywhere:DisableProfile`.
 */
export declare const disableProfile: API.OperationMethod<ScalarProfileRequest, ProfileDetailResponse, DisableProfileError, Credentials | Region | HttpClient.HttpClient>;
export type EnableProfileError = AccessDeniedException | ResourceNotFoundException | CommonErrors;
/**
 * Enables temporary credential requests for a profile.
 *
 * **Required permissions: ** `rolesanywhere:EnableProfile`.
 */
export declare const enableProfile: API.OperationMethod<ScalarProfileRequest, ProfileDetailResponse, EnableProfileError, Credentials | Region | HttpClient.HttpClient>;
export type PutAttributeMappingError = AccessDeniedException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Put an entry in the attribute mapping rules that will be enforced by a given profile. A mapping specifies a certificate field and one or more specifiers that have contextual meanings.
 */
export declare const putAttributeMapping: API.OperationMethod<PutAttributeMappingRequest, PutAttributeMappingResponse, PutAttributeMappingError, Credentials | Region | HttpClient.HttpClient>;
export type GetSubjectError = AccessDeniedException | ResourceNotFoundException | CommonErrors;
/**
 * Gets a *subject*, which associates a certificate identity with authentication attempts. The subject stores auditing information such as the status of the last authentication attempt, the certificate data used in the attempt, and the last time the associated identity attempted authentication.
 *
 * **Required permissions: ** `rolesanywhere:GetSubject`.
 */
export declare const getSubject: API.OperationMethod<ScalarSubjectRequest, SubjectDetailResponse, GetSubjectError, Credentials | Region | HttpClient.HttpClient>;
export type ListSubjectsError = AccessDeniedException | ValidationException | CommonErrors;
/**
 * Lists the subjects in the authenticated account and Amazon Web Services Region.
 *
 * **Required permissions: ** `rolesanywhere:ListSubjects`.
 */
export declare const listSubjects: API.OperationMethod<ListRequest, ListSubjectsResponse, ListSubjectsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListRequest) => stream.Stream<ListSubjectsResponse, ListSubjectsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListRequest) => stream.Stream<SubjectSummary, ListSubjectsError, Credentials | Region | HttpClient.HttpClient>;
};
export type CreateTrustAnchorError = AccessDeniedException | ValidationException | CommonErrors;
/**
 * Creates a trust anchor to establish trust between IAM Roles Anywhere and your certificate authority (CA). You can define a trust anchor as a reference to an Private Certificate Authority (Private CA) or by uploading a CA certificate. Your Amazon Web Services workloads can authenticate with the trust anchor using certificates issued by the CA in exchange for temporary Amazon Web Services credentials.
 *
 * **Required permissions: ** `rolesanywhere:CreateTrustAnchor`.
 */
export declare const createTrustAnchor: API.OperationMethod<CreateTrustAnchorRequest, TrustAnchorDetailResponse, CreateTrustAnchorError, Credentials | Region | HttpClient.HttpClient>;
export type GetTrustAnchorError = AccessDeniedException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Gets a trust anchor.
 *
 * **Required permissions: ** `rolesanywhere:GetTrustAnchor`.
 */
export declare const getTrustAnchor: API.OperationMethod<ScalarTrustAnchorRequest, TrustAnchorDetailResponse, GetTrustAnchorError, Credentials | Region | HttpClient.HttpClient>;
export type UpdateTrustAnchorError = AccessDeniedException | ResourceNotFoundException | ValidationException | CommonErrors;
/**
 * Updates a trust anchor. You establish trust between IAM Roles Anywhere and your certificate authority (CA) by configuring a trust anchor. You can define a trust anchor as a reference to an Private Certificate Authority (Private CA) or by uploading a CA certificate. Your Amazon Web Services workloads can authenticate with the trust anchor using certificates issued by the CA in exchange for temporary Amazon Web Services credentials.
 *
 * **Required permissions: ** `rolesanywhere:UpdateTrustAnchor`.
 */
export declare const updateTrustAnchor: API.OperationMethod<UpdateTrustAnchorRequest, TrustAnchorDetailResponse, UpdateTrustAnchorError, Credentials | Region | HttpClient.HttpClient>;
export type DeleteTrustAnchorError = AccessDeniedException | ResourceNotFoundException | CommonErrors;
/**
 * Deletes a trust anchor.
 *
 * **Required permissions: ** `rolesanywhere:DeleteTrustAnchor`.
 */
export declare const deleteTrustAnchor: API.OperationMethod<ScalarTrustAnchorRequest, TrustAnchorDetailResponse, DeleteTrustAnchorError, Credentials | Region | HttpClient.HttpClient>;
export type ListTrustAnchorsError = AccessDeniedException | ValidationException | CommonErrors;
/**
 * Lists the trust anchors in the authenticated account and Amazon Web Services Region.
 *
 * **Required permissions: ** `rolesanywhere:ListTrustAnchors`.
 */
export declare const listTrustAnchors: API.OperationMethod<ListRequest, ListTrustAnchorsResponse, ListTrustAnchorsError, Credentials | Region | HttpClient.HttpClient> & {
    pages: (input: ListRequest) => stream.Stream<ListTrustAnchorsResponse, ListTrustAnchorsError, Credentials | Region | HttpClient.HttpClient>;
    items: (input: ListRequest) => stream.Stream<TrustAnchorDetail, ListTrustAnchorsError, Credentials | Region | HttpClient.HttpClient>;
};
export type DisableTrustAnchorError = AccessDeniedException | ResourceNotFoundException | CommonErrors;
/**
 * Disables a trust anchor. When disabled, temporary credential requests specifying this trust anchor are unauthorized.
 *
 * **Required permissions: ** `rolesanywhere:DisableTrustAnchor`.
 */
export declare const disableTrustAnchor: API.OperationMethod<ScalarTrustAnchorRequest, TrustAnchorDetailResponse, DisableTrustAnchorError, Credentials | Region | HttpClient.HttpClient>;
export type EnableTrustAnchorError = AccessDeniedException | ResourceNotFoundException | CommonErrors;
/**
 * Enables a trust anchor. When enabled, certificates in the trust anchor chain are authorized for trust validation.
 *
 * **Required permissions: ** `rolesanywhere:EnableTrustAnchor`.
 */
export declare const enableTrustAnchor: API.OperationMethod<ScalarTrustAnchorRequest, TrustAnchorDetailResponse, EnableTrustAnchorError, Credentials | Region | HttpClient.HttpClient>;
export {};
//# sourceMappingURL=rolesanywhere.d.ts.map