@aws-sdk/client-rum 3.44.0

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

@@ -0,0 +1,824 @@
+import { LazyJsonString as __LazyJsonString } from "@aws-sdk/smithy-client";
+import { MetadataBearer as $MetadataBearer, SmithyException as __SmithyException } from "@aws-sdk/types";
+/**
+ * <p>You don't have sufficient permissions to perform this action.</p>
+ */
+export interface AccessDeniedException extends __SmithyException, $MetadataBearer {
+    name: "AccessDeniedException";
+    $fault: "client";
+    message: string | undefined;
+}
+export declare namespace AccessDeniedException {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: AccessDeniedException) => any;
+}
+export declare enum Telemetry {
+    /**
+     * Includes JS error event plugin
+     */
+    ERRORS = "errors",
+    /**
+     * Includes X-Ray Xhr and X-Ray Fetch plugin
+     */
+    HTTP = "http",
+    /**
+     * Includes navigation, paint, resource and web vital event plugins
+     */
+    PERFORMANCE = "performance"
+}
+/**
+ * <p>This structure contains much of the configuration data for the app monitor.</p>
+ */
+export interface AppMonitorConfiguration {
+    /**
+     * <p>The ID of the Amazon Cognito identity pool
+     *          that is used to authorize the sending of data to RUM.</p>
+     */
+    IdentityPoolId?: string;
+    /**
+     * <p>A list of URLs in your website or application to exclude from RUM data collection.</p>
+     *          <p>You can't include both <code>ExcludedPages</code> and <code>IncludedPages</code> in the same operation.</p>
+     */
+    ExcludedPages?: string[];
+    /**
+     * <p>If this app monitor is to collect data from only certain pages in your application, this structure lists those pages. </p>
+     *
+     *          <p>You can't include both <code>ExcludedPages</code> and <code>IncludedPages</code> in the same operation.</p>
+     */
+    IncludedPages?: string[];
+    /**
+     * <p>A list of pages in the CloudWatch RUM console that are to be displayed with a "favorite" icon.</p>
+     */
+    FavoritePages?: string[];
+    /**
+     * <p>Specifies the percentage of user sessions to use for RUM data collection. Choosing a higher percentage gives you
+     *       more data but also incurs more costs.</p>
+     *          <p>The number you specify is the percentage of user sessions that will be used.</p>
+     *          <p>If you omit this parameter, the default of 10 is used.</p>
+     */
+    SessionSampleRate?: number;
+    /**
+     * <p>The ARN of the guest IAM role that is attached to the Amazon Cognito identity pool
+     *       that is used to authorize the sending of data to RUM.</p>
+     */
+    GuestRoleArn?: string;
+    /**
+     * <p>If you set this to <code>true</code>, the RUM web client sets two cookies, a session
+     *          cookie and a user cookie. The cookies allow the RUM web client to collect data relating to
+     *          the number of users an application has and the behavior of the application across a
+     *          sequence of events. Cookies are stored in the top-level domain of the current page.</p>
+     */
+    AllowCookies?: boolean;
+    /**
+     * <p>An array that lists the types of telemetry data that this app monitor is to collect.</p>
+     *          <ul>
+     *             <li>
+     *                <p>
+     *                   <code>errors</code> indicates that RUM collects data about unhandled JavaScript errors raised
+     *          by your application.</p>
+     *             </li>
+     *             <li>
+     *                <p>
+     *                   <code>performance</code> indicates that RUM collects performance data about how your application
+     *             and its resources are loaded and rendered. This includes Core Web Vitals.</p>
+     *             </li>
+     *             <li>
+     *                <p>
+     *                   <code>http</code> indicates that RUM collects data about HTTP errors thrown by your application.</p>
+     *             </li>
+     *          </ul>
+     */
+    Telemetries?: (Telemetry | string)[];
+    /**
+     * <p>If you set this to <code>true</code>, RUM enables X-Ray tracing for
+     *          the user sessions that RUM samples. RUM adds an X-Ray trace header to allowed
+     *          HTTP requests. It also records an X-Ray segment for allowed HTTP requests.
+     *          You can see traces and segments from these user sessions in the X-Ray console
+     *          and the CloudWatch ServiceLens console. For more information, see <a href="https://docs.aws.amazon.com/xray/latest/devguide/aws-xray.html">What is X-Ray?</a>
+     *          </p>
+     */
+    EnableXRay?: boolean;
+}
+export declare namespace AppMonitorConfiguration {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: AppMonitorConfiguration) => any;
+}
+/**
+ * <p>A structure that contains the information about whether the app monitor stores copies of the data
+ *       that RUM collects in CloudWatch Logs. If it does, this structure also contains the name of the log group.</p>
+ */
+export interface CwLog {
+    /**
+     * <p>Indicated whether the app monitor stores copies of the data
+     *          that RUM collects in CloudWatch Logs.</p>
+     */
+    CwLogEnabled?: boolean;
+    /**
+     * <p>The name of the log group where the copies are stored.</p>
+     */
+    CwLogGroup?: string;
+}
+export declare namespace CwLog {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: CwLog) => any;
+}
+/**
+ * <p>A structure that contains information about whether this app monitor stores a copy of
+ *          the telemetry data that RUM collects using CloudWatch Logs.</p>
+ */
+export interface DataStorage {
+    /**
+     * <p>A structure that contains the information about whether the app monitor stores copies of the data
+     *          that RUM collects in CloudWatch Logs. If it does, this structure also contains the name of the log group.</p>
+     */
+    CwLog?: CwLog;
+}
+export declare namespace DataStorage {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: DataStorage) => any;
+}
+export declare enum StateEnum {
+    ACTIVE = "ACTIVE",
+    CREATED = "CREATED",
+    DELETING = "DELETING"
+}
+/**
+ * <p>A RUM app monitor collects telemetry data from your application and sends that
+ *          data to RUM. The data includes performance and reliability information such as page load time, client-side errors,
+ *          and user behavior.</p>
+ */
+export interface AppMonitor {
+    /**
+     * <p>The name of the app monitor.</p>
+     */
+    Name?: string;
+    /**
+     * <p>The top-level internet domain name for which your application has administrative authority.</p>
+     */
+    Domain?: string;
+    /**
+     * <p>The unique ID of this app monitor.</p>
+     */
+    Id?: string;
+    /**
+     * <p>The date and time that this app monitor was created.</p>
+     */
+    Created?: string;
+    /**
+     * <p>The date and time of the most recent changes to this app monitor's configuration.</p>
+     */
+    LastModified?: string;
+    /**
+     * <p>The list of tag keys and values associated with this app monitor.</p>
+     */
+    Tags?: {
+        [key: string]: string;
+    };
+    /**
+     * <p>The current state of the app monitor.</p>
+     */
+    State?: StateEnum | string;
+    /**
+     * <p>A structure that contains much of the configuration data for the app monitor.</p>
+     */
+    AppMonitorConfiguration?: AppMonitorConfiguration;
+    /**
+     * <p>A structure that contains information about whether this app monitor stores a copy of
+     *          the telemetry data that RUM collects using CloudWatch Logs.</p>
+     */
+    DataStorage?: DataStorage;
+}
+export declare namespace AppMonitor {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: AppMonitor) => any;
+}
+/**
+ * <p>A structure that contains information about the RUM app monitor.</p>
+ */
+export interface AppMonitorDetails {
+    /**
+     * <p>The name of the app monitor.</p>
+     */
+    name?: string;
+    /**
+     * <p>The unique ID of the app monitor.</p>
+     */
+    id?: string;
+    /**
+     * <p>The version of the app monitor.</p>
+     */
+    version?: string;
+}
+export declare namespace AppMonitorDetails {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: AppMonitorDetails) => any;
+}
+/**
+ * <p>This operation attempted to create a resource that already exists.</p>
+ */
+export interface ConflictException extends __SmithyException, $MetadataBearer {
+    name: "ConflictException";
+    $fault: "client";
+    message: string | undefined;
+    /**
+     * <p>The name of the resource that is associated with the error.</p>
+     */
+    resourceName: string | undefined;
+    /**
+     * <p>The type of the resource that is associated with the error.</p>
+     */
+    resourceType?: string;
+}
+export declare namespace ConflictException {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ConflictException) => any;
+}
+export interface CreateAppMonitorRequest {
+    /**
+     * <p>A name for the app monitor.</p>
+     */
+    Name: string | undefined;
+    /**
+     * <p>The top-level internet domain name for which your application has administrative authority.</p>
+     */
+    Domain: string | undefined;
+    /**
+     * <p>Assigns one or more tags (key-value pairs) to the app monitor.</p>
+     *          <p>Tags can help you organize and categorize your resources. You can also use them to scope user
+     *          permissions by granting a user
+     *          permission to access or change only resources with certain tag values.</p>
+     *          <p>Tags don't have any semantic meaning to Amazon Web Services and are interpreted strictly as strings of characters.</p>
+     *
+     *          <p>You can associate as many as 50 tags with an app monitor.</p>
+     *          <p>For more information, see <a href="https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html">Tagging Amazon Web Services resources</a>.</p>
+     */
+    Tags?: {
+        [key: string]: string;
+    };
+    /**
+     * <p>A structure that contains much of the configuration data for the app monitor. If you are using
+     *          Amazon Cognito for authorization, you must include this structure in your request, and it must include the ID of the
+     *          Amazon Cognito identity pool to use for authorization. If you don't include <code>AppMonitorConfiguration</code>, you must set up your own
+     *          authorization method. For more information, see
+     *          <a href="https://docs.aws.amazon.com/monitoring/CloudWatch-RUM-get-started-authorization.html">Authorize your application
+     *             to send data to Amazon Web Services</a>.</p>
+     *          <p>If you omit this argument, the sample rate used for RUM is set to 10% of the user sessions.</p>
+     */
+    AppMonitorConfiguration?: AppMonitorConfiguration;
+    /**
+     * <p>Data collected by RUM is kept by RUM for 30 days and then deleted. This parameter specifies whether RUM
+     *          sends a copy of this telemetry data to Amazon CloudWatch Logs
+     *          in your account. This enables you to keep the telemetry data for more than 30 days, but it does incur
+     *          Amazon CloudWatch Logs charges.</p>
+     *          <p>If you omit this parameter, the default is <code>false</code>.</p>
+     */
+    CwLogEnabled?: boolean;
+}
+export declare namespace CreateAppMonitorRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: CreateAppMonitorRequest) => any;
+}
+export interface CreateAppMonitorResponse {
+    /**
+     * <p>The unique ID of the new app monitor.</p>
+     */
+    Id?: string;
+}
+export declare namespace CreateAppMonitorResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: CreateAppMonitorResponse) => any;
+}
+/**
+ * <p>Internal service exception.</p>
+ */
+export interface InternalServerException extends __SmithyException, $MetadataBearer {
+    name: "InternalServerException";
+    $fault: "server";
+    $retryable: {};
+    message: string | undefined;
+    /**
+     * <p>The value of a parameter in the request caused an error.</p>
+     */
+    retryAfterSeconds?: number;
+}
+export declare namespace InternalServerException {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: InternalServerException) => any;
+}
+/**
+ * <p>This request exceeds a service quota.</p>
+ */
+export interface ServiceQuotaExceededException extends __SmithyException, $MetadataBearer {
+    name: "ServiceQuotaExceededException";
+    $fault: "client";
+    message: string | undefined;
+}
+export declare namespace ServiceQuotaExceededException {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ServiceQuotaExceededException) => any;
+}
+/**
+ * <p>The request was throttled because of quota limits.</p>
+ */
+export interface ThrottlingException extends __SmithyException, $MetadataBearer {
+    name: "ThrottlingException";
+    $fault: "client";
+    $retryable: {
+        throttling: true;
+    };
+    message: string | undefined;
+    /**
+     * <p>The ID of the service that is associated with the error.</p>
+     */
+    serviceCode?: string;
+    /**
+     * <p>The ID of the service quota that was exceeded.</p>
+     */
+    quotaCode?: string;
+    /**
+     * <p>The value of a parameter in the request caused an error.</p>
+     */
+    retryAfterSeconds?: number;
+}
+export declare namespace ThrottlingException {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ThrottlingException) => any;
+}
+/**
+ * <p>One of the arguments for the request is not valid.</p>
+ */
+export interface ValidationException extends __SmithyException, $MetadataBearer {
+    name: "ValidationException";
+    $fault: "client";
+    message: string | undefined;
+}
+export declare namespace ValidationException {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ValidationException) => any;
+}
+export interface DeleteAppMonitorRequest {
+    /**
+     * <p>The name of the app monitor to delete.</p>
+     */
+    Name: string | undefined;
+}
+export declare namespace DeleteAppMonitorRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: DeleteAppMonitorRequest) => any;
+}
+export interface DeleteAppMonitorResponse {
+}
+export declare namespace DeleteAppMonitorResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: DeleteAppMonitorResponse) => any;
+}
+/**
+ * <p>Resource not found.</p>
+ */
+export interface ResourceNotFoundException extends __SmithyException, $MetadataBearer {
+    name: "ResourceNotFoundException";
+    $fault: "client";
+    message: string | undefined;
+    /**
+     * <p>The name of the resource that is associated with the error.</p>
+     */
+    resourceName: string | undefined;
+    /**
+     * <p>The type of the resource that is associated with the error.</p>
+     */
+    resourceType?: string;
+}
+export declare namespace ResourceNotFoundException {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ResourceNotFoundException) => any;
+}
+export interface GetAppMonitorRequest {
+    /**
+     * <p>The app monitor to retrieve information for.</p>
+     */
+    Name: string | undefined;
+}
+export declare namespace GetAppMonitorRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: GetAppMonitorRequest) => any;
+}
+export interface GetAppMonitorResponse {
+    /**
+     * <p>A structure containing all the configuration information for the app monitor.</p>
+     */
+    AppMonitor?: AppMonitor;
+}
+export declare namespace GetAppMonitorResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: GetAppMonitorResponse) => any;
+}
+/**
+ * <p>A structure that defines a key and values that you can use to filter the results. The
+ *          only performance events that are returned are those that have values matching the ones that
+ *          you specify in one of your <code>QueryFilter</code> structures.</p>
+ *          <p>For example, you could specify <code>Browser</code> as the <code>Name</code>
+ *       and specify <code>Chrome,Firefox</code> as the <code>Values</code> to return
+ *       events generated only from those browsers.</p>
+ *          <p>Specifying <code>Invert</code> as the <code>Name</code>
+ *          works as a "not equal to" filter. For example, specify <code>Invert</code> as the <code>Name</code>
+ *          and specify <code>Chrome</code> as the value to return all events except events from
+ *          user sessions with the Chrome browser.</p>
+ */
+export interface QueryFilter {
+    /**
+     * <p>The name of a key to search for.
+     *       The filter returns only the events that match the <code>Name</code>
+     *          and <code>Values</code> that you specify.
+     *       </p>
+     *          <p>Valid values for <code>Name</code> are <code>Browser</code> | <code>Device</code> | <code>Country</code> |
+     *          <code>Page</code> | <code>OS</code> | <code>EventType</code> | <code>Invert</code>
+     *          </p>
+     */
+    Name?: string;
+    /**
+     * <p>The values of the <code>Name</code> that are to be be included in the returned results.</p>
+     */
+    Values?: string[];
+}
+export declare namespace QueryFilter {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: QueryFilter) => any;
+}
+/**
+ * <p>A structure that defines the time range that you want to retrieve results from.</p>
+ */
+export interface TimeRange {
+    /**
+     * <p>The beginning of the time range to retrieve performance events from.</p>
+     */
+    After: number | undefined;
+    /**
+     * <p>The end of the time range to retrieve performance events from. If you omit this, the time
+     *       range extends to the time that this operation is performed.</p>
+     */
+    Before?: number;
+}
+export declare namespace TimeRange {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: TimeRange) => any;
+}
+export interface GetAppMonitorDataRequest {
+    /**
+     * <p>The name of the app monitor that collected the data that you want to retrieve.</p>
+     */
+    Name: string | undefined;
+    /**
+     * <p>A structure that defines the time range that you want to retrieve results from.</p>
+     */
+    TimeRange: TimeRange | undefined;
+    /**
+     * <p>An array of structures that you can use to filter the results to those that match one or
+     *          more sets of key-value pairs that you specify.</p>
+     */
+    Filters?: QueryFilter[];
+    /**
+     * <p>The maximum number of results to return in one operation. </p>
+     */
+    MaxResults?: number;
+    /**
+     * <p>Use the token returned by the previous operation to request the next page of results.</p>
+     */
+    NextToken?: string;
+}
+export declare namespace GetAppMonitorDataRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: GetAppMonitorDataRequest) => any;
+}
+export interface GetAppMonitorDataResponse {
+    /**
+     * <p>The events that RUM collected that match your request.</p>
+     */
+    Events?: string[];
+    /**
+     * <p>A token that you can use in a subsequent operation to retrieve the next set of
+     *          results.</p>
+     */
+    NextToken?: string;
+}
+export declare namespace GetAppMonitorDataResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: GetAppMonitorDataResponse) => any;
+}
+export interface ListAppMonitorsRequest {
+    /**
+     * <p>The maximum number of results to return in one operation. </p>
+     */
+    MaxResults?: number;
+    /**
+     * <p>Use the token returned by the previous operation to request the next page of results.</p>
+     */
+    NextToken?: string;
+}
+export declare namespace ListAppMonitorsRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ListAppMonitorsRequest) => any;
+}
+/**
+ * <p>A structure that includes some data about app monitors and their settings.</p>
+ */
+export interface AppMonitorSummary {
+    /**
+     * <p>The name of this app monitor.</p>
+     */
+    Name?: string;
+    /**
+     * <p>The unique ID of this app monitor.</p>
+     */
+    Id?: string;
+    /**
+     * <p>The date and time that the app monitor was created.</p>
+     */
+    Created?: string;
+    /**
+     * <p>The date and time of the most recent changes to this app monitor's configuration.</p>
+     */
+    LastModified?: string;
+    /**
+     * <p>The current state of this app monitor.</p>
+     */
+    State?: StateEnum | string;
+}
+export declare namespace AppMonitorSummary {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: AppMonitorSummary) => any;
+}
+export interface ListAppMonitorsResponse {
+    /**
+     * <p>A token that you can use in a subsequent operation to retrieve the next set of
+     *          results.</p>
+     */
+    NextToken?: string;
+    /**
+     * <p>An array of structures that contain information about the returned app monitors.</p>
+     */
+    AppMonitorSummaries?: AppMonitorSummary[];
+}
+export declare namespace ListAppMonitorsResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ListAppMonitorsResponse) => any;
+}
+export interface UpdateAppMonitorRequest {
+    /**
+     * <p>The name of the app monitor to update.</p>
+     */
+    Name: string | undefined;
+    /**
+     * <p>The top-level internet domain name for which your application has administrative authority.</p>
+     */
+    Domain?: string;
+    /**
+     * <p>A structure that contains much of the configuration data for the app monitor. If you are using
+     *          Amazon Cognito for authorization, you must include this structure in your request, and it must include the ID of the
+     *          Amazon Cognito identity pool to use for authorization. If you don't include <code>AppMonitorConfiguration</code>, you must set up your own
+     *          authorization method. For more information, see
+     *          <a href="https://docs.aws.amazon.com/monitoring/CloudWatch-RUM-get-started-authorization.html">Authorize your application
+     *             to send data to Amazon Web Services</a>.</p>
+     */
+    AppMonitorConfiguration?: AppMonitorConfiguration;
+    /**
+     * <p>Data collected by RUM is kept by RUM for 30 days and then deleted. This parameter specifies whether RUM
+     *          sends a copy of this telemetry data to Amazon CloudWatch Logs
+     *          in your account. This enables you to keep the telemetry data for more than 30 days, but it does incur
+     *          Amazon CloudWatch Logs charges.</p>
+     */
+    CwLogEnabled?: boolean;
+}
+export declare namespace UpdateAppMonitorRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateAppMonitorRequest) => any;
+}
+export interface UpdateAppMonitorResponse {
+}
+export declare namespace UpdateAppMonitorResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UpdateAppMonitorResponse) => any;
+}
+export interface ListTagsForResourceRequest {
+    /**
+     * <p>The ARN of the resource that you want to see the tags of.</p>
+     */
+    ResourceArn: string | undefined;
+}
+export declare namespace ListTagsForResourceRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ListTagsForResourceRequest) => any;
+}
+export interface ListTagsForResourceResponse {
+    /**
+     * <p>The ARN of the resource that you are viewing.</p>
+     */
+    ResourceArn: string | undefined;
+    /**
+     * <p>The list of tag keys and values associated with the resource you specified.</p>
+     */
+    Tags: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace ListTagsForResourceResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: ListTagsForResourceResponse) => any;
+}
+/**
+ * <p>A structure that contains the information for one performance event that RUM collects from a user session with your
+ *       application.</p>
+ */
+export interface RumEvent {
+    /**
+     * <p>A unique ID for this event.</p>
+     */
+    id: string | undefined;
+    /**
+     * <p>The exact time that this event occurred.</p>
+     */
+    timestamp: Date | undefined;
+    /**
+     * <p>The JSON schema that denotes the type of event this is, such as a page load or a new session.</p>
+     */
+    type: string | undefined;
+    /**
+     * <p>Metadata about this event, which contains a JSON serialization of the identity of the user for
+     *          this session. The user information comes from information such as the HTTP user-agent request header
+     *          and document interface.</p>
+     */
+    metadata?: __LazyJsonString | string;
+    /**
+     * <p>A string containing details about the event.</p>
+     */
+    details: __LazyJsonString | string | undefined;
+}
+export declare namespace RumEvent {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: RumEvent) => any;
+}
+/**
+ * <p>A structure that contains information about the user session that this batch of events was collected from.</p>
+ */
+export interface UserDetails {
+    /**
+     * <p>The ID of the user for this user session. This ID is generated by RUM and does not include any
+     *       personally identifiable information about the user.</p>
+     */
+    userId?: string;
+    /**
+     * <p>The session ID that the performance events are from.</p>
+     */
+    sessionId?: string;
+}
+export declare namespace UserDetails {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UserDetails) => any;
+}
+export interface PutRumEventsRequest {
+    /**
+     * <p>The ID of the app monitor that is sending this data.</p>
+     */
+    Id: string | undefined;
+    /**
+     * <p>A unique identifier for this batch of RUM event data.</p>
+     */
+    BatchId: string | undefined;
+    /**
+     * <p>A structure that contains information about the app monitor that collected this telemetry information.</p>
+     */
+    AppMonitorDetails: AppMonitorDetails | undefined;
+    /**
+     * <p>A structure that contains information about the user session that this batch of events was collected from.</p>
+     */
+    UserDetails: UserDetails | undefined;
+    /**
+     * <p>An array of structures that contain the telemetry event data.</p>
+     */
+    RumEvents: RumEvent[] | undefined;
+}
+export declare namespace PutRumEventsRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: PutRumEventsRequest) => any;
+}
+export interface PutRumEventsResponse {
+}
+export declare namespace PutRumEventsResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: PutRumEventsResponse) => any;
+}
+export interface TagResourceRequest {
+    /**
+     * <p>The ARN of the CloudWatch RUM resource that you're adding tags to.</p>
+     */
+    ResourceArn: string | undefined;
+    /**
+     * <p>The list of key-value pairs to associate with the resource.</p>
+     */
+    Tags: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace TagResourceRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: TagResourceRequest) => any;
+}
+export interface TagResourceResponse {
+}
+export declare namespace TagResourceResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: TagResourceResponse) => any;
+}
+export interface UntagResourceRequest {
+    /**
+     * <p>The ARN of the CloudWatch RUM resource that you're removing tags from.</p>
+     */
+    ResourceArn: string | undefined;
+    /**
+     * <p>The list of tag keys to remove from the resource.</p>
+     */
+    TagKeys: string[] | undefined;
+}
+export declare namespace UntagResourceRequest {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UntagResourceRequest) => any;
+}
+export interface UntagResourceResponse {
+}
+export declare namespace UntagResourceResponse {
+    /**
+     * @internal
+     */
+    const filterSensitiveLog: (obj: UntagResourceResponse) => any;
+}