@rio-cloud/cdk-v2-constructs 9.0.0-alpha.2 → 9.0.0-alpha.4

package/node_modules/@aws-sdk/client-route-53/dist-types/commands/GetCheckerIpRangesCommand.d.ts

@@ -0,0 +1,83 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import type { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import type { GetCheckerIpRangesRequest, GetCheckerIpRangesResponse } from "../models/models_0";
+import type { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link GetCheckerIpRangesCommand}.
+ */
+export interface GetCheckerIpRangesCommandInput extends GetCheckerIpRangesRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link GetCheckerIpRangesCommand}.
+ */
+export interface GetCheckerIpRangesCommandOutput extends GetCheckerIpRangesResponse, __MetadataBearer {
+}
+declare const GetCheckerIpRangesCommand_base: {
+    new (input: GetCheckerIpRangesCommandInput): import("@smithy/smithy-client").CommandImpl<GetCheckerIpRangesCommandInput, GetCheckerIpRangesCommandOutput, Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (...[input]: [] | [GetCheckerIpRangesCommandInput]): import("@smithy/smithy-client").CommandImpl<GetCheckerIpRangesCommandInput, GetCheckerIpRangesCommandOutput, Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+/**
+ * <p>Route 53 does not perform authorization for this API because it retrieves information
+ * 			that is already available to the public.</p>
+ *          <important>
+ *             <p>
+ *                <code>GetCheckerIpRanges</code> still works, but we recommend that you download
+ * 				ip-ranges.json, which includes IP address ranges for all Amazon Web Services
+ * 				services. For more information, see <a href="https://docs.aws.amazon.com/Route53/latest/DeveloperGuide/route-53-ip-addresses.html">IP Address Ranges
+ * 					of Amazon Route 53 Servers</a> in the <i>Amazon Route 53 Developer
+ * 					Guide</i>.</p>
+ *          </important>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { Route53Client, GetCheckerIpRangesCommand } from "@aws-sdk/client-route-53"; // ES Modules import
+ * // const { Route53Client, GetCheckerIpRangesCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
+ * // import type { Route53ClientConfig } from "@aws-sdk/client-route-53";
+ * const config = {}; // type is Route53ClientConfig
+ * const client = new Route53Client(config);
+ * const input = {};
+ * const command = new GetCheckerIpRangesCommand(input);
+ * const response = await client.send(command);
+ * // { // GetCheckerIpRangesResponse
+ * //   CheckerIpRanges: [ // CheckerIpRanges // required
+ * //     "STRING_VALUE",
+ * //   ],
+ * // };
+ *
+ * ```
+ *
+ * @param GetCheckerIpRangesCommandInput - {@link GetCheckerIpRangesCommandInput}
+ * @returns {@link GetCheckerIpRangesCommandOutput}
+ * @see {@link GetCheckerIpRangesCommandInput} for command's `input` shape.
+ * @see {@link GetCheckerIpRangesCommandOutput} for command's `response` shape.
+ * @see {@link Route53ClientResolvedConfig | config} for Route53Client's `config` shape.
+ *
+ * @throws {@link Route53ServiceException}
+ * <p>Base exception class for all service exceptions from Route53 service.</p>
+ *
+ *
+ * @public
+ */
+export declare class GetCheckerIpRangesCommand extends GetCheckerIpRangesCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: {};
+            output: GetCheckerIpRangesResponse;
+        };
+        sdk: {
+            input: GetCheckerIpRangesCommandInput;
+            output: GetCheckerIpRangesCommandOutput;
+        };
+    };
+}

package/node_modules/@aws-sdk/client-route-53/dist-types/commands/GetDNSSECCommand.d.ts

@@ -0,0 +1,107 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import type { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import type { GetDNSSECRequest, GetDNSSECResponse } from "../models/models_0";
+import type { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link GetDNSSECCommand}.
+ */
+export interface GetDNSSECCommandInput extends GetDNSSECRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link GetDNSSECCommand}.
+ */
+export interface GetDNSSECCommandOutput extends GetDNSSECResponse, __MetadataBearer {
+}
+declare const GetDNSSECCommand_base: {
+    new (input: GetDNSSECCommandInput): import("@smithy/smithy-client").CommandImpl<GetDNSSECCommandInput, GetDNSSECCommandOutput, Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (input: GetDNSSECCommandInput): import("@smithy/smithy-client").CommandImpl<GetDNSSECCommandInput, GetDNSSECCommandOutput, Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+/**
+ * <p>Returns information about DNSSEC for a specific hosted zone, including the key-signing
+ * 			keys (KSKs) in the hosted zone.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { Route53Client, GetDNSSECCommand } from "@aws-sdk/client-route-53"; // ES Modules import
+ * // const { Route53Client, GetDNSSECCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
+ * // import type { Route53ClientConfig } from "@aws-sdk/client-route-53";
+ * const config = {}; // type is Route53ClientConfig
+ * const client = new Route53Client(config);
+ * const input = { // GetDNSSECRequest
+ *   HostedZoneId: "STRING_VALUE", // required
+ * };
+ * const command = new GetDNSSECCommand(input);
+ * const response = await client.send(command);
+ * // { // GetDNSSECResponse
+ * //   Status: { // DNSSECStatus
+ * //     ServeSignature: "STRING_VALUE",
+ * //     StatusMessage: "STRING_VALUE",
+ * //   },
+ * //   KeySigningKeys: [ // KeySigningKeys // required
+ * //     { // KeySigningKey
+ * //       Name: "STRING_VALUE",
+ * //       KmsArn: "STRING_VALUE",
+ * //       Flag: Number("int"),
+ * //       SigningAlgorithmMnemonic: "STRING_VALUE",
+ * //       SigningAlgorithmType: Number("int"),
+ * //       DigestAlgorithmMnemonic: "STRING_VALUE",
+ * //       DigestAlgorithmType: Number("int"),
+ * //       KeyTag: Number("int"),
+ * //       DigestValue: "STRING_VALUE",
+ * //       PublicKey: "STRING_VALUE",
+ * //       DSRecord: "STRING_VALUE",
+ * //       DNSKEYRecord: "STRING_VALUE",
+ * //       Status: "STRING_VALUE",
+ * //       StatusMessage: "STRING_VALUE",
+ * //       CreatedDate: new Date("TIMESTAMP"),
+ * //       LastModifiedDate: new Date("TIMESTAMP"),
+ * //     },
+ * //   ],
+ * // };
+ *
+ * ```
+ *
+ * @param GetDNSSECCommandInput - {@link GetDNSSECCommandInput}
+ * @returns {@link GetDNSSECCommandOutput}
+ * @see {@link GetDNSSECCommandInput} for command's `input` shape.
+ * @see {@link GetDNSSECCommandOutput} for command's `response` shape.
+ * @see {@link Route53ClientResolvedConfig | config} for Route53Client's `config` shape.
+ *
+ * @throws {@link InvalidArgument} (client fault)
+ *  <p>Parameter name is not valid.</p>
+ *
+ * @throws {@link InvalidInput} (client fault)
+ *  <p>The input is not valid.</p>
+ *
+ * @throws {@link NoSuchHostedZone} (client fault)
+ *  <p>No hosted zone exists with the ID that you specified.</p>
+ *
+ * @throws {@link Route53ServiceException}
+ * <p>Base exception class for all service exceptions from Route53 service.</p>
+ *
+ *
+ * @public
+ */
+export declare class GetDNSSECCommand extends GetDNSSECCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: GetDNSSECRequest;
+            output: GetDNSSECResponse;
+        };
+        sdk: {
+            input: GetDNSSECCommandInput;
+            output: GetDNSSECCommandOutput;
+        };
+    };
+}

package/node_modules/@aws-sdk/client-route-53/dist-types/commands/GetGeoLocationCommand.d.ts

@@ -0,0 +1,116 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import type { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import type { GetGeoLocationRequest, GetGeoLocationResponse } from "../models/models_0";
+import type { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link GetGeoLocationCommand}.
+ */
+export interface GetGeoLocationCommandInput extends GetGeoLocationRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link GetGeoLocationCommand}.
+ */
+export interface GetGeoLocationCommandOutput extends GetGeoLocationResponse, __MetadataBearer {
+}
+declare const GetGeoLocationCommand_base: {
+    new (input: GetGeoLocationCommandInput): import("@smithy/smithy-client").CommandImpl<GetGeoLocationCommandInput, GetGeoLocationCommandOutput, Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (...[input]: [] | [GetGeoLocationCommandInput]): import("@smithy/smithy-client").CommandImpl<GetGeoLocationCommandInput, GetGeoLocationCommandOutput, Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+/**
+ * <p>Gets information about whether a specified geographic location is supported for Amazon
+ * 			Route 53 geolocation resource record sets.</p>
+ *          <p>Route 53 does not perform authorization for this API because it retrieves information
+ * 			that is already available to the public.</p>
+ *          <p>Use the following syntax to determine whether a continent is supported for
+ * 			geolocation:</p>
+ *          <p>
+ *             <code>GET /2013-04-01/geolocation?continentcode=<i>two-letter abbreviation for
+ * 					a continent</i>
+ *             </code>
+ *          </p>
+ *          <p>Use the following syntax to determine whether a country is supported for
+ * 			geolocation:</p>
+ *          <p>
+ *             <code>GET /2013-04-01/geolocation?countrycode=<i>two-character country
+ * 					code</i>
+ *             </code>
+ *          </p>
+ *          <p>Use the following syntax to determine whether a subdivision of a country is supported
+ * 			for geolocation:</p>
+ *          <p>
+ *             <code>GET /2013-04-01/geolocation?countrycode=<i>two-character country
+ * 					code</i>&subdivisioncode=<i>subdivision
+ * 			code</i>
+ *             </code>
+ *          </p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { Route53Client, GetGeoLocationCommand } from "@aws-sdk/client-route-53"; // ES Modules import
+ * // const { Route53Client, GetGeoLocationCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
+ * // import type { Route53ClientConfig } from "@aws-sdk/client-route-53";
+ * const config = {}; // type is Route53ClientConfig
+ * const client = new Route53Client(config);
+ * const input = { // GetGeoLocationRequest
+ *   ContinentCode: "STRING_VALUE",
+ *   CountryCode: "STRING_VALUE",
+ *   SubdivisionCode: "STRING_VALUE",
+ * };
+ * const command = new GetGeoLocationCommand(input);
+ * const response = await client.send(command);
+ * // { // GetGeoLocationResponse
+ * //   GeoLocationDetails: { // GeoLocationDetails
+ * //     ContinentCode: "STRING_VALUE",
+ * //     ContinentName: "STRING_VALUE",
+ * //     CountryCode: "STRING_VALUE",
+ * //     CountryName: "STRING_VALUE",
+ * //     SubdivisionCode: "STRING_VALUE",
+ * //     SubdivisionName: "STRING_VALUE",
+ * //   },
+ * // };
+ *
+ * ```
+ *
+ * @param GetGeoLocationCommandInput - {@link GetGeoLocationCommandInput}
+ * @returns {@link GetGeoLocationCommandOutput}
+ * @see {@link GetGeoLocationCommandInput} for command's `input` shape.
+ * @see {@link GetGeoLocationCommandOutput} for command's `response` shape.
+ * @see {@link Route53ClientResolvedConfig | config} for Route53Client's `config` shape.
+ *
+ * @throws {@link InvalidInput} (client fault)
+ *  <p>The input is not valid.</p>
+ *
+ * @throws {@link NoSuchGeoLocation} (client fault)
+ *  <p>Amazon Route 53 doesn't support the specified geographic location. For a list of
+ * 			supported geolocation codes, see the <a href="https://docs.aws.amazon.com/Route53/latest/APIReference/API_GeoLocation.html">GeoLocation</a> data
+ * 			type.</p>
+ *
+ * @throws {@link Route53ServiceException}
+ * <p>Base exception class for all service exceptions from Route53 service.</p>
+ *
+ *
+ * @public
+ */
+export declare class GetGeoLocationCommand extends GetGeoLocationCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: GetGeoLocationRequest;
+            output: GetGeoLocationResponse;
+        };
+        sdk: {
+            input: GetGeoLocationCommandInput;
+            output: GetGeoLocationCommandOutput;
+        };
+    };
+}

package/node_modules/@aws-sdk/client-route-53/dist-types/commands/GetHealthCheckCommand.d.ts

@@ -0,0 +1,134 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import type { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import type { GetHealthCheckRequest, GetHealthCheckResponse } from "../models/models_0";
+import type { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link GetHealthCheckCommand}.
+ */
+export interface GetHealthCheckCommandInput extends GetHealthCheckRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link GetHealthCheckCommand}.
+ */
+export interface GetHealthCheckCommandOutput extends GetHealthCheckResponse, __MetadataBearer {
+}
+declare const GetHealthCheckCommand_base: {
+    new (input: GetHealthCheckCommandInput): import("@smithy/smithy-client").CommandImpl<GetHealthCheckCommandInput, GetHealthCheckCommandOutput, Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (input: GetHealthCheckCommandInput): import("@smithy/smithy-client").CommandImpl<GetHealthCheckCommandInput, GetHealthCheckCommandOutput, Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+/**
+ * <p>Gets information about a specified health check.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { Route53Client, GetHealthCheckCommand } from "@aws-sdk/client-route-53"; // ES Modules import
+ * // const { Route53Client, GetHealthCheckCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
+ * // import type { Route53ClientConfig } from "@aws-sdk/client-route-53";
+ * const config = {}; // type is Route53ClientConfig
+ * const client = new Route53Client(config);
+ * const input = { // GetHealthCheckRequest
+ *   HealthCheckId: "STRING_VALUE", // required
+ * };
+ * const command = new GetHealthCheckCommand(input);
+ * const response = await client.send(command);
+ * // { // GetHealthCheckResponse
+ * //   HealthCheck: { // HealthCheck
+ * //     Id: "STRING_VALUE", // required
+ * //     CallerReference: "STRING_VALUE", // required
+ * //     LinkedService: { // LinkedService
+ * //       ServicePrincipal: "STRING_VALUE",
+ * //       Description: "STRING_VALUE",
+ * //     },
+ * //     HealthCheckConfig: { // HealthCheckConfig
+ * //       IPAddress: "STRING_VALUE",
+ * //       Port: Number("int"),
+ * //       Type: "HTTP" || "HTTPS" || "HTTP_STR_MATCH" || "HTTPS_STR_MATCH" || "TCP" || "CALCULATED" || "CLOUDWATCH_METRIC" || "RECOVERY_CONTROL", // required
+ * //       ResourcePath: "STRING_VALUE",
+ * //       FullyQualifiedDomainName: "STRING_VALUE",
+ * //       SearchString: "STRING_VALUE",
+ * //       RequestInterval: Number("int"),
+ * //       FailureThreshold: Number("int"),
+ * //       MeasureLatency: true || false,
+ * //       Inverted: true || false,
+ * //       Disabled: true || false,
+ * //       HealthThreshold: Number("int"),
+ * //       ChildHealthChecks: [ // ChildHealthCheckList
+ * //         "STRING_VALUE",
+ * //       ],
+ * //       EnableSNI: true || false,
+ * //       Regions: [ // HealthCheckRegionList
+ * //         "us-east-1" || "us-west-1" || "us-west-2" || "eu-west-1" || "ap-southeast-1" || "ap-southeast-2" || "ap-northeast-1" || "sa-east-1",
+ * //       ],
+ * //       AlarmIdentifier: { // AlarmIdentifier
+ * //         Region: "us-east-1" || "us-east-2" || "us-west-1" || "us-west-2" || "ca-central-1" || "eu-central-1" || "eu-central-2" || "eu-west-1" || "eu-west-2" || "eu-west-3" || "ap-east-1" || "me-south-1" || "me-central-1" || "ap-south-1" || "ap-south-2" || "ap-southeast-1" || "ap-southeast-2" || "ap-southeast-3" || "ap-northeast-1" || "ap-northeast-2" || "ap-northeast-3" || "eu-north-1" || "sa-east-1" || "cn-northwest-1" || "cn-north-1" || "af-south-1" || "eu-south-1" || "eu-south-2" || "us-gov-west-1" || "us-gov-east-1" || "us-iso-east-1" || "us-iso-west-1" || "us-isob-east-1" || "ap-southeast-4" || "il-central-1" || "ca-west-1" || "ap-southeast-5" || "mx-central-1" || "us-isof-south-1" || "us-isof-east-1" || "ap-southeast-7" || "ap-east-2" || "eu-isoe-west-1" || "ap-southeast-6" || "us-isob-west-1" || "eusc-de-east-1", // required
+ * //         Name: "STRING_VALUE", // required
+ * //       },
+ * //       InsufficientDataHealthStatus: "Healthy" || "Unhealthy" || "LastKnownStatus",
+ * //       RoutingControlArn: "STRING_VALUE",
+ * //     },
+ * //     HealthCheckVersion: Number("long"), // required
+ * //     CloudWatchAlarmConfiguration: { // CloudWatchAlarmConfiguration
+ * //       EvaluationPeriods: Number("int"), // required
+ * //       Threshold: Number("double"), // required
+ * //       ComparisonOperator: "GreaterThanOrEqualToThreshold" || "GreaterThanThreshold" || "LessThanThreshold" || "LessThanOrEqualToThreshold", // required
+ * //       Period: Number("int"), // required
+ * //       MetricName: "STRING_VALUE", // required
+ * //       Namespace: "STRING_VALUE", // required
+ * //       Statistic: "Average" || "Sum" || "SampleCount" || "Maximum" || "Minimum", // required
+ * //       Dimensions: [ // DimensionList
+ * //         { // Dimension
+ * //           Name: "STRING_VALUE", // required
+ * //           Value: "STRING_VALUE", // required
+ * //         },
+ * //       ],
+ * //     },
+ * //   },
+ * // };
+ *
+ * ```
+ *
+ * @param GetHealthCheckCommandInput - {@link GetHealthCheckCommandInput}
+ * @returns {@link GetHealthCheckCommandOutput}
+ * @see {@link GetHealthCheckCommandInput} for command's `input` shape.
+ * @see {@link GetHealthCheckCommandOutput} for command's `response` shape.
+ * @see {@link Route53ClientResolvedConfig | config} for Route53Client's `config` shape.
+ *
+ * @throws {@link IncompatibleVersion} (client fault)
+ *  <p>The resource you're trying to access is unsupported on this Amazon Route 53
+ * 			endpoint.</p>
+ *
+ * @throws {@link InvalidInput} (client fault)
+ *  <p>The input is not valid.</p>
+ *
+ * @throws {@link NoSuchHealthCheck} (client fault)
+ *  <p>No health check exists with the specified ID.</p>
+ *
+ * @throws {@link Route53ServiceException}
+ * <p>Base exception class for all service exceptions from Route53 service.</p>
+ *
+ *
+ * @public
+ */
+export declare class GetHealthCheckCommand extends GetHealthCheckCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: GetHealthCheckRequest;
+            output: GetHealthCheckResponse;
+        };
+        sdk: {
+            input: GetHealthCheckCommandInput;
+            output: GetHealthCheckCommandOutput;
+        };
+    };
+}

package/node_modules/@aws-sdk/client-route-53/dist-types/commands/GetHealthCheckCountCommand.d.ts

@@ -0,0 +1,72 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import type { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import type { GetHealthCheckCountRequest, GetHealthCheckCountResponse } from "../models/models_0";
+import type { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link GetHealthCheckCountCommand}.
+ */
+export interface GetHealthCheckCountCommandInput extends GetHealthCheckCountRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link GetHealthCheckCountCommand}.
+ */
+export interface GetHealthCheckCountCommandOutput extends GetHealthCheckCountResponse, __MetadataBearer {
+}
+declare const GetHealthCheckCountCommand_base: {
+    new (input: GetHealthCheckCountCommandInput): import("@smithy/smithy-client").CommandImpl<GetHealthCheckCountCommandInput, GetHealthCheckCountCommandOutput, Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (...[input]: [] | [GetHealthCheckCountCommandInput]): import("@smithy/smithy-client").CommandImpl<GetHealthCheckCountCommandInput, GetHealthCheckCountCommandOutput, Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+/**
+ * <p>Retrieves the number of health checks that are associated with the current Amazon Web Services account.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { Route53Client, GetHealthCheckCountCommand } from "@aws-sdk/client-route-53"; // ES Modules import
+ * // const { Route53Client, GetHealthCheckCountCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
+ * // import type { Route53ClientConfig } from "@aws-sdk/client-route-53";
+ * const config = {}; // type is Route53ClientConfig
+ * const client = new Route53Client(config);
+ * const input = {};
+ * const command = new GetHealthCheckCountCommand(input);
+ * const response = await client.send(command);
+ * // { // GetHealthCheckCountResponse
+ * //   HealthCheckCount: Number("long"), // required
+ * // };
+ *
+ * ```
+ *
+ * @param GetHealthCheckCountCommandInput - {@link GetHealthCheckCountCommandInput}
+ * @returns {@link GetHealthCheckCountCommandOutput}
+ * @see {@link GetHealthCheckCountCommandInput} for command's `input` shape.
+ * @see {@link GetHealthCheckCountCommandOutput} for command's `response` shape.
+ * @see {@link Route53ClientResolvedConfig | config} for Route53Client's `config` shape.
+ *
+ * @throws {@link Route53ServiceException}
+ * <p>Base exception class for all service exceptions from Route53 service.</p>
+ *
+ *
+ * @public
+ */
+export declare class GetHealthCheckCountCommand extends GetHealthCheckCountCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: {};
+            output: GetHealthCheckCountResponse;
+        };
+        sdk: {
+            input: GetHealthCheckCountCommandInput;
+            output: GetHealthCheckCountCommandOutput;
+        };
+    };
+}

package/node_modules/@aws-sdk/client-route-53/dist-types/commands/GetHealthCheckLastFailureReasonCommand.d.ts

@@ -0,0 +1,89 @@
+import { Command as $Command } from "@smithy/smithy-client";
+import type { MetadataBearer as __MetadataBearer } from "@smithy/types";
+import type { GetHealthCheckLastFailureReasonRequest, GetHealthCheckLastFailureReasonResponse } from "../models/models_0";
+import type { Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes } from "../Route53Client";
+/**
+ * @public
+ */
+export type { __MetadataBearer };
+export { $Command };
+/**
+ * @public
+ *
+ * The input for {@link GetHealthCheckLastFailureReasonCommand}.
+ */
+export interface GetHealthCheckLastFailureReasonCommandInput extends GetHealthCheckLastFailureReasonRequest {
+}
+/**
+ * @public
+ *
+ * The output of {@link GetHealthCheckLastFailureReasonCommand}.
+ */
+export interface GetHealthCheckLastFailureReasonCommandOutput extends GetHealthCheckLastFailureReasonResponse, __MetadataBearer {
+}
+declare const GetHealthCheckLastFailureReasonCommand_base: {
+    new (input: GetHealthCheckLastFailureReasonCommandInput): import("@smithy/smithy-client").CommandImpl<GetHealthCheckLastFailureReasonCommandInput, GetHealthCheckLastFailureReasonCommandOutput, Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    new (input: GetHealthCheckLastFailureReasonCommandInput): import("@smithy/smithy-client").CommandImpl<GetHealthCheckLastFailureReasonCommandInput, GetHealthCheckLastFailureReasonCommandOutput, Route53ClientResolvedConfig, ServiceInputTypes, ServiceOutputTypes>;
+    getEndpointParameterInstructions(): import("@smithy/middleware-endpoint").EndpointParameterInstructions;
+};
+/**
+ * <p>Gets the reason that a specified health check failed most recently.</p>
+ * @example
+ * Use a bare-bones client and the command you need to make an API call.
+ * ```javascript
+ * import { Route53Client, GetHealthCheckLastFailureReasonCommand } from "@aws-sdk/client-route-53"; // ES Modules import
+ * // const { Route53Client, GetHealthCheckLastFailureReasonCommand } = require("@aws-sdk/client-route-53"); // CommonJS import
+ * // import type { Route53ClientConfig } from "@aws-sdk/client-route-53";
+ * const config = {}; // type is Route53ClientConfig
+ * const client = new Route53Client(config);
+ * const input = { // GetHealthCheckLastFailureReasonRequest
+ *   HealthCheckId: "STRING_VALUE", // required
+ * };
+ * const command = new GetHealthCheckLastFailureReasonCommand(input);
+ * const response = await client.send(command);
+ * // { // GetHealthCheckLastFailureReasonResponse
+ * //   HealthCheckObservations: [ // HealthCheckObservations // required
+ * //     { // HealthCheckObservation
+ * //       Region: "us-east-1" || "us-west-1" || "us-west-2" || "eu-west-1" || "ap-southeast-1" || "ap-southeast-2" || "ap-northeast-1" || "sa-east-1",
+ * //       IPAddress: "STRING_VALUE",
+ * //       StatusReport: { // StatusReport
+ * //         Status: "STRING_VALUE",
+ * //         CheckedTime: new Date("TIMESTAMP"),
+ * //       },
+ * //     },
+ * //   ],
+ * // };
+ *
+ * ```
+ *
+ * @param GetHealthCheckLastFailureReasonCommandInput - {@link GetHealthCheckLastFailureReasonCommandInput}
+ * @returns {@link GetHealthCheckLastFailureReasonCommandOutput}
+ * @see {@link GetHealthCheckLastFailureReasonCommandInput} for command's `input` shape.
+ * @see {@link GetHealthCheckLastFailureReasonCommandOutput} for command's `response` shape.
+ * @see {@link Route53ClientResolvedConfig | config} for Route53Client's `config` shape.
+ *
+ * @throws {@link InvalidInput} (client fault)
+ *  <p>The input is not valid.</p>
+ *
+ * @throws {@link NoSuchHealthCheck} (client fault)
+ *  <p>No health check exists with the specified ID.</p>
+ *
+ * @throws {@link Route53ServiceException}
+ * <p>Base exception class for all service exceptions from Route53 service.</p>
+ *
+ *
+ * @public
+ */
+export declare class GetHealthCheckLastFailureReasonCommand extends GetHealthCheckLastFailureReasonCommand_base {
+    /** @internal type navigation helper, not in runtime. */
+    protected static __types: {
+        api: {
+            input: GetHealthCheckLastFailureReasonRequest;
+            output: GetHealthCheckLastFailureReasonResponse;
+        };
+        sdk: {
+            input: GetHealthCheckLastFailureReasonCommandInput;
+            output: GetHealthCheckLastFailureReasonCommandOutput;
+        };
+    };
+}