@aws-sdk/client-rolesanywhere 3.123.0

package/dist-types/commands/CreateTrustAnchorCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CreateTrustAnchorRequest, TrustAnchorDetailResponse } from "../models/models_0";
+import { RolesAnywhereClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RolesAnywhereClient";
+export interface CreateTrustAnchorCommandInput extends CreateTrustAnchorRequest {
+}
+export interface CreateTrustAnchorCommandOutput extends TrustAnchorDetailResponse, __MetadataBearer {
+}
+/**
+ * <p>Creates a trust anchor. You establish trust between IAM Roles Anywhere and your certificate authority (CA) by configuring a trust anchor. A Trust Anchor is defined either as a reference to a AWS Certificate Manager Private Certificate Authority (ACM PCA), or by uploading a Certificate Authority (CA) certificate. Your AWS workloads can authenticate with the trust anchor using certificates issued by the trusted Certificate Authority (CA) in exchange for temporary AWS credentials.</p>
+ *          <p>
+ *             <b>Required permissions: </b>
+ *             <code>rolesanywhere:CreateTrustAnchor</code>.
+ *          </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RolesAnywhereClient, CreateTrustAnchorCommand } from "@aws-sdk/client-rolesanywhere"; // ES Modules import
+ * // const { RolesAnywhereClient, CreateTrustAnchorCommand } = require("@aws-sdk/client-rolesanywhere"); // CommonJS import
+ * const client = new RolesAnywhereClient(config);
+ * const command = new CreateTrustAnchorCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link CreateTrustAnchorCommandInput} for command's `input` shape.
+ * @see {@link CreateTrustAnchorCommandOutput} for command's `response` shape.
+ * @see {@link RolesAnywhereClientResolvedConfig | config} for RolesAnywhereClient's `config` shape.
+ *
+ */
+export declare class CreateTrustAnchorCommand extends $Command<CreateTrustAnchorCommandInput, CreateTrustAnchorCommandOutput, RolesAnywhereClientResolvedConfig> {
+    readonly input: CreateTrustAnchorCommandInput;
+    constructor(input: CreateTrustAnchorCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RolesAnywhereClientResolvedConfig, options?: __HttpHandlerOptions): Handler<CreateTrustAnchorCommandInput, CreateTrustAnchorCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteCrlCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CrlDetailResponse, ScalarCrlRequest } from "../models/models_0";
+import { RolesAnywhereClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RolesAnywhereClient";
+export interface DeleteCrlCommandInput extends ScalarCrlRequest {
+}
+export interface DeleteCrlCommandOutput extends CrlDetailResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes a certificate revocation list (CRL).</p>
+ *          <p>
+ *             <b>Required permissions: </b>
+ *             <code>rolesanywhere:DeleteCrl</code>.
+ *          </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RolesAnywhereClient, DeleteCrlCommand } from "@aws-sdk/client-rolesanywhere"; // ES Modules import
+ * // const { RolesAnywhereClient, DeleteCrlCommand } = require("@aws-sdk/client-rolesanywhere"); // CommonJS import
+ * const client = new RolesAnywhereClient(config);
+ * const command = new DeleteCrlCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteCrlCommandInput} for command's `input` shape.
+ * @see {@link DeleteCrlCommandOutput} for command's `response` shape.
+ * @see {@link RolesAnywhereClientResolvedConfig | config} for RolesAnywhereClient's `config` shape.
+ *
+ */
+export declare class DeleteCrlCommand extends $Command<DeleteCrlCommandInput, DeleteCrlCommandOutput, RolesAnywhereClientResolvedConfig> {
+    readonly input: DeleteCrlCommandInput;
+    constructor(input: DeleteCrlCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RolesAnywhereClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteCrlCommandInput, DeleteCrlCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteProfileCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ProfileDetailResponse, ScalarProfileRequest } from "../models/models_0";
+import { RolesAnywhereClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RolesAnywhereClient";
+export interface DeleteProfileCommandInput extends ScalarProfileRequest {
+}
+export interface DeleteProfileCommandOutput extends ProfileDetailResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes a profile.</p>
+ *          <p>
+ *             <b>Required permissions: </b>
+ *             <code>rolesanywhere:DeleteProfile</code>.
+ *          </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RolesAnywhereClient, DeleteProfileCommand } from "@aws-sdk/client-rolesanywhere"; // ES Modules import
+ * // const { RolesAnywhereClient, DeleteProfileCommand } = require("@aws-sdk/client-rolesanywhere"); // CommonJS import
+ * const client = new RolesAnywhereClient(config);
+ * const command = new DeleteProfileCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteProfileCommandInput} for command's `input` shape.
+ * @see {@link DeleteProfileCommandOutput} for command's `response` shape.
+ * @see {@link RolesAnywhereClientResolvedConfig | config} for RolesAnywhereClient's `config` shape.
+ *
+ */
+export declare class DeleteProfileCommand extends $Command<DeleteProfileCommandInput, DeleteProfileCommandOutput, RolesAnywhereClientResolvedConfig> {
+    readonly input: DeleteProfileCommandInput;
+    constructor(input: DeleteProfileCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RolesAnywhereClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteProfileCommandInput, DeleteProfileCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DeleteTrustAnchorCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ScalarTrustAnchorRequest, TrustAnchorDetailResponse } from "../models/models_0";
+import { RolesAnywhereClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RolesAnywhereClient";
+export interface DeleteTrustAnchorCommandInput extends ScalarTrustAnchorRequest {
+}
+export interface DeleteTrustAnchorCommandOutput extends TrustAnchorDetailResponse, __MetadataBearer {
+}
+/**
+ * <p>Deletes a trust anchor.</p>
+ *          <p>
+ *             <b>Required permissions: </b>
+ *             <code>rolesanywhere:DeleteTrustAnchor</code>.
+ *          </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RolesAnywhereClient, DeleteTrustAnchorCommand } from "@aws-sdk/client-rolesanywhere"; // ES Modules import
+ * // const { RolesAnywhereClient, DeleteTrustAnchorCommand } = require("@aws-sdk/client-rolesanywhere"); // CommonJS import
+ * const client = new RolesAnywhereClient(config);
+ * const command = new DeleteTrustAnchorCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DeleteTrustAnchorCommandInput} for command's `input` shape.
+ * @see {@link DeleteTrustAnchorCommandOutput} for command's `response` shape.
+ * @see {@link RolesAnywhereClientResolvedConfig | config} for RolesAnywhereClient's `config` shape.
+ *
+ */
+export declare class DeleteTrustAnchorCommand extends $Command<DeleteTrustAnchorCommandInput, DeleteTrustAnchorCommandOutput, RolesAnywhereClientResolvedConfig> {
+    readonly input: DeleteTrustAnchorCommandInput;
+    constructor(input: DeleteTrustAnchorCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RolesAnywhereClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DeleteTrustAnchorCommandInput, DeleteTrustAnchorCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DisableCrlCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CrlDetailResponse, ScalarCrlRequest } from "../models/models_0";
+import { RolesAnywhereClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RolesAnywhereClient";
+export interface DisableCrlCommandInput extends ScalarCrlRequest {
+}
+export interface DisableCrlCommandOutput extends CrlDetailResponse, __MetadataBearer {
+}
+/**
+ * <p>Disables a certificate revocation list (CRL).</p>
+ *          <p>
+ *             <b>Required permissions: </b>
+ *             <code>rolesanywhere:DisableCrl</code>.
+ *          </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RolesAnywhereClient, DisableCrlCommand } from "@aws-sdk/client-rolesanywhere"; // ES Modules import
+ * // const { RolesAnywhereClient, DisableCrlCommand } = require("@aws-sdk/client-rolesanywhere"); // CommonJS import
+ * const client = new RolesAnywhereClient(config);
+ * const command = new DisableCrlCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DisableCrlCommandInput} for command's `input` shape.
+ * @see {@link DisableCrlCommandOutput} for command's `response` shape.
+ * @see {@link RolesAnywhereClientResolvedConfig | config} for RolesAnywhereClient's `config` shape.
+ *
+ */
+export declare class DisableCrlCommand extends $Command<DisableCrlCommandInput, DisableCrlCommandOutput, RolesAnywhereClientResolvedConfig> {
+    readonly input: DisableCrlCommandInput;
+    constructor(input: DisableCrlCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RolesAnywhereClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisableCrlCommandInput, DisableCrlCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DisableProfileCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ProfileDetailResponse, ScalarProfileRequest } from "../models/models_0";
+import { RolesAnywhereClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RolesAnywhereClient";
+export interface DisableProfileCommandInput extends ScalarProfileRequest {
+}
+export interface DisableProfileCommandOutput extends ProfileDetailResponse, __MetadataBearer {
+}
+/**
+ * <p>Disables a profile. When disabled, <a href="https://docs.aws.amazon.com/rolesanywhere/latest/APIReference/API_CreateSession.html">CreateSession</a> requests with this profile fail.</p>
+ *          <p>
+ *             <b>Required permissions: </b>
+ *             <code>rolesanywhere:DisableProfile</code>.
+ *          </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RolesAnywhereClient, DisableProfileCommand } from "@aws-sdk/client-rolesanywhere"; // ES Modules import
+ * // const { RolesAnywhereClient, DisableProfileCommand } = require("@aws-sdk/client-rolesanywhere"); // CommonJS import
+ * const client = new RolesAnywhereClient(config);
+ * const command = new DisableProfileCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DisableProfileCommandInput} for command's `input` shape.
+ * @see {@link DisableProfileCommandOutput} for command's `response` shape.
+ * @see {@link RolesAnywhereClientResolvedConfig | config} for RolesAnywhereClient's `config` shape.
+ *
+ */
+export declare class DisableProfileCommand extends $Command<DisableProfileCommandInput, DisableProfileCommandOutput, RolesAnywhereClientResolvedConfig> {
+    readonly input: DisableProfileCommandInput;
+    constructor(input: DisableProfileCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RolesAnywhereClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisableProfileCommandInput, DisableProfileCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/DisableTrustAnchorCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ScalarTrustAnchorRequest, TrustAnchorDetailResponse } from "../models/models_0";
+import { RolesAnywhereClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RolesAnywhereClient";
+export interface DisableTrustAnchorCommandInput extends ScalarTrustAnchorRequest {
+}
+export interface DisableTrustAnchorCommandOutput extends TrustAnchorDetailResponse, __MetadataBearer {
+}
+/**
+ * <p>Disables a trust anchor. When disabled, <a href="https://docs.aws.amazon.com/rolesanywhere/latest/APIReference/API_CreateSession.html">CreateSession</a> requests specifying this trust anchor are unauthorized.</p>
+ *          <p>
+ *             <b>Required permissions: </b>
+ *             <code>rolesanywhere:DisableTrustAnchor</code>.
+ *          </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RolesAnywhereClient, DisableTrustAnchorCommand } from "@aws-sdk/client-rolesanywhere"; // ES Modules import
+ * // const { RolesAnywhereClient, DisableTrustAnchorCommand } = require("@aws-sdk/client-rolesanywhere"); // CommonJS import
+ * const client = new RolesAnywhereClient(config);
+ * const command = new DisableTrustAnchorCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link DisableTrustAnchorCommandInput} for command's `input` shape.
+ * @see {@link DisableTrustAnchorCommandOutput} for command's `response` shape.
+ * @see {@link RolesAnywhereClientResolvedConfig | config} for RolesAnywhereClient's `config` shape.
+ *
+ */
+export declare class DisableTrustAnchorCommand extends $Command<DisableTrustAnchorCommandInput, DisableTrustAnchorCommandOutput, RolesAnywhereClientResolvedConfig> {
+    readonly input: DisableTrustAnchorCommandInput;
+    constructor(input: DisableTrustAnchorCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RolesAnywhereClientResolvedConfig, options?: __HttpHandlerOptions): Handler<DisableTrustAnchorCommandInput, DisableTrustAnchorCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/EnableCrlCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CrlDetailResponse, ScalarCrlRequest } from "../models/models_0";
+import { RolesAnywhereClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RolesAnywhereClient";
+export interface EnableCrlCommandInput extends ScalarCrlRequest {
+}
+export interface EnableCrlCommandOutput extends CrlDetailResponse, __MetadataBearer {
+}
+/**
+ * <p>Enables a certificate revocation list (CRL). When enabled, certificates stored in the CRL are unauthorized to receive session credentials.</p>
+ *          <p>
+ *             <b>Required permissions: </b>
+ *             <code>rolesanywhere:EnableCrl</code>.
+ *          </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RolesAnywhereClient, EnableCrlCommand } from "@aws-sdk/client-rolesanywhere"; // ES Modules import
+ * // const { RolesAnywhereClient, EnableCrlCommand } = require("@aws-sdk/client-rolesanywhere"); // CommonJS import
+ * const client = new RolesAnywhereClient(config);
+ * const command = new EnableCrlCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link EnableCrlCommandInput} for command's `input` shape.
+ * @see {@link EnableCrlCommandOutput} for command's `response` shape.
+ * @see {@link RolesAnywhereClientResolvedConfig | config} for RolesAnywhereClient's `config` shape.
+ *
+ */
+export declare class EnableCrlCommand extends $Command<EnableCrlCommandInput, EnableCrlCommandOutput, RolesAnywhereClientResolvedConfig> {
+    readonly input: EnableCrlCommandInput;
+    constructor(input: EnableCrlCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RolesAnywhereClientResolvedConfig, options?: __HttpHandlerOptions): Handler<EnableCrlCommandInput, EnableCrlCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/EnableProfileCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ProfileDetailResponse, ScalarProfileRequest } from "../models/models_0";
+import { RolesAnywhereClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RolesAnywhereClient";
+export interface EnableProfileCommandInput extends ScalarProfileRequest {
+}
+export interface EnableProfileCommandOutput extends ProfileDetailResponse, __MetadataBearer {
+}
+/**
+ * <p>Enables the roles in a profile to receive session credentials in <a href="https://docs.aws.amazon.com/rolesanywhere/latest/APIReference/API_CreateSession.html">CreateSession</a>. </p>
+ *          <p>
+ *             <b>Required permissions: </b>
+ *             <code>rolesanywhere:EnableProfile</code>.
+ *          </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RolesAnywhereClient, EnableProfileCommand } from "@aws-sdk/client-rolesanywhere"; // ES Modules import
+ * // const { RolesAnywhereClient, EnableProfileCommand } = require("@aws-sdk/client-rolesanywhere"); // CommonJS import
+ * const client = new RolesAnywhereClient(config);
+ * const command = new EnableProfileCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link EnableProfileCommandInput} for command's `input` shape.
+ * @see {@link EnableProfileCommandOutput} for command's `response` shape.
+ * @see {@link RolesAnywhereClientResolvedConfig | config} for RolesAnywhereClient's `config` shape.
+ *
+ */
+export declare class EnableProfileCommand extends $Command<EnableProfileCommandInput, EnableProfileCommandOutput, RolesAnywhereClientResolvedConfig> {
+    readonly input: EnableProfileCommandInput;
+    constructor(input: EnableProfileCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RolesAnywhereClientResolvedConfig, options?: __HttpHandlerOptions): Handler<EnableProfileCommandInput, EnableProfileCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/EnableTrustAnchorCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ScalarTrustAnchorRequest, TrustAnchorDetailResponse } from "../models/models_0";
+import { RolesAnywhereClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RolesAnywhereClient";
+export interface EnableTrustAnchorCommandInput extends ScalarTrustAnchorRequest {
+}
+export interface EnableTrustAnchorCommandOutput extends TrustAnchorDetailResponse, __MetadataBearer {
+}
+/**
+ * <p>Enables a trust anchor. When enabled, certificates in the trust anchor chain are authorized for trust validation. </p>
+ *          <p>
+ *             <b>Required permissions: </b>
+ *             <code>rolesanywhere:EnableTrustAnchor</code>.
+ *          </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RolesAnywhereClient, EnableTrustAnchorCommand } from "@aws-sdk/client-rolesanywhere"; // ES Modules import
+ * // const { RolesAnywhereClient, EnableTrustAnchorCommand } = require("@aws-sdk/client-rolesanywhere"); // CommonJS import
+ * const client = new RolesAnywhereClient(config);
+ * const command = new EnableTrustAnchorCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link EnableTrustAnchorCommandInput} for command's `input` shape.
+ * @see {@link EnableTrustAnchorCommandOutput} for command's `response` shape.
+ * @see {@link RolesAnywhereClientResolvedConfig | config} for RolesAnywhereClient's `config` shape.
+ *
+ */
+export declare class EnableTrustAnchorCommand extends $Command<EnableTrustAnchorCommandInput, EnableTrustAnchorCommandOutput, RolesAnywhereClientResolvedConfig> {
+    readonly input: EnableTrustAnchorCommandInput;
+    constructor(input: EnableTrustAnchorCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RolesAnywhereClientResolvedConfig, options?: __HttpHandlerOptions): Handler<EnableTrustAnchorCommandInput, EnableTrustAnchorCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetCrlCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CrlDetailResponse, ScalarCrlRequest } from "../models/models_0";
+import { RolesAnywhereClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RolesAnywhereClient";
+export interface GetCrlCommandInput extends ScalarCrlRequest {
+}
+export interface GetCrlCommandOutput extends CrlDetailResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets a certificate revocation list (CRL).</p>
+ *          <p>
+ *             <b>Required permissions: </b>
+ *             <code>rolesanywhere:GetCrl</code>.
+ *          </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RolesAnywhereClient, GetCrlCommand } from "@aws-sdk/client-rolesanywhere"; // ES Modules import
+ * // const { RolesAnywhereClient, GetCrlCommand } = require("@aws-sdk/client-rolesanywhere"); // CommonJS import
+ * const client = new RolesAnywhereClient(config);
+ * const command = new GetCrlCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetCrlCommandInput} for command's `input` shape.
+ * @see {@link GetCrlCommandOutput} for command's `response` shape.
+ * @see {@link RolesAnywhereClientResolvedConfig | config} for RolesAnywhereClient's `config` shape.
+ *
+ */
+export declare class GetCrlCommand extends $Command<GetCrlCommandInput, GetCrlCommandOutput, RolesAnywhereClientResolvedConfig> {
+    readonly input: GetCrlCommandInput;
+    constructor(input: GetCrlCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RolesAnywhereClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetCrlCommandInput, GetCrlCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetProfileCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ProfileDetailResponse, ScalarProfileRequest } from "../models/models_0";
+import { RolesAnywhereClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RolesAnywhereClient";
+export interface GetProfileCommandInput extends ScalarProfileRequest {
+}
+export interface GetProfileCommandOutput extends ProfileDetailResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets a profile.</p>
+ *          <p>
+ *             <b>Required permissions: </b>
+ *             <code>rolesanywhere:GetProfile</code>.
+ *          </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RolesAnywhereClient, GetProfileCommand } from "@aws-sdk/client-rolesanywhere"; // ES Modules import
+ * // const { RolesAnywhereClient, GetProfileCommand } = require("@aws-sdk/client-rolesanywhere"); // CommonJS import
+ * const client = new RolesAnywhereClient(config);
+ * const command = new GetProfileCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetProfileCommandInput} for command's `input` shape.
+ * @see {@link GetProfileCommandOutput} for command's `response` shape.
+ * @see {@link RolesAnywhereClientResolvedConfig | config} for RolesAnywhereClient's `config` shape.
+ *
+ */
+export declare class GetProfileCommand extends $Command<GetProfileCommandInput, GetProfileCommandOutput, RolesAnywhereClientResolvedConfig> {
+    readonly input: GetProfileCommandInput;
+    constructor(input: GetProfileCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RolesAnywhereClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetProfileCommandInput, GetProfileCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetSubjectCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ScalarSubjectRequest, SubjectDetailResponse } from "../models/models_0";
+import { RolesAnywhereClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RolesAnywhereClient";
+export interface GetSubjectCommandInput extends ScalarSubjectRequest {
+}
+export interface GetSubjectCommandOutput extends SubjectDetailResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets a Subject. A Subject associates a certificate identity with authentication attempts by CreateSession. The Subject resources stores audit information such as status of the last authentication attempt, the certificate data used in the attempt, and the last time the associated identity attempted authentication. </p>
+ *          <p>
+ *             <b>Required permissions: </b>
+ *             <code>rolesanywhere:GetSubject</code>.
+ *          </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RolesAnywhereClient, GetSubjectCommand } from "@aws-sdk/client-rolesanywhere"; // ES Modules import
+ * // const { RolesAnywhereClient, GetSubjectCommand } = require("@aws-sdk/client-rolesanywhere"); // CommonJS import
+ * const client = new RolesAnywhereClient(config);
+ * const command = new GetSubjectCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetSubjectCommandInput} for command's `input` shape.
+ * @see {@link GetSubjectCommandOutput} for command's `response` shape.
+ * @see {@link RolesAnywhereClientResolvedConfig | config} for RolesAnywhereClient's `config` shape.
+ *
+ */
+export declare class GetSubjectCommand extends $Command<GetSubjectCommandInput, GetSubjectCommandOutput, RolesAnywhereClientResolvedConfig> {
+    readonly input: GetSubjectCommandInput;
+    constructor(input: GetSubjectCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RolesAnywhereClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetSubjectCommandInput, GetSubjectCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/GetTrustAnchorCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ScalarTrustAnchorRequest, TrustAnchorDetailResponse } from "../models/models_0";
+import { RolesAnywhereClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RolesAnywhereClient";
+export interface GetTrustAnchorCommandInput extends ScalarTrustAnchorRequest {
+}
+export interface GetTrustAnchorCommandOutput extends TrustAnchorDetailResponse, __MetadataBearer {
+}
+/**
+ * <p>Gets a trust anchor.</p>
+ *          <p>
+ *             <b>Required permissions: </b>
+ *             <code>rolesanywhere:GetTrustAnchor</code>.
+ *          </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RolesAnywhereClient, GetTrustAnchorCommand } from "@aws-sdk/client-rolesanywhere"; // ES Modules import
+ * // const { RolesAnywhereClient, GetTrustAnchorCommand } = require("@aws-sdk/client-rolesanywhere"); // CommonJS import
+ * const client = new RolesAnywhereClient(config);
+ * const command = new GetTrustAnchorCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link GetTrustAnchorCommandInput} for command's `input` shape.
+ * @see {@link GetTrustAnchorCommandOutput} for command's `response` shape.
+ * @see {@link RolesAnywhereClientResolvedConfig | config} for RolesAnywhereClient's `config` shape.
+ *
+ */
+export declare class GetTrustAnchorCommand extends $Command<GetTrustAnchorCommandInput, GetTrustAnchorCommandOutput, RolesAnywhereClientResolvedConfig> {
+    readonly input: GetTrustAnchorCommandInput;
+    constructor(input: GetTrustAnchorCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RolesAnywhereClientResolvedConfig, options?: __HttpHandlerOptions): Handler<GetTrustAnchorCommandInput, GetTrustAnchorCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ImportCrlCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { CrlDetailResponse, ImportCrlRequest } from "../models/models_0";
+import { RolesAnywhereClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RolesAnywhereClient";
+export interface ImportCrlCommandInput extends ImportCrlRequest {
+}
+export interface ImportCrlCommandOutput extends CrlDetailResponse, __MetadataBearer {
+}
+/**
+ * <p>Imports the certificate revocation list (CRL). CRl is a list of certificates that have been revoked by the issuing certificate Authority (CA). IAM Roles Anywhere validates against the crl list before issuing credentials. </p>
+ *          <p>
+ *             <b>Required permissions: </b>
+ *             <code>rolesanywhere:ImportCrl</code>.
+ *          </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RolesAnywhereClient, ImportCrlCommand } from "@aws-sdk/client-rolesanywhere"; // ES Modules import
+ * // const { RolesAnywhereClient, ImportCrlCommand } = require("@aws-sdk/client-rolesanywhere"); // CommonJS import
+ * const client = new RolesAnywhereClient(config);
+ * const command = new ImportCrlCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ImportCrlCommandInput} for command's `input` shape.
+ * @see {@link ImportCrlCommandOutput} for command's `response` shape.
+ * @see {@link RolesAnywhereClientResolvedConfig | config} for RolesAnywhereClient's `config` shape.
+ *
+ */
+export declare class ImportCrlCommand extends $Command<ImportCrlCommandInput, ImportCrlCommandOutput, RolesAnywhereClientResolvedConfig> {
+    readonly input: ImportCrlCommandInput;
+    constructor(input: ImportCrlCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RolesAnywhereClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ImportCrlCommandInput, ImportCrlCommandOutput>;
+    private serialize;
+    private deserialize;
+}

package/dist-types/commands/ListCrlsCommand.d.ts

@@ -0,0 +1,39 @@
+import { Command as $Command } from "@aws-sdk/smithy-client";
+import { Handler, HttpHandlerOptions as __HttpHandlerOptions, MetadataBearer as __MetadataBearer, MiddlewareStack } from "@aws-sdk/types";
+import { ListCrlsResponse, ListRequest } from "../models/models_0";
+import { RolesAnywhereClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../RolesAnywhereClient";
+export interface ListCrlsCommandInput extends ListRequest {
+}
+export interface ListCrlsCommandOutput extends ListCrlsResponse, __MetadataBearer {
+}
+/**
+ * <p>Lists all Crls in the authenticated account and Amazon Web Services Region.</p>
+ *          <p>
+ *             <b>Required permissions: </b>
+ *             <code>rolesanywhere:ListCrls</code>.
+ *          </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { RolesAnywhereClient, ListCrlsCommand } from "@aws-sdk/client-rolesanywhere"; // ES Modules import
+ * // const { RolesAnywhereClient, ListCrlsCommand } = require("@aws-sdk/client-rolesanywhere"); // CommonJS import
+ * const client = new RolesAnywhereClient(config);
+ * const command = new ListCrlsCommand(input);
+ * const response = await client.send(command);
+ * ```
+ *
+ * @see {@link ListCrlsCommandInput} for command's `input` shape.
+ * @see {@link ListCrlsCommandOutput} for command's `response` shape.
+ * @see {@link RolesAnywhereClientResolvedConfig | config} for RolesAnywhereClient's `config` shape.
+ *
+ */
+export declare class ListCrlsCommand extends $Command<ListCrlsCommandInput, ListCrlsCommandOutput, RolesAnywhereClientResolvedConfig> {
+    readonly input: ListCrlsCommandInput;
+    constructor(input: ListCrlsCommandInput);
+    /**
+     * @internal
+     */
+    resolveMiddleware(clientStack: MiddlewareStack<ServiceInputTypes, ServiceOutputTypes>, configuration: RolesAnywhereClientResolvedConfig, options?: __HttpHandlerOptions): Handler<ListCrlsCommandInput, ListCrlsCommandOutput>;
+    private serialize;
+    private deserialize;
+}