@aws-sdk/client-cloudwatch-logs 3.50.0 → 3.53.0

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

@@ -0,0 +1,1222 @@
+import { ExceptionOptionType as __ExceptionOptionType } from "@aws-sdk/smithy-client";
+import { CloudWatchLogsServiceException as __BaseException } from "./CloudWatchLogsServiceException";
+export interface AssociateKmsKeyRequest {
+    
+    logGroupName: string | undefined;
+    
+    kmsKeyId: string | undefined;
+}
+export declare namespace AssociateKmsKeyRequest {
+    
+    const filterSensitiveLog: (obj: AssociateKmsKeyRequest) => any;
+}
+
+export declare class InvalidParameterException extends __BaseException {
+    readonly name: "InvalidParameterException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidParameterException, __BaseException>);
+}
+
+export declare class OperationAbortedException extends __BaseException {
+    readonly name: "OperationAbortedException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<OperationAbortedException, __BaseException>);
+}
+
+export declare class ResourceNotFoundException extends __BaseException {
+    readonly name: "ResourceNotFoundException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ResourceNotFoundException, __BaseException>);
+}
+
+export declare class ServiceUnavailableException extends __BaseException {
+    readonly name: "ServiceUnavailableException";
+    readonly $fault: "server";
+    
+    constructor(opts: __ExceptionOptionType<ServiceUnavailableException, __BaseException>);
+}
+export interface CancelExportTaskRequest {
+    
+    taskId: string | undefined;
+}
+export declare namespace CancelExportTaskRequest {
+    
+    const filterSensitiveLog: (obj: CancelExportTaskRequest) => any;
+}
+
+export declare class InvalidOperationException extends __BaseException {
+    readonly name: "InvalidOperationException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<InvalidOperationException, __BaseException>);
+}
+export interface CreateExportTaskRequest {
+    
+    taskName?: string;
+    
+    logGroupName: string | undefined;
+    
+    logStreamNamePrefix?: string;
+    
+    from: number | undefined;
+    
+    to: number | undefined;
+    
+    destination: string | undefined;
+    
+    destinationPrefix?: string;
+}
+export declare namespace CreateExportTaskRequest {
+    
+    const filterSensitiveLog: (obj: CreateExportTaskRequest) => any;
+}
+export interface CreateExportTaskResponse {
+    
+    taskId?: string;
+}
+export declare namespace CreateExportTaskResponse {
+    
+    const filterSensitiveLog: (obj: CreateExportTaskResponse) => any;
+}
+
+export declare class LimitExceededException extends __BaseException {
+    readonly name: "LimitExceededException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<LimitExceededException, __BaseException>);
+}
+
+export declare class ResourceAlreadyExistsException extends __BaseException {
+    readonly name: "ResourceAlreadyExistsException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<ResourceAlreadyExistsException, __BaseException>);
+}
+export interface CreateLogGroupRequest {
+    
+    logGroupName: string | undefined;
+    
+    kmsKeyId?: string;
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace CreateLogGroupRequest {
+    
+    const filterSensitiveLog: (obj: CreateLogGroupRequest) => any;
+}
+export interface CreateLogStreamRequest {
+    
+    logGroupName: string | undefined;
+    
+    logStreamName: string | undefined;
+}
+export declare namespace CreateLogStreamRequest {
+    
+    const filterSensitiveLog: (obj: CreateLogStreamRequest) => any;
+}
+
+export declare class DataAlreadyAcceptedException extends __BaseException {
+    readonly name: "DataAlreadyAcceptedException";
+    readonly $fault: "client";
+    expectedSequenceToken?: string;
+    
+    constructor(opts: __ExceptionOptionType<DataAlreadyAcceptedException, __BaseException>);
+}
+export interface DeleteDestinationRequest {
+    
+    destinationName: string | undefined;
+}
+export declare namespace DeleteDestinationRequest {
+    
+    const filterSensitiveLog: (obj: DeleteDestinationRequest) => any;
+}
+export interface DeleteLogGroupRequest {
+    
+    logGroupName: string | undefined;
+}
+export declare namespace DeleteLogGroupRequest {
+    
+    const filterSensitiveLog: (obj: DeleteLogGroupRequest) => any;
+}
+export interface DeleteLogStreamRequest {
+    
+    logGroupName: string | undefined;
+    
+    logStreamName: string | undefined;
+}
+export declare namespace DeleteLogStreamRequest {
+    
+    const filterSensitiveLog: (obj: DeleteLogStreamRequest) => any;
+}
+export interface DeleteMetricFilterRequest {
+    
+    logGroupName: string | undefined;
+    
+    filterName: string | undefined;
+}
+export declare namespace DeleteMetricFilterRequest {
+    
+    const filterSensitiveLog: (obj: DeleteMetricFilterRequest) => any;
+}
+export interface DeleteQueryDefinitionRequest {
+    
+    queryDefinitionId: string | undefined;
+}
+export declare namespace DeleteQueryDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: DeleteQueryDefinitionRequest) => any;
+}
+export interface DeleteQueryDefinitionResponse {
+    
+    success?: boolean;
+}
+export declare namespace DeleteQueryDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: DeleteQueryDefinitionResponse) => any;
+}
+export interface DeleteResourcePolicyRequest {
+    
+    policyName?: string;
+}
+export declare namespace DeleteResourcePolicyRequest {
+    
+    const filterSensitiveLog: (obj: DeleteResourcePolicyRequest) => any;
+}
+export interface DeleteRetentionPolicyRequest {
+    
+    logGroupName: string | undefined;
+}
+export declare namespace DeleteRetentionPolicyRequest {
+    
+    const filterSensitiveLog: (obj: DeleteRetentionPolicyRequest) => any;
+}
+export interface DeleteSubscriptionFilterRequest {
+    
+    logGroupName: string | undefined;
+    
+    filterName: string | undefined;
+}
+export declare namespace DeleteSubscriptionFilterRequest {
+    
+    const filterSensitiveLog: (obj: DeleteSubscriptionFilterRequest) => any;
+}
+export interface DescribeDestinationsRequest {
+    
+    DestinationNamePrefix?: string;
+    
+    nextToken?: string;
+    
+    limit?: number;
+}
+export declare namespace DescribeDestinationsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeDestinationsRequest) => any;
+}
+
+export interface Destination {
+    
+    destinationName?: string;
+    
+    targetArn?: string;
+    
+    roleArn?: string;
+    
+    accessPolicy?: string;
+    
+    arn?: string;
+    
+    creationTime?: number;
+}
+export declare namespace Destination {
+    
+    const filterSensitiveLog: (obj: Destination) => any;
+}
+export interface DescribeDestinationsResponse {
+    
+    destinations?: Destination[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeDestinationsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeDestinationsResponse) => any;
+}
+export declare enum ExportTaskStatusCode {
+    CANCELLED = "CANCELLED",
+    COMPLETED = "COMPLETED",
+    FAILED = "FAILED",
+    PENDING = "PENDING",
+    PENDING_CANCEL = "PENDING_CANCEL",
+    RUNNING = "RUNNING"
+}
+export interface DescribeExportTasksRequest {
+    
+    taskId?: string;
+    
+    statusCode?: ExportTaskStatusCode | string;
+    
+    nextToken?: string;
+    
+    limit?: number;
+}
+export declare namespace DescribeExportTasksRequest {
+    
+    const filterSensitiveLog: (obj: DescribeExportTasksRequest) => any;
+}
+
+export interface ExportTaskExecutionInfo {
+    
+    creationTime?: number;
+    
+    completionTime?: number;
+}
+export declare namespace ExportTaskExecutionInfo {
+    
+    const filterSensitiveLog: (obj: ExportTaskExecutionInfo) => any;
+}
+
+export interface ExportTaskStatus {
+    
+    code?: ExportTaskStatusCode | string;
+    
+    message?: string;
+}
+export declare namespace ExportTaskStatus {
+    
+    const filterSensitiveLog: (obj: ExportTaskStatus) => any;
+}
+
+export interface ExportTask {
+    
+    taskId?: string;
+    
+    taskName?: string;
+    
+    logGroupName?: string;
+    
+    from?: number;
+    
+    to?: number;
+    
+    destination?: string;
+    
+    destinationPrefix?: string;
+    
+    status?: ExportTaskStatus;
+    
+    executionInfo?: ExportTaskExecutionInfo;
+}
+export declare namespace ExportTask {
+    
+    const filterSensitiveLog: (obj: ExportTask) => any;
+}
+export interface DescribeExportTasksResponse {
+    
+    exportTasks?: ExportTask[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeExportTasksResponse {
+    
+    const filterSensitiveLog: (obj: DescribeExportTasksResponse) => any;
+}
+export interface DescribeLogGroupsRequest {
+    
+    logGroupNamePrefix?: string;
+    
+    nextToken?: string;
+    
+    limit?: number;
+}
+export declare namespace DescribeLogGroupsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeLogGroupsRequest) => any;
+}
+
+export interface LogGroup {
+    
+    logGroupName?: string;
+    
+    creationTime?: number;
+    
+    retentionInDays?: number;
+    
+    metricFilterCount?: number;
+    
+    arn?: string;
+    
+    storedBytes?: number;
+    
+    kmsKeyId?: string;
+}
+export declare namespace LogGroup {
+    
+    const filterSensitiveLog: (obj: LogGroup) => any;
+}
+export interface DescribeLogGroupsResponse {
+    
+    logGroups?: LogGroup[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeLogGroupsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeLogGroupsResponse) => any;
+}
+export declare enum OrderBy {
+    LastEventTime = "LastEventTime",
+    LogStreamName = "LogStreamName"
+}
+export interface DescribeLogStreamsRequest {
+    
+    logGroupName: string | undefined;
+    
+    logStreamNamePrefix?: string;
+    
+    orderBy?: OrderBy | string;
+    
+    descending?: boolean;
+    
+    nextToken?: string;
+    
+    limit?: number;
+}
+export declare namespace DescribeLogStreamsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeLogStreamsRequest) => any;
+}
+
+export interface LogStream {
+    
+    logStreamName?: string;
+    
+    creationTime?: number;
+    
+    firstEventTimestamp?: number;
+    
+    lastEventTimestamp?: number;
+    
+    lastIngestionTime?: number;
+    
+    uploadSequenceToken?: string;
+    
+    arn?: string;
+    
+    storedBytes?: number;
+}
+export declare namespace LogStream {
+    
+    const filterSensitiveLog: (obj: LogStream) => any;
+}
+export interface DescribeLogStreamsResponse {
+    
+    logStreams?: LogStream[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeLogStreamsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeLogStreamsResponse) => any;
+}
+export interface DescribeMetricFiltersRequest {
+    
+    logGroupName?: string;
+    
+    filterNamePrefix?: string;
+    
+    nextToken?: string;
+    
+    limit?: number;
+    
+    metricName?: string;
+    
+    metricNamespace?: string;
+}
+export declare namespace DescribeMetricFiltersRequest {
+    
+    const filterSensitiveLog: (obj: DescribeMetricFiltersRequest) => any;
+}
+export declare enum StandardUnit {
+    Bits = "Bits",
+    BitsSecond = "Bits/Second",
+    Bytes = "Bytes",
+    BytesSecond = "Bytes/Second",
+    Count = "Count",
+    CountSecond = "Count/Second",
+    Gigabits = "Gigabits",
+    GigabitsSecond = "Gigabits/Second",
+    Gigabytes = "Gigabytes",
+    GigabytesSecond = "Gigabytes/Second",
+    Kilobits = "Kilobits",
+    KilobitsSecond = "Kilobits/Second",
+    Kilobytes = "Kilobytes",
+    KilobytesSecond = "Kilobytes/Second",
+    Megabits = "Megabits",
+    MegabitsSecond = "Megabits/Second",
+    Megabytes = "Megabytes",
+    MegabytesSecond = "Megabytes/Second",
+    Microseconds = "Microseconds",
+    Milliseconds = "Milliseconds",
+    None = "None",
+    Percent = "Percent",
+    Seconds = "Seconds",
+    Terabits = "Terabits",
+    TerabitsSecond = "Terabits/Second",
+    Terabytes = "Terabytes",
+    TerabytesSecond = "Terabytes/Second"
+}
+
+export interface MetricTransformation {
+    
+    metricName: string | undefined;
+    
+    metricNamespace: string | undefined;
+    
+    metricValue: string | undefined;
+    
+    defaultValue?: number;
+    
+    dimensions?: {
+        [key: string]: string;
+    };
+    
+    unit?: StandardUnit | string;
+}
+export declare namespace MetricTransformation {
+    
+    const filterSensitiveLog: (obj: MetricTransformation) => any;
+}
+
+export interface MetricFilter {
+    
+    filterName?: string;
+    
+    filterPattern?: string;
+    
+    metricTransformations?: MetricTransformation[];
+    
+    creationTime?: number;
+    
+    logGroupName?: string;
+}
+export declare namespace MetricFilter {
+    
+    const filterSensitiveLog: (obj: MetricFilter) => any;
+}
+export interface DescribeMetricFiltersResponse {
+    
+    metricFilters?: MetricFilter[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeMetricFiltersResponse {
+    
+    const filterSensitiveLog: (obj: DescribeMetricFiltersResponse) => any;
+}
+export declare enum QueryStatus {
+    Cancelled = "Cancelled",
+    Complete = "Complete",
+    Failed = "Failed",
+    Running = "Running",
+    Scheduled = "Scheduled",
+    Timeout = "Timeout",
+    Unknown = "Unknown"
+}
+export interface DescribeQueriesRequest {
+    
+    logGroupName?: string;
+    
+    status?: QueryStatus | string;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace DescribeQueriesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeQueriesRequest) => any;
+}
+
+export interface QueryInfo {
+    
+    queryId?: string;
+    
+    queryString?: string;
+    
+    status?: QueryStatus | string;
+    
+    createTime?: number;
+    
+    logGroupName?: string;
+}
+export declare namespace QueryInfo {
+    
+    const filterSensitiveLog: (obj: QueryInfo) => any;
+}
+export interface DescribeQueriesResponse {
+    
+    queries?: QueryInfo[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeQueriesResponse {
+    
+    const filterSensitiveLog: (obj: DescribeQueriesResponse) => any;
+}
+export interface DescribeQueryDefinitionsRequest {
+    
+    queryDefinitionNamePrefix?: string;
+    
+    maxResults?: number;
+    
+    nextToken?: string;
+}
+export declare namespace DescribeQueryDefinitionsRequest {
+    
+    const filterSensitiveLog: (obj: DescribeQueryDefinitionsRequest) => any;
+}
+
+export interface QueryDefinition {
+    
+    queryDefinitionId?: string;
+    
+    name?: string;
+    
+    queryString?: string;
+    
+    lastModified?: number;
+    
+    logGroupNames?: string[];
+}
+export declare namespace QueryDefinition {
+    
+    const filterSensitiveLog: (obj: QueryDefinition) => any;
+}
+export interface DescribeQueryDefinitionsResponse {
+    
+    queryDefinitions?: QueryDefinition[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeQueryDefinitionsResponse {
+    
+    const filterSensitiveLog: (obj: DescribeQueryDefinitionsResponse) => any;
+}
+export interface DescribeResourcePoliciesRequest {
+    
+    nextToken?: string;
+    
+    limit?: number;
+}
+export declare namespace DescribeResourcePoliciesRequest {
+    
+    const filterSensitiveLog: (obj: DescribeResourcePoliciesRequest) => any;
+}
+
+export interface ResourcePolicy {
+    
+    policyName?: string;
+    
+    policyDocument?: string;
+    
+    lastUpdatedTime?: number;
+}
+export declare namespace ResourcePolicy {
+    
+    const filterSensitiveLog: (obj: ResourcePolicy) => any;
+}
+export interface DescribeResourcePoliciesResponse {
+    
+    resourcePolicies?: ResourcePolicy[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeResourcePoliciesResponse {
+    
+    const filterSensitiveLog: (obj: DescribeResourcePoliciesResponse) => any;
+}
+export interface DescribeSubscriptionFiltersRequest {
+    
+    logGroupName: string | undefined;
+    
+    filterNamePrefix?: string;
+    
+    nextToken?: string;
+    
+    limit?: number;
+}
+export declare namespace DescribeSubscriptionFiltersRequest {
+    
+    const filterSensitiveLog: (obj: DescribeSubscriptionFiltersRequest) => any;
+}
+export declare enum Distribution {
+    ByLogStream = "ByLogStream",
+    Random = "Random"
+}
+
+export interface SubscriptionFilter {
+    
+    filterName?: string;
+    
+    logGroupName?: string;
+    
+    filterPattern?: string;
+    
+    destinationArn?: string;
+    
+    roleArn?: string;
+    
+    distribution?: Distribution | string;
+    
+    creationTime?: number;
+}
+export declare namespace SubscriptionFilter {
+    
+    const filterSensitiveLog: (obj: SubscriptionFilter) => any;
+}
+export interface DescribeSubscriptionFiltersResponse {
+    
+    subscriptionFilters?: SubscriptionFilter[];
+    
+    nextToken?: string;
+}
+export declare namespace DescribeSubscriptionFiltersResponse {
+    
+    const filterSensitiveLog: (obj: DescribeSubscriptionFiltersResponse) => any;
+}
+export interface DisassociateKmsKeyRequest {
+    
+    logGroupName: string | undefined;
+}
+export declare namespace DisassociateKmsKeyRequest {
+    
+    const filterSensitiveLog: (obj: DisassociateKmsKeyRequest) => any;
+}
+
+export interface FilteredLogEvent {
+    
+    logStreamName?: string;
+    
+    timestamp?: number;
+    
+    message?: string;
+    
+    ingestionTime?: number;
+    
+    eventId?: string;
+}
+export declare namespace FilteredLogEvent {
+    
+    const filterSensitiveLog: (obj: FilteredLogEvent) => any;
+}
+export interface FilterLogEventsRequest {
+    
+    logGroupName: string | undefined;
+    
+    logStreamNames?: string[];
+    
+    logStreamNamePrefix?: string;
+    
+    startTime?: number;
+    
+    endTime?: number;
+    
+    filterPattern?: string;
+    
+    nextToken?: string;
+    
+    limit?: number;
+    
+    interleaved?: boolean;
+}
+export declare namespace FilterLogEventsRequest {
+    
+    const filterSensitiveLog: (obj: FilterLogEventsRequest) => any;
+}
+
+export interface SearchedLogStream {
+    
+    logStreamName?: string;
+    
+    searchedCompletely?: boolean;
+}
+export declare namespace SearchedLogStream {
+    
+    const filterSensitiveLog: (obj: SearchedLogStream) => any;
+}
+export interface FilterLogEventsResponse {
+    
+    events?: FilteredLogEvent[];
+    
+    searchedLogStreams?: SearchedLogStream[];
+    
+    nextToken?: string;
+}
+export declare namespace FilterLogEventsResponse {
+    
+    const filterSensitiveLog: (obj: FilterLogEventsResponse) => any;
+}
+export interface GetLogEventsRequest {
+    
+    logGroupName: string | undefined;
+    
+    logStreamName: string | undefined;
+    
+    startTime?: number;
+    
+    endTime?: number;
+    
+    nextToken?: string;
+    
+    limit?: number;
+    
+    startFromHead?: boolean;
+}
+export declare namespace GetLogEventsRequest {
+    
+    const filterSensitiveLog: (obj: GetLogEventsRequest) => any;
+}
+
+export interface OutputLogEvent {
+    
+    timestamp?: number;
+    
+    message?: string;
+    
+    ingestionTime?: number;
+}
+export declare namespace OutputLogEvent {
+    
+    const filterSensitiveLog: (obj: OutputLogEvent) => any;
+}
+export interface GetLogEventsResponse {
+    
+    events?: OutputLogEvent[];
+    
+    nextForwardToken?: string;
+    
+    nextBackwardToken?: string;
+}
+export declare namespace GetLogEventsResponse {
+    
+    const filterSensitiveLog: (obj: GetLogEventsResponse) => any;
+}
+export interface GetLogGroupFieldsRequest {
+    
+    logGroupName: string | undefined;
+    
+    time?: number;
+}
+export declare namespace GetLogGroupFieldsRequest {
+    
+    const filterSensitiveLog: (obj: GetLogGroupFieldsRequest) => any;
+}
+
+export interface LogGroupField {
+    
+    name?: string;
+    
+    percent?: number;
+}
+export declare namespace LogGroupField {
+    
+    const filterSensitiveLog: (obj: LogGroupField) => any;
+}
+export interface GetLogGroupFieldsResponse {
+    
+    logGroupFields?: LogGroupField[];
+}
+export declare namespace GetLogGroupFieldsResponse {
+    
+    const filterSensitiveLog: (obj: GetLogGroupFieldsResponse) => any;
+}
+export interface GetLogRecordRequest {
+    
+    logRecordPointer: string | undefined;
+}
+export declare namespace GetLogRecordRequest {
+    
+    const filterSensitiveLog: (obj: GetLogRecordRequest) => any;
+}
+export interface GetLogRecordResponse {
+    
+    logRecord?: {
+        [key: string]: string;
+    };
+}
+export declare namespace GetLogRecordResponse {
+    
+    const filterSensitiveLog: (obj: GetLogRecordResponse) => any;
+}
+export interface GetQueryResultsRequest {
+    
+    queryId: string | undefined;
+}
+export declare namespace GetQueryResultsRequest {
+    
+    const filterSensitiveLog: (obj: GetQueryResultsRequest) => any;
+}
+
+export interface ResultField {
+    
+    field?: string;
+    
+    value?: string;
+}
+export declare namespace ResultField {
+    
+    const filterSensitiveLog: (obj: ResultField) => any;
+}
+
+export interface QueryStatistics {
+    
+    recordsMatched?: number;
+    
+    recordsScanned?: number;
+    
+    bytesScanned?: number;
+}
+export declare namespace QueryStatistics {
+    
+    const filterSensitiveLog: (obj: QueryStatistics) => any;
+}
+export interface GetQueryResultsResponse {
+    
+    results?: ResultField[][];
+    
+    statistics?: QueryStatistics;
+    
+    status?: QueryStatus | string;
+}
+export declare namespace GetQueryResultsResponse {
+    
+    const filterSensitiveLog: (obj: GetQueryResultsResponse) => any;
+}
+
+export interface InputLogEvent {
+    
+    timestamp: number | undefined;
+    
+    message: string | undefined;
+}
+export declare namespace InputLogEvent {
+    
+    const filterSensitiveLog: (obj: InputLogEvent) => any;
+}
+
+export declare class InvalidSequenceTokenException extends __BaseException {
+    readonly name: "InvalidSequenceTokenException";
+    readonly $fault: "client";
+    expectedSequenceToken?: string;
+    
+    constructor(opts: __ExceptionOptionType<InvalidSequenceTokenException, __BaseException>);
+}
+export interface ListTagsLogGroupRequest {
+    
+    logGroupName: string | undefined;
+}
+export declare namespace ListTagsLogGroupRequest {
+    
+    const filterSensitiveLog: (obj: ListTagsLogGroupRequest) => any;
+}
+export interface ListTagsLogGroupResponse {
+    
+    tags?: {
+        [key: string]: string;
+    };
+}
+export declare namespace ListTagsLogGroupResponse {
+    
+    const filterSensitiveLog: (obj: ListTagsLogGroupResponse) => any;
+}
+export interface PutDestinationRequest {
+    
+    destinationName: string | undefined;
+    
+    targetArn: string | undefined;
+    
+    roleArn: string | undefined;
+}
+export declare namespace PutDestinationRequest {
+    
+    const filterSensitiveLog: (obj: PutDestinationRequest) => any;
+}
+export interface PutDestinationResponse {
+    
+    destination?: Destination;
+}
+export declare namespace PutDestinationResponse {
+    
+    const filterSensitiveLog: (obj: PutDestinationResponse) => any;
+}
+export interface PutDestinationPolicyRequest {
+    
+    destinationName: string | undefined;
+    
+    accessPolicy: string | undefined;
+    
+    forceUpdate?: boolean;
+}
+export declare namespace PutDestinationPolicyRequest {
+    
+    const filterSensitiveLog: (obj: PutDestinationPolicyRequest) => any;
+}
+export interface PutLogEventsRequest {
+    
+    logGroupName: string | undefined;
+    
+    logStreamName: string | undefined;
+    
+    logEvents: InputLogEvent[] | undefined;
+    
+    sequenceToken?: string;
+}
+export declare namespace PutLogEventsRequest {
+    
+    const filterSensitiveLog: (obj: PutLogEventsRequest) => any;
+}
+
+export interface RejectedLogEventsInfo {
+    
+    tooNewLogEventStartIndex?: number;
+    
+    tooOldLogEventEndIndex?: number;
+    
+    expiredLogEventEndIndex?: number;
+}
+export declare namespace RejectedLogEventsInfo {
+    
+    const filterSensitiveLog: (obj: RejectedLogEventsInfo) => any;
+}
+export interface PutLogEventsResponse {
+    
+    nextSequenceToken?: string;
+    
+    rejectedLogEventsInfo?: RejectedLogEventsInfo;
+}
+export declare namespace PutLogEventsResponse {
+    
+    const filterSensitiveLog: (obj: PutLogEventsResponse) => any;
+}
+
+export declare class UnrecognizedClientException extends __BaseException {
+    readonly name: "UnrecognizedClientException";
+    readonly $fault: "client";
+    
+    constructor(opts: __ExceptionOptionType<UnrecognizedClientException, __BaseException>);
+}
+export interface PutMetricFilterRequest {
+    
+    logGroupName: string | undefined;
+    
+    filterName: string | undefined;
+    
+    filterPattern: string | undefined;
+    
+    metricTransformations: MetricTransformation[] | undefined;
+}
+export declare namespace PutMetricFilterRequest {
+    
+    const filterSensitiveLog: (obj: PutMetricFilterRequest) => any;
+}
+export interface PutQueryDefinitionRequest {
+    
+    name: string | undefined;
+    
+    queryDefinitionId?: string;
+    
+    logGroupNames?: string[];
+    
+    queryString: string | undefined;
+}
+export declare namespace PutQueryDefinitionRequest {
+    
+    const filterSensitiveLog: (obj: PutQueryDefinitionRequest) => any;
+}
+export interface PutQueryDefinitionResponse {
+    
+    queryDefinitionId?: string;
+}
+export declare namespace PutQueryDefinitionResponse {
+    
+    const filterSensitiveLog: (obj: PutQueryDefinitionResponse) => any;
+}
+export interface PutResourcePolicyRequest {
+    
+    policyName?: string;
+    
+    policyDocument?: string;
+}
+export declare namespace PutResourcePolicyRequest {
+    
+    const filterSensitiveLog: (obj: PutResourcePolicyRequest) => any;
+}
+export interface PutResourcePolicyResponse {
+    
+    resourcePolicy?: ResourcePolicy;
+}
+export declare namespace PutResourcePolicyResponse {
+    
+    const filterSensitiveLog: (obj: PutResourcePolicyResponse) => any;
+}
+export interface PutRetentionPolicyRequest {
+    
+    logGroupName: string | undefined;
+    
+    retentionInDays: number | undefined;
+}
+export declare namespace PutRetentionPolicyRequest {
+    
+    const filterSensitiveLog: (obj: PutRetentionPolicyRequest) => any;
+}
+export interface PutSubscriptionFilterRequest {
+    
+    logGroupName: string | undefined;
+    
+    filterName: string | undefined;
+    
+    filterPattern: string | undefined;
+    
+    destinationArn: string | undefined;
+    
+    roleArn?: string;
+    
+    distribution?: Distribution | string;
+}
+export declare namespace PutSubscriptionFilterRequest {
+    
+    const filterSensitiveLog: (obj: PutSubscriptionFilterRequest) => any;
+}
+
+export interface QueryCompileErrorLocation {
+    
+    startCharOffset?: number;
+    
+    endCharOffset?: number;
+}
+export declare namespace QueryCompileErrorLocation {
+    
+    const filterSensitiveLog: (obj: QueryCompileErrorLocation) => any;
+}
+
+export interface QueryCompileError {
+    
+    location?: QueryCompileErrorLocation;
+    
+    message?: string;
+}
+export declare namespace QueryCompileError {
+    
+    const filterSensitiveLog: (obj: QueryCompileError) => any;
+}
+
+export declare class MalformedQueryException extends __BaseException {
+    readonly name: "MalformedQueryException";
+    readonly $fault: "client";
+    
+    queryCompileError?: QueryCompileError;
+    
+    constructor(opts: __ExceptionOptionType<MalformedQueryException, __BaseException>);
+}
+export interface StartQueryRequest {
+    
+    logGroupName?: string;
+    
+    logGroupNames?: string[];
+    
+    startTime: number | undefined;
+    
+    endTime: number | undefined;
+    
+    queryString: string | undefined;
+    
+    limit?: number;
+}
+export declare namespace StartQueryRequest {
+    
+    const filterSensitiveLog: (obj: StartQueryRequest) => any;
+}
+export interface StartQueryResponse {
+    
+    queryId?: string;
+}
+export declare namespace StartQueryResponse {
+    
+    const filterSensitiveLog: (obj: StartQueryResponse) => any;
+}
+export interface StopQueryRequest {
+    
+    queryId: string | undefined;
+}
+export declare namespace StopQueryRequest {
+    
+    const filterSensitiveLog: (obj: StopQueryRequest) => any;
+}
+export interface StopQueryResponse {
+    
+    success?: boolean;
+}
+export declare namespace StopQueryResponse {
+    
+    const filterSensitiveLog: (obj: StopQueryResponse) => any;
+}
+export interface TagLogGroupRequest {
+    
+    logGroupName: string | undefined;
+    
+    tags: {
+        [key: string]: string;
+    } | undefined;
+}
+export declare namespace TagLogGroupRequest {
+    
+    const filterSensitiveLog: (obj: TagLogGroupRequest) => any;
+}
+export interface TestMetricFilterRequest {
+    
+    filterPattern: string | undefined;
+    
+    logEventMessages: string[] | undefined;
+}
+export declare namespace TestMetricFilterRequest {
+    
+    const filterSensitiveLog: (obj: TestMetricFilterRequest) => any;
+}
+
+export interface MetricFilterMatchRecord {
+    
+    eventNumber?: number;
+    
+    eventMessage?: string;
+    
+    extractedValues?: {
+        [key: string]: string;
+    };
+}
+export declare namespace MetricFilterMatchRecord {
+    
+    const filterSensitiveLog: (obj: MetricFilterMatchRecord) => any;
+}
+export interface TestMetricFilterResponse {
+    
+    matches?: MetricFilterMatchRecord[];
+}
+export declare namespace TestMetricFilterResponse {
+    
+    const filterSensitiveLog: (obj: TestMetricFilterResponse) => any;
+}
+export interface UntagLogGroupRequest {
+    
+    logGroupName: string | undefined;
+    
+    tags: string[] | undefined;
+}
+export declare namespace UntagLogGroupRequest {
+    
+    const filterSensitiveLog: (obj: UntagLogGroupRequest) => any;
+}