cloudwatchlogs.d.ts (48700B)
1 import {Request} from '../lib/request'; 2 import {Response} from '../lib/response'; 3 import {AWSError} from '../lib/error'; 4 import {Service} from '../lib/service'; 5 import {ServiceConfigurationOptions} from '../lib/service'; 6 import {ConfigBase as Config} from '../lib/config'; 7 interface Blob {} 8 declare class CloudWatchLogs extends Service { 9 /** 10 * Constructs a service object. This object has one method for each API operation. 11 */ 12 constructor(options?: CloudWatchLogs.Types.ClientConfiguration) 13 config: Config & CloudWatchLogs.Types.ClientConfiguration; 14 /** 15 * Cancels the specified export task. The task must be in the PENDING or RUNNING state. 16 */ 17 cancelExportTask(params: CloudWatchLogs.Types.CancelExportTaskRequest, callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>; 18 /** 19 * Cancels the specified export task. The task must be in the PENDING or RUNNING state. 20 */ 21 cancelExportTask(callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>; 22 /** 23 * Creates an export task, which allows you to efficiently export data from a log group to an Amazon S3 bucket. This is an asynchronous call. If all the required information is provided, this operation initiates an export task and responds with the ID of the task. After the task has started, you can use DescribeExportTasks to get the status of the export task. Each account can only have one active (RUNNING or PENDING) export task at a time. To cancel an export task, use CancelExportTask. You can export logs from multiple log groups or multiple time ranges to the same S3 bucket. To separate out log data for each export task, you can specify a prefix that will be used as the Amazon S3 key prefix for all exported objects. 24 */ 25 createExportTask(params: CloudWatchLogs.Types.CreateExportTaskRequest, callback?: (err: AWSError, data: CloudWatchLogs.Types.CreateExportTaskResponse) => void): Request<CloudWatchLogs.Types.CreateExportTaskResponse, AWSError>; 26 /** 27 * Creates an export task, which allows you to efficiently export data from a log group to an Amazon S3 bucket. This is an asynchronous call. If all the required information is provided, this operation initiates an export task and responds with the ID of the task. After the task has started, you can use DescribeExportTasks to get the status of the export task. Each account can only have one active (RUNNING or PENDING) export task at a time. To cancel an export task, use CancelExportTask. You can export logs from multiple log groups or multiple time ranges to the same S3 bucket. To separate out log data for each export task, you can specify a prefix that will be used as the Amazon S3 key prefix for all exported objects. 28 */ 29 createExportTask(callback?: (err: AWSError, data: CloudWatchLogs.Types.CreateExportTaskResponse) => void): Request<CloudWatchLogs.Types.CreateExportTaskResponse, AWSError>; 30 /** 31 * Creates a log group with the specified name. You can create up to 5000 log groups per account. You must use the following guidelines when naming a log group: Log group names must be unique within a region for an AWS account. Log group names can be between 1 and 512 characters long. Log group names consist of the following characters: a-z, A-Z, 0-9, '_' (underscore), '-' (hyphen), '/' (forward slash), and '.' (period). 32 */ 33 createLogGroup(params: CloudWatchLogs.Types.CreateLogGroupRequest, callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>; 34 /** 35 * Creates a log group with the specified name. You can create up to 5000 log groups per account. You must use the following guidelines when naming a log group: Log group names must be unique within a region for an AWS account. Log group names can be between 1 and 512 characters long. Log group names consist of the following characters: a-z, A-Z, 0-9, '_' (underscore), '-' (hyphen), '/' (forward slash), and '.' (period). 36 */ 37 createLogGroup(callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>; 38 /** 39 * Creates a log stream for the specified log group. There is no limit on the number of log streams that you can create for a log group. You must use the following guidelines when naming a log stream: Log stream names must be unique within the log group. Log stream names can be between 1 and 512 characters long. The ':' (colon) and '*' (asterisk) characters are not allowed. 40 */ 41 createLogStream(params: CloudWatchLogs.Types.CreateLogStreamRequest, callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>; 42 /** 43 * Creates a log stream for the specified log group. There is no limit on the number of log streams that you can create for a log group. You must use the following guidelines when naming a log stream: Log stream names must be unique within the log group. Log stream names can be between 1 and 512 characters long. The ':' (colon) and '*' (asterisk) characters are not allowed. 44 */ 45 createLogStream(callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>; 46 /** 47 * Deletes the specified destination, and eventually disables all the subscription filters that publish to it. This operation does not delete the physical resource encapsulated by the destination. 48 */ 49 deleteDestination(params: CloudWatchLogs.Types.DeleteDestinationRequest, callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>; 50 /** 51 * Deletes the specified destination, and eventually disables all the subscription filters that publish to it. This operation does not delete the physical resource encapsulated by the destination. 52 */ 53 deleteDestination(callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>; 54 /** 55 * Deletes the specified log group and permanently deletes all the archived log events associated with the log group. 56 */ 57 deleteLogGroup(params: CloudWatchLogs.Types.DeleteLogGroupRequest, callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>; 58 /** 59 * Deletes the specified log group and permanently deletes all the archived log events associated with the log group. 60 */ 61 deleteLogGroup(callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>; 62 /** 63 * Deletes the specified log stream and permanently deletes all the archived log events associated with the log stream. 64 */ 65 deleteLogStream(params: CloudWatchLogs.Types.DeleteLogStreamRequest, callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>; 66 /** 67 * Deletes the specified log stream and permanently deletes all the archived log events associated with the log stream. 68 */ 69 deleteLogStream(callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>; 70 /** 71 * Deletes the specified metric filter. 72 */ 73 deleteMetricFilter(params: CloudWatchLogs.Types.DeleteMetricFilterRequest, callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>; 74 /** 75 * Deletes the specified metric filter. 76 */ 77 deleteMetricFilter(callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>; 78 /** 79 * Deletes the specified retention policy. Log events do not expire if they belong to log groups without a retention policy. 80 */ 81 deleteRetentionPolicy(params: CloudWatchLogs.Types.DeleteRetentionPolicyRequest, callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>; 82 /** 83 * Deletes the specified retention policy. Log events do not expire if they belong to log groups without a retention policy. 84 */ 85 deleteRetentionPolicy(callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>; 86 /** 87 * Deletes the specified subscription filter. 88 */ 89 deleteSubscriptionFilter(params: CloudWatchLogs.Types.DeleteSubscriptionFilterRequest, callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>; 90 /** 91 * Deletes the specified subscription filter. 92 */ 93 deleteSubscriptionFilter(callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>; 94 /** 95 * Lists all your destinations. The results are ASCII-sorted by destination name. 96 */ 97 describeDestinations(params: CloudWatchLogs.Types.DescribeDestinationsRequest, callback?: (err: AWSError, data: CloudWatchLogs.Types.DescribeDestinationsResponse) => void): Request<CloudWatchLogs.Types.DescribeDestinationsResponse, AWSError>; 98 /** 99 * Lists all your destinations. The results are ASCII-sorted by destination name. 100 */ 101 describeDestinations(callback?: (err: AWSError, data: CloudWatchLogs.Types.DescribeDestinationsResponse) => void): Request<CloudWatchLogs.Types.DescribeDestinationsResponse, AWSError>; 102 /** 103 * Lists the specified export tasks. You can list all your export tasks or filter the results based on task ID or task status. 104 */ 105 describeExportTasks(params: CloudWatchLogs.Types.DescribeExportTasksRequest, callback?: (err: AWSError, data: CloudWatchLogs.Types.DescribeExportTasksResponse) => void): Request<CloudWatchLogs.Types.DescribeExportTasksResponse, AWSError>; 106 /** 107 * Lists the specified export tasks. You can list all your export tasks or filter the results based on task ID or task status. 108 */ 109 describeExportTasks(callback?: (err: AWSError, data: CloudWatchLogs.Types.DescribeExportTasksResponse) => void): Request<CloudWatchLogs.Types.DescribeExportTasksResponse, AWSError>; 110 /** 111 * Lists the specified log groups. You can list all your log groups or filter the results by prefix. The results are ASCII-sorted by log group name. 112 */ 113 describeLogGroups(params: CloudWatchLogs.Types.DescribeLogGroupsRequest, callback?: (err: AWSError, data: CloudWatchLogs.Types.DescribeLogGroupsResponse) => void): Request<CloudWatchLogs.Types.DescribeLogGroupsResponse, AWSError>; 114 /** 115 * Lists the specified log groups. You can list all your log groups or filter the results by prefix. The results are ASCII-sorted by log group name. 116 */ 117 describeLogGroups(callback?: (err: AWSError, data: CloudWatchLogs.Types.DescribeLogGroupsResponse) => void): Request<CloudWatchLogs.Types.DescribeLogGroupsResponse, AWSError>; 118 /** 119 * Lists the log streams for the specified log group. You can list all the log streams or filter the results by prefix. You can also control how the results are ordered. This operation has a limit of five transactions per second, after which transactions are throttled. 120 */ 121 describeLogStreams(params: CloudWatchLogs.Types.DescribeLogStreamsRequest, callback?: (err: AWSError, data: CloudWatchLogs.Types.DescribeLogStreamsResponse) => void): Request<CloudWatchLogs.Types.DescribeLogStreamsResponse, AWSError>; 122 /** 123 * Lists the log streams for the specified log group. You can list all the log streams or filter the results by prefix. You can also control how the results are ordered. This operation has a limit of five transactions per second, after which transactions are throttled. 124 */ 125 describeLogStreams(callback?: (err: AWSError, data: CloudWatchLogs.Types.DescribeLogStreamsResponse) => void): Request<CloudWatchLogs.Types.DescribeLogStreamsResponse, AWSError>; 126 /** 127 * Lists the specified metric filters. You can list all the metric filters or filter the results by log name, prefix, metric name, or metric namespace. The results are ASCII-sorted by filter name. 128 */ 129 describeMetricFilters(params: CloudWatchLogs.Types.DescribeMetricFiltersRequest, callback?: (err: AWSError, data: CloudWatchLogs.Types.DescribeMetricFiltersResponse) => void): Request<CloudWatchLogs.Types.DescribeMetricFiltersResponse, AWSError>; 130 /** 131 * Lists the specified metric filters. You can list all the metric filters or filter the results by log name, prefix, metric name, or metric namespace. The results are ASCII-sorted by filter name. 132 */ 133 describeMetricFilters(callback?: (err: AWSError, data: CloudWatchLogs.Types.DescribeMetricFiltersResponse) => void): Request<CloudWatchLogs.Types.DescribeMetricFiltersResponse, AWSError>; 134 /** 135 * Lists the subscription filters for the specified log group. You can list all the subscription filters or filter the results by prefix. The results are ASCII-sorted by filter name. 136 */ 137 describeSubscriptionFilters(params: CloudWatchLogs.Types.DescribeSubscriptionFiltersRequest, callback?: (err: AWSError, data: CloudWatchLogs.Types.DescribeSubscriptionFiltersResponse) => void): Request<CloudWatchLogs.Types.DescribeSubscriptionFiltersResponse, AWSError>; 138 /** 139 * Lists the subscription filters for the specified log group. You can list all the subscription filters or filter the results by prefix. The results are ASCII-sorted by filter name. 140 */ 141 describeSubscriptionFilters(callback?: (err: AWSError, data: CloudWatchLogs.Types.DescribeSubscriptionFiltersResponse) => void): Request<CloudWatchLogs.Types.DescribeSubscriptionFiltersResponse, AWSError>; 142 /** 143 * Lists log events from the specified log group. You can list all the log events or filter the results using a filter pattern, a time range, and the name of the log stream. By default, this operation returns as many log events as can fit in 1MB (up to 10,000 log events), or all the events found within the time range that you specify. If the results include a token, then there are more log events available, and you can get additional results by specifying the token in a subsequent call. 144 */ 145 filterLogEvents(params: CloudWatchLogs.Types.FilterLogEventsRequest, callback?: (err: AWSError, data: CloudWatchLogs.Types.FilterLogEventsResponse) => void): Request<CloudWatchLogs.Types.FilterLogEventsResponse, AWSError>; 146 /** 147 * Lists log events from the specified log group. You can list all the log events or filter the results using a filter pattern, a time range, and the name of the log stream. By default, this operation returns as many log events as can fit in 1MB (up to 10,000 log events), or all the events found within the time range that you specify. If the results include a token, then there are more log events available, and you can get additional results by specifying the token in a subsequent call. 148 */ 149 filterLogEvents(callback?: (err: AWSError, data: CloudWatchLogs.Types.FilterLogEventsResponse) => void): Request<CloudWatchLogs.Types.FilterLogEventsResponse, AWSError>; 150 /** 151 * Lists log events from the specified log stream. You can list all the log events or filter using a time range. By default, this operation returns as many log events as can fit in a response size of 1MB (up to 10,000 log events). If the results include tokens, there are more log events available. You can get additional log events by specifying one of the tokens in a subsequent call. 152 */ 153 getLogEvents(params: CloudWatchLogs.Types.GetLogEventsRequest, callback?: (err: AWSError, data: CloudWatchLogs.Types.GetLogEventsResponse) => void): Request<CloudWatchLogs.Types.GetLogEventsResponse, AWSError>; 154 /** 155 * Lists log events from the specified log stream. You can list all the log events or filter using a time range. By default, this operation returns as many log events as can fit in a response size of 1MB (up to 10,000 log events). If the results include tokens, there are more log events available. You can get additional log events by specifying one of the tokens in a subsequent call. 156 */ 157 getLogEvents(callback?: (err: AWSError, data: CloudWatchLogs.Types.GetLogEventsResponse) => void): Request<CloudWatchLogs.Types.GetLogEventsResponse, AWSError>; 158 /** 159 * Creates or updates a destination. A destination encapsulates a physical resource (such as a Kinesis stream) and enables you to subscribe to a real-time stream of log events of a different account, ingested using PutLogEvents. Currently, the only supported physical resource is a Amazon Kinesis stream belonging to the same account as the destination. A destination controls what is written to its Amazon Kinesis stream through an access policy. By default, PutDestination does not set any access policy with the destination, which means a cross-account user cannot call PutSubscriptionFilter against this destination. To enable this, the destination owner must call PutDestinationPolicy after PutDestination. 160 */ 161 putDestination(params: CloudWatchLogs.Types.PutDestinationRequest, callback?: (err: AWSError, data: CloudWatchLogs.Types.PutDestinationResponse) => void): Request<CloudWatchLogs.Types.PutDestinationResponse, AWSError>; 162 /** 163 * Creates or updates a destination. A destination encapsulates a physical resource (such as a Kinesis stream) and enables you to subscribe to a real-time stream of log events of a different account, ingested using PutLogEvents. Currently, the only supported physical resource is a Amazon Kinesis stream belonging to the same account as the destination. A destination controls what is written to its Amazon Kinesis stream through an access policy. By default, PutDestination does not set any access policy with the destination, which means a cross-account user cannot call PutSubscriptionFilter against this destination. To enable this, the destination owner must call PutDestinationPolicy after PutDestination. 164 */ 165 putDestination(callback?: (err: AWSError, data: CloudWatchLogs.Types.PutDestinationResponse) => void): Request<CloudWatchLogs.Types.PutDestinationResponse, AWSError>; 166 /** 167 * Creates or updates an access policy associated with an existing destination. An access policy is an IAM policy document that is used to authorize claims to register a subscription filter against a given destination. 168 */ 169 putDestinationPolicy(params: CloudWatchLogs.Types.PutDestinationPolicyRequest, callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>; 170 /** 171 * Creates or updates an access policy associated with an existing destination. An access policy is an IAM policy document that is used to authorize claims to register a subscription filter against a given destination. 172 */ 173 putDestinationPolicy(callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>; 174 /** 175 * Uploads a batch of log events to the specified log stream. You must include the sequence token obtained from the response of the previous call. An upload in a newly created log stream does not require a sequence token. You can also get the sequence token using DescribeLogStreams. The batch of events must satisfy the following constraints: The maximum batch size is 1,048,576 bytes, and this size is calculated as the sum of all event messages in UTF-8, plus 26 bytes for each log event. None of the log events in the batch can be more than 2 hours in the future. None of the log events in the batch can be older than 14 days or the retention period of the log group. The log events in the batch must be in chronological ordered by their timestamp. The maximum number of log events in a batch is 10,000. A batch of log events in a single PutLogEvents request cannot span more than 24 hours. Otherwise, the PutLogEvents operation will fail. 176 */ 177 putLogEvents(params: CloudWatchLogs.Types.PutLogEventsRequest, callback?: (err: AWSError, data: CloudWatchLogs.Types.PutLogEventsResponse) => void): Request<CloudWatchLogs.Types.PutLogEventsResponse, AWSError>; 178 /** 179 * Uploads a batch of log events to the specified log stream. You must include the sequence token obtained from the response of the previous call. An upload in a newly created log stream does not require a sequence token. You can also get the sequence token using DescribeLogStreams. The batch of events must satisfy the following constraints: The maximum batch size is 1,048,576 bytes, and this size is calculated as the sum of all event messages in UTF-8, plus 26 bytes for each log event. None of the log events in the batch can be more than 2 hours in the future. None of the log events in the batch can be older than 14 days or the retention period of the log group. The log events in the batch must be in chronological ordered by their timestamp. The maximum number of log events in a batch is 10,000. A batch of log events in a single PutLogEvents request cannot span more than 24 hours. Otherwise, the PutLogEvents operation will fail. 180 */ 181 putLogEvents(callback?: (err: AWSError, data: CloudWatchLogs.Types.PutLogEventsResponse) => void): Request<CloudWatchLogs.Types.PutLogEventsResponse, AWSError>; 182 /** 183 * Creates or updates a metric filter and associates it with the specified log group. Metric filters allow you to configure rules to extract metric data from log events ingested through PutLogEvents. The maximum number of metric filters that can be associated with a log group is 100. 184 */ 185 putMetricFilter(params: CloudWatchLogs.Types.PutMetricFilterRequest, callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>; 186 /** 187 * Creates or updates a metric filter and associates it with the specified log group. Metric filters allow you to configure rules to extract metric data from log events ingested through PutLogEvents. The maximum number of metric filters that can be associated with a log group is 100. 188 */ 189 putMetricFilter(callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>; 190 /** 191 * Sets the retention of the specified log group. A retention policy allows you to configure the number of days you want to retain log events in the specified log group. 192 */ 193 putRetentionPolicy(params: CloudWatchLogs.Types.PutRetentionPolicyRequest, callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>; 194 /** 195 * Sets the retention of the specified log group. A retention policy allows you to configure the number of days you want to retain log events in the specified log group. 196 */ 197 putRetentionPolicy(callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>; 198 /** 199 * Creates or updates a subscription filter and associates it with the specified log group. Subscription filters allow you to subscribe to a real-time stream of log events ingested through PutLogEvents and have them delivered to a specific destination. Currently, the supported destinations are: An Amazon Kinesis stream belonging to the same account as the subscription filter, for same-account delivery. A logical destination that belongs to a different account, for cross-account delivery. An Amazon Kinesis Firehose stream that belongs to the same account as the subscription filter, for same-account delivery. An AWS Lambda function that belongs to the same account as the subscription filter, for same-account delivery. There can only be one subscription filter associated with a log group. 200 */ 201 putSubscriptionFilter(params: CloudWatchLogs.Types.PutSubscriptionFilterRequest, callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>; 202 /** 203 * Creates or updates a subscription filter and associates it with the specified log group. Subscription filters allow you to subscribe to a real-time stream of log events ingested through PutLogEvents and have them delivered to a specific destination. Currently, the supported destinations are: An Amazon Kinesis stream belonging to the same account as the subscription filter, for same-account delivery. A logical destination that belongs to a different account, for cross-account delivery. An Amazon Kinesis Firehose stream that belongs to the same account as the subscription filter, for same-account delivery. An AWS Lambda function that belongs to the same account as the subscription filter, for same-account delivery. There can only be one subscription filter associated with a log group. 204 */ 205 putSubscriptionFilter(callback?: (err: AWSError, data: {}) => void): Request<{}, AWSError>; 206 /** 207 * Tests the filter pattern of a metric filter against a sample of log event messages. You can use this operation to validate the correctness of a metric filter pattern. 208 */ 209 testMetricFilter(params: CloudWatchLogs.Types.TestMetricFilterRequest, callback?: (err: AWSError, data: CloudWatchLogs.Types.TestMetricFilterResponse) => void): Request<CloudWatchLogs.Types.TestMetricFilterResponse, AWSError>; 210 /** 211 * Tests the filter pattern of a metric filter against a sample of log event messages. You can use this operation to validate the correctness of a metric filter pattern. 212 */ 213 testMetricFilter(callback?: (err: AWSError, data: CloudWatchLogs.Types.TestMetricFilterResponse) => void): Request<CloudWatchLogs.Types.TestMetricFilterResponse, AWSError>; 214 } 215 declare namespace CloudWatchLogs.Types { 216 export type AccessPolicy = string; 217 export type Arn = string; 218 export interface CancelExportTaskRequest { 219 /** 220 * The ID of the export task. 221 */ 222 taskId: ExportTaskId; 223 } 224 export interface CreateExportTaskRequest { 225 /** 226 * The name of the export task. 227 */ 228 taskName?: ExportTaskName; 229 /** 230 * The name of the log group. 231 */ 232 logGroupName: LogGroupName; 233 /** 234 * Export only log streams that match the provided prefix. If you don't specify a value, no prefix filter is applied. 235 */ 236 logStreamNamePrefix?: LogStreamName; 237 /** 238 * The start time of the range for the request, expressed as the number of milliseconds since Jan 1, 1970 00:00:00 UTC. Events with a timestamp earlier than this time are not exported. 239 */ 240 from: Timestamp; 241 /** 242 * The end time of the range for the request, expressed as the number of milliseconds since Jan 1, 1970 00:00:00 UTC. Events with a timestamp later than this time are not exported. 243 */ 244 to: Timestamp; 245 /** 246 * The name of S3 bucket for the exported log data. The bucket must be in the same AWS region. 247 */ 248 destination: ExportDestinationBucket; 249 /** 250 * The prefix used as the start of the key for every object exported. If you don't specify a value, the default is exportedlogs. 251 */ 252 destinationPrefix?: ExportDestinationPrefix; 253 } 254 export interface CreateExportTaskResponse { 255 /** 256 * The ID of the export task. 257 */ 258 taskId?: ExportTaskId; 259 } 260 export interface CreateLogGroupRequest { 261 /** 262 * The name of the log group. 263 */ 264 logGroupName: LogGroupName; 265 } 266 export interface CreateLogStreamRequest { 267 /** 268 * The name of the log group. 269 */ 270 logGroupName: LogGroupName; 271 /** 272 * The name of the log stream. 273 */ 274 logStreamName: LogStreamName; 275 } 276 export type Days = number; 277 export type DefaultValue = number; 278 export interface DeleteDestinationRequest { 279 /** 280 * The name of the destination. 281 */ 282 destinationName: DestinationName; 283 } 284 export interface DeleteLogGroupRequest { 285 /** 286 * The name of the log group. 287 */ 288 logGroupName: LogGroupName; 289 } 290 export interface DeleteLogStreamRequest { 291 /** 292 * The name of the log group. 293 */ 294 logGroupName: LogGroupName; 295 /** 296 * The name of the log stream. 297 */ 298 logStreamName: LogStreamName; 299 } 300 export interface DeleteMetricFilterRequest { 301 /** 302 * The name of the log group. 303 */ 304 logGroupName: LogGroupName; 305 /** 306 * The name of the metric filter. 307 */ 308 filterName: FilterName; 309 } 310 export interface DeleteRetentionPolicyRequest { 311 /** 312 * The name of the log group. 313 */ 314 logGroupName: LogGroupName; 315 } 316 export interface DeleteSubscriptionFilterRequest { 317 /** 318 * The name of the log group. 319 */ 320 logGroupName: LogGroupName; 321 /** 322 * The name of the subscription filter. 323 */ 324 filterName: FilterName; 325 } 326 export type Descending = boolean; 327 export interface DescribeDestinationsRequest { 328 /** 329 * The prefix to match. If you don't specify a value, no prefix filter is applied. 330 */ 331 DestinationNamePrefix?: DestinationName; 332 /** 333 * The token for the next set of items to return. (You received this token from a previous call.) 334 */ 335 nextToken?: NextToken; 336 /** 337 * The maximum number of items returned. If you don't specify a value, the default is up to 50 items. 338 */ 339 limit?: DescribeLimit; 340 } 341 export interface DescribeDestinationsResponse { 342 /** 343 * The destinations. 344 */ 345 destinations?: Destinations; 346 nextToken?: NextToken; 347 } 348 export interface DescribeExportTasksRequest { 349 /** 350 * The ID of the export task. Specifying a task ID filters the results to zero or one export tasks. 351 */ 352 taskId?: ExportTaskId; 353 /** 354 * The status code of the export task. Specifying a status code filters the results to zero or more export tasks. 355 */ 356 statusCode?: ExportTaskStatusCode; 357 /** 358 * The token for the next set of items to return. (You received this token from a previous call.) 359 */ 360 nextToken?: NextToken; 361 /** 362 * The maximum number of items returned. If you don't specify a value, the default is up to 50 items. 363 */ 364 limit?: DescribeLimit; 365 } 366 export interface DescribeExportTasksResponse { 367 /** 368 * The export tasks. 369 */ 370 exportTasks?: ExportTasks; 371 nextToken?: NextToken; 372 } 373 export type DescribeLimit = number; 374 export interface DescribeLogGroupsRequest { 375 /** 376 * The prefix to match. 377 */ 378 logGroupNamePrefix?: LogGroupName; 379 /** 380 * The token for the next set of items to return. (You received this token from a previous call.) 381 */ 382 nextToken?: NextToken; 383 /** 384 * The maximum number of items returned. If you don't specify a value, the default is up to 50 items. 385 */ 386 limit?: DescribeLimit; 387 } 388 export interface DescribeLogGroupsResponse { 389 /** 390 * The log groups. 391 */ 392 logGroups?: LogGroups; 393 nextToken?: NextToken; 394 } 395 export interface DescribeLogStreamsRequest { 396 /** 397 * The name of the log group. 398 */ 399 logGroupName: LogGroupName; 400 /** 401 * The prefix to match. You cannot specify this parameter if orderBy is LastEventTime. 402 */ 403 logStreamNamePrefix?: LogStreamName; 404 /** 405 * If the value is LogStreamName, the results are ordered by log stream name. If the value is LastEventTime, the results are ordered by the event time. The default value is LogStreamName. If you order the results by event time, you cannot specify the logStreamNamePrefix parameter. 406 */ 407 orderBy?: OrderBy; 408 /** 409 * If the value is true, results are returned in descending order. If the value is to false, results are returned in ascending order. The default value is false. 410 */ 411 descending?: Descending; 412 /** 413 * The token for the next set of items to return. (You received this token from a previous call.) 414 */ 415 nextToken?: NextToken; 416 /** 417 * The maximum number of items returned. If you don't specify a value, the default is up to 50 items. 418 */ 419 limit?: DescribeLimit; 420 } 421 export interface DescribeLogStreamsResponse { 422 /** 423 * The log streams. 424 */ 425 logStreams?: LogStreams; 426 nextToken?: NextToken; 427 } 428 export interface DescribeMetricFiltersRequest { 429 /** 430 * The name of the log group. 431 */ 432 logGroupName?: LogGroupName; 433 /** 434 * The prefix to match. 435 */ 436 filterNamePrefix?: FilterName; 437 /** 438 * The token for the next set of items to return. (You received this token from a previous call.) 439 */ 440 nextToken?: NextToken; 441 /** 442 * The maximum number of items returned. If you don't specify a value, the default is up to 50 items. 443 */ 444 limit?: DescribeLimit; 445 /** 446 * The name of the CloudWatch metric. 447 */ 448 metricName?: MetricName; 449 /** 450 * The namespace of the CloudWatch metric. 451 */ 452 metricNamespace?: MetricNamespace; 453 } 454 export interface DescribeMetricFiltersResponse { 455 /** 456 * The metric filters. 457 */ 458 metricFilters?: MetricFilters; 459 nextToken?: NextToken; 460 } 461 export interface DescribeSubscriptionFiltersRequest { 462 /** 463 * The name of the log group. 464 */ 465 logGroupName: LogGroupName; 466 /** 467 * The prefix to match. If you don't specify a value, no prefix filter is applied. 468 */ 469 filterNamePrefix?: FilterName; 470 /** 471 * The token for the next set of items to return. (You received this token from a previous call.) 472 */ 473 nextToken?: NextToken; 474 /** 475 * The maximum number of items returned. If you don't specify a value, the default is up to 50 items. 476 */ 477 limit?: DescribeLimit; 478 } 479 export interface DescribeSubscriptionFiltersResponse { 480 /** 481 * The subscription filters. 482 */ 483 subscriptionFilters?: SubscriptionFilters; 484 nextToken?: NextToken; 485 } 486 export interface Destination { 487 /** 488 * The name of the destination. 489 */ 490 destinationName?: DestinationName; 491 /** 492 * The Amazon Resource Name (ARN) of the physical target where the log events will be delivered (for example, a Kinesis stream). 493 */ 494 targetArn?: TargetArn; 495 /** 496 * A role for impersonation, used when delivering log events to the target. 497 */ 498 roleArn?: RoleArn; 499 /** 500 * An IAM policy document that governs which AWS accounts can create subscription filters against this destination. 501 */ 502 accessPolicy?: AccessPolicy; 503 /** 504 * The ARN of this destination. 505 */ 506 arn?: Arn; 507 /** 508 * The creation time of the destination. 509 */ 510 creationTime?: Timestamp; 511 } 512 export type DestinationArn = string; 513 export type DestinationName = string; 514 export type Destinations = Destination[]; 515 export type EventId = string; 516 export type EventMessage = string; 517 export type EventNumber = number; 518 export type EventsLimit = number; 519 export type ExportDestinationBucket = string; 520 export type ExportDestinationPrefix = string; 521 export interface ExportTask { 522 /** 523 * The ID of the export task. 524 */ 525 taskId?: ExportTaskId; 526 /** 527 * The name of the export task. 528 */ 529 taskName?: ExportTaskName; 530 /** 531 * The name of the log group from which logs data was exported. 532 */ 533 logGroupName?: LogGroupName; 534 /** 535 * The start time. Events with a timestamp prior to this time are not exported. 536 */ 537 from?: Timestamp; 538 /** 539 * The end time. Events with a timestamp later than this time are not exported. 540 */ 541 to?: Timestamp; 542 /** 543 * The name of Amazon S3 bucket to which the log data was exported. 544 */ 545 destination?: ExportDestinationBucket; 546 /** 547 * The prefix that was used as the start of Amazon S3 key for every object exported. 548 */ 549 destinationPrefix?: ExportDestinationPrefix; 550 /** 551 * The status of the export task. 552 */ 553 status?: ExportTaskStatus; 554 /** 555 * Execution info about the export task. 556 */ 557 executionInfo?: ExportTaskExecutionInfo; 558 } 559 export interface ExportTaskExecutionInfo { 560 /** 561 * The creation time of the export task. 562 */ 563 creationTime?: Timestamp; 564 /** 565 * The completion time of the export task. 566 */ 567 completionTime?: Timestamp; 568 } 569 export type ExportTaskId = string; 570 export type ExportTaskName = string; 571 export interface ExportTaskStatus { 572 /** 573 * The status code of the export task. 574 */ 575 code?: ExportTaskStatusCode; 576 /** 577 * The status message related to the status code. 578 */ 579 message?: ExportTaskStatusMessage; 580 } 581 export type ExportTaskStatusCode = "CANCELLED"|"COMPLETED"|"FAILED"|"PENDING"|"PENDING_CANCEL"|"RUNNING"|string; 582 export type ExportTaskStatusMessage = string; 583 export type ExportTasks = ExportTask[]; 584 export type ExtractedValues = {[key: string]: Value}; 585 export type FilterCount = number; 586 export interface FilterLogEventsRequest { 587 /** 588 * The name of the log group. 589 */ 590 logGroupName: LogGroupName; 591 /** 592 * Optional list of log stream names. 593 */ 594 logStreamNames?: InputLogStreamNames; 595 /** 596 * The start of the time range. Events with a timestamp prior to this time are not returned. 597 */ 598 startTime?: Timestamp; 599 /** 600 * The end of the time range. Events with a timestamp later than this time are not returned. 601 */ 602 endTime?: Timestamp; 603 /** 604 * The filter pattern to use. If not provided, all the events are matched. 605 */ 606 filterPattern?: FilterPattern; 607 /** 608 * The token for the next set of events to return. (You received this token from a previous call.) 609 */ 610 nextToken?: NextToken; 611 /** 612 * The maximum number of events to return. The default is 10,000 events. 613 */ 614 limit?: EventsLimit; 615 /** 616 * If the value is true, the operation makes a best effort to provide responses that contain events from multiple log streams within the log group interleaved in a single response. If the value is false all the matched log events in the first log stream are searched first, then those in the next log stream, and so on. The default is false. 617 */ 618 interleaved?: Interleaved; 619 } 620 export interface FilterLogEventsResponse { 621 /** 622 * The matched events. 623 */ 624 events?: FilteredLogEvents; 625 /** 626 * Indicates which log streams have been searched and whether each has been searched completely. 627 */ 628 searchedLogStreams?: SearchedLogStreams; 629 /** 630 * The token to use when requesting the next set of items. The token expires after 24 hours. 631 */ 632 nextToken?: NextToken; 633 } 634 export type FilterName = string; 635 export type FilterPattern = string; 636 export interface FilteredLogEvent { 637 /** 638 * The name of the log stream this event belongs to. 639 */ 640 logStreamName?: LogStreamName; 641 /** 642 * The time the event occurred. 643 */ 644 timestamp?: Timestamp; 645 /** 646 * The data contained in the log event. 647 */ 648 message?: EventMessage; 649 /** 650 * The time the event was ingested. 651 */ 652 ingestionTime?: Timestamp; 653 /** 654 * The ID of the event. 655 */ 656 eventId?: EventId; 657 } 658 export type FilteredLogEvents = FilteredLogEvent[]; 659 export interface GetLogEventsRequest { 660 /** 661 * The name of the log group. 662 */ 663 logGroupName: LogGroupName; 664 /** 665 * The name of the log stream. 666 */ 667 logStreamName: LogStreamName; 668 /** 669 * The start of the time range. Events with a timestamp earlier than this time are not included. 670 */ 671 startTime?: Timestamp; 672 /** 673 * The end of the time range. Events with a timestamp later than this time are not included. 674 */ 675 endTime?: Timestamp; 676 /** 677 * The token for the next set of items to return. (You received this token from a previous call.) 678 */ 679 nextToken?: NextToken; 680 /** 681 * The maximum number of log events returned. If you don't specify a value, the maximum is as many log events as can fit in a response size of 1MB, up to 10,000 log events. 682 */ 683 limit?: EventsLimit; 684 /** 685 * If the value is true, the earliest log events are returned first. If the value is false, the latest log events are returned first. The default value is false. 686 */ 687 startFromHead?: StartFromHead; 688 } 689 export interface GetLogEventsResponse { 690 /** 691 * The events. 692 */ 693 events?: OutputLogEvents; 694 /** 695 * The token for the next set of items in the forward direction. The token expires after 24 hours. 696 */ 697 nextForwardToken?: NextToken; 698 /** 699 * The token for the next set of items in the backward direction. The token expires after 24 hours. 700 */ 701 nextBackwardToken?: NextToken; 702 } 703 export interface InputLogEvent { 704 /** 705 * The time the event occurred. 706 */ 707 timestamp: Timestamp; 708 /** 709 * The raw event message. 710 */ 711 message: EventMessage; 712 } 713 export type InputLogEvents = InputLogEvent[]; 714 export type InputLogStreamNames = LogStreamName[]; 715 export type Interleaved = boolean; 716 export type LogEventIndex = number; 717 export interface LogGroup { 718 /** 719 * The name of the log group. 720 */ 721 logGroupName?: LogGroupName; 722 /** 723 * The creation time of the log group. 724 */ 725 creationTime?: Timestamp; 726 retentionInDays?: Days; 727 /** 728 * The number of metric filters. 729 */ 730 metricFilterCount?: FilterCount; 731 /** 732 * The Amazon Resource Name (ARN) of the log group. 733 */ 734 arn?: Arn; 735 /** 736 * The number of bytes stored. 737 */ 738 storedBytes?: StoredBytes; 739 } 740 export type LogGroupName = string; 741 export type LogGroups = LogGroup[]; 742 export interface LogStream { 743 /** 744 * The name of the log stream. 745 */ 746 logStreamName?: LogStreamName; 747 /** 748 * The creation time of the stream. 749 */ 750 creationTime?: Timestamp; 751 /** 752 * The time of the first event. 753 */ 754 firstEventTimestamp?: Timestamp; 755 /** 756 * The time of the last event. 757 */ 758 lastEventTimestamp?: Timestamp; 759 /** 760 * The ingestion time. 761 */ 762 lastIngestionTime?: Timestamp; 763 /** 764 * The sequence token. 765 */ 766 uploadSequenceToken?: SequenceToken; 767 /** 768 * The Amazon Resource Name (ARN) of the log stream. 769 */ 770 arn?: Arn; 771 /** 772 * The number of bytes stored. 773 */ 774 storedBytes?: StoredBytes; 775 } 776 export type LogStreamName = string; 777 export type LogStreamSearchedCompletely = boolean; 778 export type LogStreams = LogStream[]; 779 export interface MetricFilter { 780 /** 781 * The name of the metric filter. 782 */ 783 filterName?: FilterName; 784 filterPattern?: FilterPattern; 785 /** 786 * The metric transformations. 787 */ 788 metricTransformations?: MetricTransformations; 789 /** 790 * The creation time of the metric filter. 791 */ 792 creationTime?: Timestamp; 793 /** 794 * The name of the log group. 795 */ 796 logGroupName?: LogGroupName; 797 } 798 export interface MetricFilterMatchRecord { 799 /** 800 * The event number. 801 */ 802 eventNumber?: EventNumber; 803 /** 804 * The raw event data. 805 */ 806 eventMessage?: EventMessage; 807 /** 808 * The values extracted from the event data by the filter. 809 */ 810 extractedValues?: ExtractedValues; 811 } 812 export type MetricFilterMatches = MetricFilterMatchRecord[]; 813 export type MetricFilters = MetricFilter[]; 814 export type MetricName = string; 815 export type MetricNamespace = string; 816 export interface MetricTransformation { 817 /** 818 * The name of the CloudWatch metric. 819 */ 820 metricName: MetricName; 821 /** 822 * The namespace of the CloudWatch metric. 823 */ 824 metricNamespace: MetricNamespace; 825 /** 826 * The value to publish to the CloudWatch metric when a filter pattern matches a log event. 827 */ 828 metricValue: MetricValue; 829 /** 830 * (Optional) The value to emit when a filter pattern does not match a log event. This value can be null. 831 */ 832 defaultValue?: DefaultValue; 833 } 834 export type MetricTransformations = MetricTransformation[]; 835 export type MetricValue = string; 836 export type NextToken = string; 837 export type OrderBy = "LogStreamName"|"LastEventTime"|string; 838 export interface OutputLogEvent { 839 /** 840 * The time the event occurred. 841 */ 842 timestamp?: Timestamp; 843 /** 844 * The data contained in the log event. 845 */ 846 message?: EventMessage; 847 /** 848 * The time the event was ingested. 849 */ 850 ingestionTime?: Timestamp; 851 } 852 export type OutputLogEvents = OutputLogEvent[]; 853 export interface PutDestinationPolicyRequest { 854 /** 855 * A name for an existing destination. 856 */ 857 destinationName: DestinationName; 858 /** 859 * An IAM policy document that authorizes cross-account users to deliver their log events to the associated destination. 860 */ 861 accessPolicy: AccessPolicy; 862 } 863 export interface PutDestinationRequest { 864 /** 865 * A name for the destination. 866 */ 867 destinationName: DestinationName; 868 /** 869 * The ARN of an Amazon Kinesis stream to deliver matching log events to. 870 */ 871 targetArn: TargetArn; 872 /** 873 * The ARN of an IAM role that grants CloudWatch Logs permissions to call Amazon Kinesis PutRecord on the destination stream. 874 */ 875 roleArn: RoleArn; 876 } 877 export interface PutDestinationResponse { 878 /** 879 * The destination. 880 */ 881 destination?: Destination; 882 } 883 export interface PutLogEventsRequest { 884 /** 885 * The name of the log group. 886 */ 887 logGroupName: LogGroupName; 888 /** 889 * The name of the log stream. 890 */ 891 logStreamName: LogStreamName; 892 /** 893 * The log events. 894 */ 895 logEvents: InputLogEvents; 896 /** 897 * The sequence token. 898 */ 899 sequenceToken?: SequenceToken; 900 } 901 export interface PutLogEventsResponse { 902 /** 903 * The next sequence token. 904 */ 905 nextSequenceToken?: SequenceToken; 906 /** 907 * The rejected events. 908 */ 909 rejectedLogEventsInfo?: RejectedLogEventsInfo; 910 } 911 export interface PutMetricFilterRequest { 912 /** 913 * The name of the log group. 914 */ 915 logGroupName: LogGroupName; 916 /** 917 * A name for the metric filter. 918 */ 919 filterName: FilterName; 920 /** 921 * A filter pattern for extracting metric data out of ingested log events. 922 */ 923 filterPattern: FilterPattern; 924 /** 925 * A collection of information needed to define how metric data gets emitted. 926 */ 927 metricTransformations: MetricTransformations; 928 } 929 export interface PutRetentionPolicyRequest { 930 /** 931 * The name of the log group. 932 */ 933 logGroupName: LogGroupName; 934 retentionInDays: Days; 935 } 936 export interface PutSubscriptionFilterRequest { 937 /** 938 * The name of the log group. 939 */ 940 logGroupName: LogGroupName; 941 /** 942 * A name for the subscription filter. 943 */ 944 filterName: FilterName; 945 /** 946 * A filter pattern for subscribing to a filtered stream of log events. 947 */ 948 filterPattern: FilterPattern; 949 /** 950 * The ARN of the destination to deliver matching log events to. Currently, the supported destinations are: An Amazon Kinesis stream belonging to the same account as the subscription filter, for same-account delivery. A logical destination (specified using an ARN) belonging to a different account, for cross-account delivery. An Amazon Kinesis Firehose stream belonging to the same account as the subscription filter, for same-account delivery. An AWS Lambda function belonging to the same account as the subscription filter, for same-account delivery. 951 */ 952 destinationArn: DestinationArn; 953 /** 954 * The ARN of an IAM role that grants CloudWatch Logs permissions to deliver ingested log events to the destination stream. You don't need to provide the ARN when you are working with a logical destination for cross-account delivery. 955 */ 956 roleArn?: RoleArn; 957 } 958 export interface RejectedLogEventsInfo { 959 /** 960 * The log events that are too new. 961 */ 962 tooNewLogEventStartIndex?: LogEventIndex; 963 /** 964 * The log events that are too old. 965 */ 966 tooOldLogEventEndIndex?: LogEventIndex; 967 /** 968 * The expired log events. 969 */ 970 expiredLogEventEndIndex?: LogEventIndex; 971 } 972 export type RoleArn = string; 973 export interface SearchedLogStream { 974 /** 975 * The name of the log stream. 976 */ 977 logStreamName?: LogStreamName; 978 /** 979 * Indicates whether all the events in this log stream were searched. 980 */ 981 searchedCompletely?: LogStreamSearchedCompletely; 982 } 983 export type SearchedLogStreams = SearchedLogStream[]; 984 export type SequenceToken = string; 985 export type StartFromHead = boolean; 986 export type StoredBytes = number; 987 export interface SubscriptionFilter { 988 /** 989 * The name of the subscription filter. 990 */ 991 filterName?: FilterName; 992 /** 993 * The name of the log group. 994 */ 995 logGroupName?: LogGroupName; 996 filterPattern?: FilterPattern; 997 /** 998 * The Amazon Resource Name (ARN) of the destination. 999 */ 1000 destinationArn?: DestinationArn; 1001 /** 1002 * 1003 */ 1004 roleArn?: RoleArn; 1005 /** 1006 * The creation time of the subscription filter. 1007 */ 1008 creationTime?: Timestamp; 1009 } 1010 export type SubscriptionFilters = SubscriptionFilter[]; 1011 export type TargetArn = string; 1012 export type TestEventMessages = EventMessage[]; 1013 export interface TestMetricFilterRequest { 1014 filterPattern: FilterPattern; 1015 /** 1016 * The log event messages to test. 1017 */ 1018 logEventMessages: TestEventMessages; 1019 } 1020 export interface TestMetricFilterResponse { 1021 /** 1022 * The matched events. 1023 */ 1024 matches?: MetricFilterMatches; 1025 } 1026 export type Timestamp = number; 1027 export type Token = string; 1028 export type Value = string; 1029 /** 1030 * A string in YYYY-MM-DD format that represents the latest possible API version that can be used in this service. Specify 'latest' to use the latest possible version. 1031 */ 1032 export type apiVersion = "2014-03-28"|"latest"|string; 1033 export interface ClientApiVersions { 1034 /** 1035 * A string in YYYY-MM-DD format that represents the latest possible API version that can be used in this service. Specify 'latest' to use the latest possible version. 1036 */ 1037 apiVersion?: apiVersion; 1038 } 1039 export type ClientConfiguration = ServiceConfigurationOptions & ClientApiVersions; 1040 } 1041 export = CloudWatchLogs;