cdk-amazon-chime-resources/node_modules/@aws-sdk/client-cloudwatch-logs/dist-cjs/index.js


"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
  if (from && typeof from === "object" || typeof from === "function") {
    for (let key of __getOwnPropNames(from))
      if (!__hasOwnProp.call(to, key) && key !== except)
        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
  }
  return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);

// src/index.ts
var src_exports = {};
__export(src_exports, {
  AccessDeniedException: () => AccessDeniedException,
  AnomalyDetectorStatus: () => AnomalyDetectorStatus,
  AssociateKmsKeyCommand: () => AssociateKmsKeyCommand,
  CancelExportTaskCommand: () => CancelExportTaskCommand,
  CloudWatchLogs: () => CloudWatchLogs,
  CloudWatchLogsClient: () => CloudWatchLogsClient,
  CloudWatchLogsServiceException: () => CloudWatchLogsServiceException,
  ConflictException: () => ConflictException,
  CreateDeliveryCommand: () => CreateDeliveryCommand,
  CreateExportTaskCommand: () => CreateExportTaskCommand,
  CreateLogAnomalyDetectorCommand: () => CreateLogAnomalyDetectorCommand,
  CreateLogGroupCommand: () => CreateLogGroupCommand,
  CreateLogStreamCommand: () => CreateLogStreamCommand,
  DataAlreadyAcceptedException: () => DataAlreadyAcceptedException,
  DataProtectionStatus: () => DataProtectionStatus,
  DeleteAccountPolicyCommand: () => DeleteAccountPolicyCommand,
  DeleteDataProtectionPolicyCommand: () => DeleteDataProtectionPolicyCommand,
  DeleteDeliveryCommand: () => DeleteDeliveryCommand,
  DeleteDeliveryDestinationCommand: () => DeleteDeliveryDestinationCommand,
  DeleteDeliveryDestinationPolicyCommand: () => DeleteDeliveryDestinationPolicyCommand,
  DeleteDeliverySourceCommand: () => DeleteDeliverySourceCommand,
  DeleteDestinationCommand: () => DeleteDestinationCommand,
  DeleteLogAnomalyDetectorCommand: () => DeleteLogAnomalyDetectorCommand,
  DeleteLogGroupCommand: () => DeleteLogGroupCommand,
  DeleteLogStreamCommand: () => DeleteLogStreamCommand,
  DeleteMetricFilterCommand: () => DeleteMetricFilterCommand,
  DeleteQueryDefinitionCommand: () => DeleteQueryDefinitionCommand,
  DeleteResourcePolicyCommand: () => DeleteResourcePolicyCommand,
  DeleteRetentionPolicyCommand: () => DeleteRetentionPolicyCommand,
  DeleteSubscriptionFilterCommand: () => DeleteSubscriptionFilterCommand,
  DeliveryDestinationType: () => DeliveryDestinationType,
  DescribeAccountPoliciesCommand: () => DescribeAccountPoliciesCommand,
  DescribeDeliveriesCommand: () => DescribeDeliveriesCommand,
  DescribeDeliveryDestinationsCommand: () => DescribeDeliveryDestinationsCommand,
  DescribeDeliverySourcesCommand: () => DescribeDeliverySourcesCommand,
  DescribeDestinationsCommand: () => DescribeDestinationsCommand,
  DescribeExportTasksCommand: () => DescribeExportTasksCommand,
  DescribeLogGroupsCommand: () => DescribeLogGroupsCommand,
  DescribeLogStreamsCommand: () => DescribeLogStreamsCommand,
  DescribeMetricFiltersCommand: () => DescribeMetricFiltersCommand,
  DescribeQueriesCommand: () => DescribeQueriesCommand,
  DescribeQueryDefinitionsCommand: () => DescribeQueryDefinitionsCommand,
  DescribeResourcePoliciesCommand: () => DescribeResourcePoliciesCommand,
  DescribeSubscriptionFiltersCommand: () => DescribeSubscriptionFiltersCommand,
  DisassociateKmsKeyCommand: () => DisassociateKmsKeyCommand,
  Distribution: () => Distribution,
  EvaluationFrequency: () => EvaluationFrequency,
  ExportTaskStatusCode: () => ExportTaskStatusCode,
  FilterLogEventsCommand: () => FilterLogEventsCommand,
  GetDataProtectionPolicyCommand: () => GetDataProtectionPolicyCommand,
  GetDeliveryCommand: () => GetDeliveryCommand,
  GetDeliveryDestinationCommand: () => GetDeliveryDestinationCommand,
  GetDeliveryDestinationPolicyCommand: () => GetDeliveryDestinationPolicyCommand,
  GetDeliverySourceCommand: () => GetDeliverySourceCommand,
  GetLogAnomalyDetectorCommand: () => GetLogAnomalyDetectorCommand,
  GetLogEventsCommand: () => GetLogEventsCommand,
  GetLogGroupFieldsCommand: () => GetLogGroupFieldsCommand,
  GetLogRecordCommand: () => GetLogRecordCommand,
  GetQueryResultsCommand: () => GetQueryResultsCommand,
  InheritedProperty: () => InheritedProperty,
  InvalidOperationException: () => InvalidOperationException,
  InvalidParameterException: () => InvalidParameterException,
  InvalidSequenceTokenException: () => InvalidSequenceTokenException,
  LimitExceededException: () => LimitExceededException,
  ListAnomaliesCommand: () => ListAnomaliesCommand,
  ListLogAnomalyDetectorsCommand: () => ListLogAnomalyDetectorsCommand,
  ListTagsForResourceCommand: () => ListTagsForResourceCommand,
  ListTagsLogGroupCommand: () => ListTagsLogGroupCommand,
  LogGroupClass: () => LogGroupClass,
  MalformedQueryException: () => MalformedQueryException,
  OperationAbortedException: () => OperationAbortedException,
  OrderBy: () => OrderBy,
  OutputFormat: () => OutputFormat,
  PolicyType: () => PolicyType,
  PutAccountPolicyCommand: () => PutAccountPolicyCommand,
  PutDataProtectionPolicyCommand: () => PutDataProtectionPolicyCommand,
  PutDeliveryDestinationCommand: () => PutDeliveryDestinationCommand,
  PutDeliveryDestinationPolicyCommand: () => PutDeliveryDestinationPolicyCommand,
  PutDeliverySourceCommand: () => PutDeliverySourceCommand,
  PutDestinationCommand: () => PutDestinationCommand,
  PutDestinationPolicyCommand: () => PutDestinationPolicyCommand,
  PutLogEventsCommand: () => PutLogEventsCommand,
  PutMetricFilterCommand: () => PutMetricFilterCommand,
  PutQueryDefinitionCommand: () => PutQueryDefinitionCommand,
  PutResourcePolicyCommand: () => PutResourcePolicyCommand,
  PutRetentionPolicyCommand: () => PutRetentionPolicyCommand,
  PutSubscriptionFilterCommand: () => PutSubscriptionFilterCommand,
  QueryStatus: () => QueryStatus,
  ResourceAlreadyExistsException: () => ResourceAlreadyExistsException,
  ResourceNotFoundException: () => ResourceNotFoundException,
  Scope: () => Scope,
  ServiceQuotaExceededException: () => ServiceQuotaExceededException,
  ServiceUnavailableException: () => ServiceUnavailableException,
  SessionStreamingException: () => SessionStreamingException,
  SessionTimeoutException: () => SessionTimeoutException,
  StandardUnit: () => StandardUnit,
  StartLiveTailCommand: () => StartLiveTailCommand,
  StartLiveTailResponseFilterSensitiveLog: () => StartLiveTailResponseFilterSensitiveLog,
  StartLiveTailResponseStream: () => StartLiveTailResponseStream,
  StartLiveTailResponseStreamFilterSensitiveLog: () => StartLiveTailResponseStreamFilterSensitiveLog,
  StartQueryCommand: () => StartQueryCommand,
  State: () => State,
  StopQueryCommand: () => StopQueryCommand,
  SuppressionState: () => SuppressionState,
  SuppressionType: () => SuppressionType,
  SuppressionUnit: () => SuppressionUnit,
  TagLogGroupCommand: () => TagLogGroupCommand,
  TagResourceCommand: () => TagResourceCommand,
  TestMetricFilterCommand: () => TestMetricFilterCommand,
  ThrottlingException: () => ThrottlingException,
  TooManyTagsException: () => TooManyTagsException,
  UnrecognizedClientException: () => UnrecognizedClientException,
  UntagLogGroupCommand: () => UntagLogGroupCommand,
  UntagResourceCommand: () => UntagResourceCommand,
  UpdateAnomalyCommand: () => UpdateAnomalyCommand,
  UpdateLogAnomalyDetectorCommand: () => UpdateLogAnomalyDetectorCommand,
  ValidationException: () => ValidationException,
  __Client: () => import_smithy_client.Client,
  paginateDescribeDeliveries: () => paginateDescribeDeliveries,
  paginateDescribeDeliveryDestinations: () => paginateDescribeDeliveryDestinations,
  paginateDescribeDeliverySources: () => paginateDescribeDeliverySources,
  paginateDescribeDestinations: () => paginateDescribeDestinations,
  paginateDescribeLogGroups: () => paginateDescribeLogGroups,
  paginateDescribeLogStreams: () => paginateDescribeLogStreams,
  paginateDescribeMetricFilters: () => paginateDescribeMetricFilters,
  paginateDescribeSubscriptionFilters: () => paginateDescribeSubscriptionFilters,
  paginateFilterLogEvents: () => paginateFilterLogEvents,
  paginateGetLogEvents: () => paginateGetLogEvents,
  paginateListAnomalies: () => paginateListAnomalies,
  paginateListLogAnomalyDetectors: () => paginateListLogAnomalyDetectors
});
module.exports = __toCommonJS(src_exports);

// src/CloudWatchLogsClient.ts
var import_middleware_host_header = require("@aws-sdk/middleware-host-header");
var import_middleware_logger = require("@aws-sdk/middleware-logger");
var import_middleware_recursion_detection = require("@aws-sdk/middleware-recursion-detection");
var import_middleware_user_agent = require("@aws-sdk/middleware-user-agent");
var import_config_resolver = require("@smithy/config-resolver");
var import_core = require("@smithy/core");
var import_eventstream_serde_config_resolver = require("@smithy/eventstream-serde-config-resolver");
var import_middleware_content_length = require("@smithy/middleware-content-length");
var import_middleware_endpoint = require("@smithy/middleware-endpoint");
var import_middleware_retry = require("@smithy/middleware-retry");

var import_httpAuthSchemeProvider = require("./auth/httpAuthSchemeProvider");

// src/endpoint/EndpointParameters.ts
var resolveClientEndpointParameters = /* @__PURE__ */ __name((options) => {
  return {
    ...options,
    useDualstackEndpoint: options.useDualstackEndpoint ?? false,
    useFipsEndpoint: options.useFipsEndpoint ?? false,
    defaultSigningName: "logs"
  };
}, "resolveClientEndpointParameters");
var commonParams = {
  UseFIPS: { type: "builtInParams", name: "useFipsEndpoint" },
  Endpoint: { type: "builtInParams", name: "endpoint" },
  Region: { type: "builtInParams", name: "region" },
  UseDualStack: { type: "builtInParams", name: "useDualstackEndpoint" }
};

// src/CloudWatchLogsClient.ts
var import_runtimeConfig = require("././runtimeConfig");

// src/runtimeExtensions.ts
var import_region_config_resolver = require("@aws-sdk/region-config-resolver");
var import_protocol_http = require("@smithy/protocol-http");
var import_smithy_client = require("@smithy/smithy-client");

// src/auth/httpAuthExtensionConfiguration.ts
var getHttpAuthExtensionConfiguration = /* @__PURE__ */ __name((runtimeConfig) => {
  const _httpAuthSchemes = runtimeConfig.httpAuthSchemes;
  let _httpAuthSchemeProvider = runtimeConfig.httpAuthSchemeProvider;
  let _credentials = runtimeConfig.credentials;
  return {
    setHttpAuthScheme(httpAuthScheme) {
      const index = _httpAuthSchemes.findIndex((scheme) => scheme.schemeId === httpAuthScheme.schemeId);
      if (index === -1) {
        _httpAuthSchemes.push(httpAuthScheme);
      } else {
        _httpAuthSchemes.splice(index, 1, httpAuthScheme);
      }
    },
    httpAuthSchemes() {
      return _httpAuthSchemes;
    },
    setHttpAuthSchemeProvider(httpAuthSchemeProvider) {
      _httpAuthSchemeProvider = httpAuthSchemeProvider;
    },
    httpAuthSchemeProvider() {
      return _httpAuthSchemeProvider;
    },
    setCredentials(credentials) {
      _credentials = credentials;
    },
    credentials() {
      return _credentials;
    }
  };
}, "getHttpAuthExtensionConfiguration");
var resolveHttpAuthRuntimeConfig = /* @__PURE__ */ __name((config) => {
  return {
    httpAuthSchemes: config.httpAuthSchemes(),
    httpAuthSchemeProvider: config.httpAuthSchemeProvider(),
    credentials: config.credentials()
  };
}, "resolveHttpAuthRuntimeConfig");

// src/runtimeExtensions.ts
var asPartial = /* @__PURE__ */ __name((t) => t, "asPartial");
var resolveRuntimeExtensions = /* @__PURE__ */ __name((runtimeConfig, extensions) => {
  const extensionConfiguration = {
    ...asPartial((0, import_region_config_resolver.getAwsRegionExtensionConfiguration)(runtimeConfig)),
    ...asPartial((0, import_smithy_client.getDefaultExtensionConfiguration)(runtimeConfig)),
    ...asPartial((0, import_protocol_http.getHttpHandlerExtensionConfiguration)(runtimeConfig)),
    ...asPartial(getHttpAuthExtensionConfiguration(runtimeConfig))
  };
  extensions.forEach((extension) => extension.configure(extensionConfiguration));
  return {
    ...runtimeConfig,
    ...(0, import_region_config_resolver.resolveAwsRegionExtensionConfiguration)(extensionConfiguration),
    ...(0, import_smithy_client.resolveDefaultRuntimeConfig)(extensionConfiguration),
    ...(0, import_protocol_http.resolveHttpHandlerRuntimeConfig)(extensionConfiguration),
    ...resolveHttpAuthRuntimeConfig(extensionConfiguration)
  };
}, "resolveRuntimeExtensions");

// src/CloudWatchLogsClient.ts
var _CloudWatchLogsClient = class _CloudWatchLogsClient extends import_smithy_client.Client {
  constructor(...[configuration]) {
    const _config_0 = (0, import_runtimeConfig.getRuntimeConfig)(configuration || {});
    const _config_1 = resolveClientEndpointParameters(_config_0);
    const _config_2 = (0, import_middleware_user_agent.resolveUserAgentConfig)(_config_1);
    const _config_3 = (0, import_middleware_retry.resolveRetryConfig)(_config_2);
    const _config_4 = (0, import_config_resolver.resolveRegionConfig)(_config_3);
    const _config_5 = (0, import_middleware_host_header.resolveHostHeaderConfig)(_config_4);
    const _config_6 = (0, import_middleware_endpoint.resolveEndpointConfig)(_config_5);
    const _config_7 = (0, import_eventstream_serde_config_resolver.resolveEventStreamSerdeConfig)(_config_6);
    const _config_8 = (0, import_httpAuthSchemeProvider.resolveHttpAuthSchemeConfig)(_config_7);
    const _config_9 = resolveRuntimeExtensions(_config_8, (configuration == null ? void 0 : configuration.extensions) || []);
    super(_config_9);
    this.config = _config_9;
    this.middlewareStack.use((0, import_middleware_user_agent.getUserAgentPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_retry.getRetryPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_content_length.getContentLengthPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_host_header.getHostHeaderPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_logger.getLoggerPlugin)(this.config));
    this.middlewareStack.use((0, import_middleware_recursion_detection.getRecursionDetectionPlugin)(this.config));
    this.middlewareStack.use(
      (0, import_core.getHttpAuthSchemeEndpointRuleSetPlugin)(this.config, {
        httpAuthSchemeParametersProvider: import_httpAuthSchemeProvider.defaultCloudWatchLogsHttpAuthSchemeParametersProvider,
        identityProviderConfigProvider: async (config) => new import_core.DefaultIdentityProviderConfig({
          "aws.auth#sigv4": config.credentials
        })
      })
    );
    this.middlewareStack.use((0, import_core.getHttpSigningPlugin)(this.config));
  }
  /**
   * Destroy underlying resources, like sockets. It's usually not necessary to do this.
   * However in Node.js, it's best to explicitly shut down the client's agent when it is no longer needed.
   * Otherwise, sockets might stay open for quite a long time before the server terminates them.
   */
  destroy() {
    super.destroy();
  }
};
__name(_CloudWatchLogsClient, "CloudWatchLogsClient");
var CloudWatchLogsClient = _CloudWatchLogsClient;

// src/CloudWatchLogs.ts


// src/commands/AssociateKmsKeyCommand.ts

var import_middleware_serde = require("@smithy/middleware-serde");


// src/protocols/Aws_json1_1.ts
var import_core2 = require("@aws-sdk/core");


var import_uuid = require("uuid");

// src/models/CloudWatchLogsServiceException.ts

var _CloudWatchLogsServiceException = class _CloudWatchLogsServiceException extends import_smithy_client.ServiceException {
  /**
   * @internal
   */
  constructor(options) {
    super(options);
    Object.setPrototypeOf(this, _CloudWatchLogsServiceException.prototype);
  }
};
__name(_CloudWatchLogsServiceException, "CloudWatchLogsServiceException");
var CloudWatchLogsServiceException = _CloudWatchLogsServiceException;

// src/models/models_0.ts
var _AccessDeniedException = class _AccessDeniedException extends CloudWatchLogsServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "AccessDeniedException",
      $fault: "client",
      ...opts
    });
    this.name = "AccessDeniedException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _AccessDeniedException.prototype);
  }
};
__name(_AccessDeniedException, "AccessDeniedException");
var AccessDeniedException = _AccessDeniedException;
var PolicyType = {
  DATA_PROTECTION_POLICY: "DATA_PROTECTION_POLICY",
  SUBSCRIPTION_FILTER_POLICY: "SUBSCRIPTION_FILTER_POLICY"
};
var Scope = {
  ALL: "ALL"
};
var State = {
  Active: "Active",
  Baseline: "Baseline",
  Suppressed: "Suppressed"
};
var AnomalyDetectorStatus = {
  ANALYZING: "ANALYZING",
  DELETED: "DELETED",
  FAILED: "FAILED",
  INITIALIZING: "INITIALIZING",
  PAUSED: "PAUSED",
  TRAINING: "TRAINING"
};
var EvaluationFrequency = {
  FIFTEEN_MIN: "FIFTEEN_MIN",
  FIVE_MIN: "FIVE_MIN",
  ONE_HOUR: "ONE_HOUR",
  ONE_MIN: "ONE_MIN",
  TEN_MIN: "TEN_MIN",
  THIRTY_MIN: "THIRTY_MIN"
};
var _InvalidParameterException = class _InvalidParameterException extends CloudWatchLogsServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidParameterException",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidParameterException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidParameterException.prototype);
  }
};
__name(_InvalidParameterException, "InvalidParameterException");
var InvalidParameterException = _InvalidParameterException;
var _OperationAbortedException = class _OperationAbortedException extends CloudWatchLogsServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "OperationAbortedException",
      $fault: "client",
      ...opts
    });
    this.name = "OperationAbortedException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _OperationAbortedException.prototype);
  }
};
__name(_OperationAbortedException, "OperationAbortedException");
var OperationAbortedException = _OperationAbortedException;
var _ResourceNotFoundException = class _ResourceNotFoundException extends CloudWatchLogsServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ResourceNotFoundException",
      $fault: "client",
      ...opts
    });
    this.name = "ResourceNotFoundException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ResourceNotFoundException.prototype);
  }
};
__name(_ResourceNotFoundException, "ResourceNotFoundException");
var ResourceNotFoundException = _ResourceNotFoundException;
var _ServiceUnavailableException = class _ServiceUnavailableException extends CloudWatchLogsServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ServiceUnavailableException",
      $fault: "server",
      ...opts
    });
    this.name = "ServiceUnavailableException";
    this.$fault = "server";
    Object.setPrototypeOf(this, _ServiceUnavailableException.prototype);
  }
};
__name(_ServiceUnavailableException, "ServiceUnavailableException");
var ServiceUnavailableException = _ServiceUnavailableException;
var _InvalidOperationException = class _InvalidOperationException extends CloudWatchLogsServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidOperationException",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidOperationException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidOperationException.prototype);
  }
};
__name(_InvalidOperationException, "InvalidOperationException");
var InvalidOperationException = _InvalidOperationException;
var _ConflictException = class _ConflictException extends CloudWatchLogsServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ConflictException",
      $fault: "client",
      ...opts
    });
    this.name = "ConflictException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ConflictException.prototype);
  }
};
__name(_ConflictException, "ConflictException");
var ConflictException = _ConflictException;
var DeliveryDestinationType = {
  CWL: "CWL",
  FH: "FH",
  S3: "S3"
};
var _ServiceQuotaExceededException = class _ServiceQuotaExceededException extends CloudWatchLogsServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ServiceQuotaExceededException",
      $fault: "client",
      ...opts
    });
    this.name = "ServiceQuotaExceededException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ServiceQuotaExceededException.prototype);
  }
};
__name(_ServiceQuotaExceededException, "ServiceQuotaExceededException");
var ServiceQuotaExceededException = _ServiceQuotaExceededException;
var _ThrottlingException = class _ThrottlingException extends CloudWatchLogsServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ThrottlingException",
      $fault: "client",
      ...opts
    });
    this.name = "ThrottlingException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ThrottlingException.prototype);
  }
};
__name(_ThrottlingException, "ThrottlingException");
var ThrottlingException = _ThrottlingException;
var _ValidationException = class _ValidationException extends CloudWatchLogsServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ValidationException",
      $fault: "client",
      ...opts
    });
    this.name = "ValidationException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ValidationException.prototype);
  }
};
__name(_ValidationException, "ValidationException");
var ValidationException = _ValidationException;
var _LimitExceededException = class _LimitExceededException extends CloudWatchLogsServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "LimitExceededException",
      $fault: "client",
      ...opts
    });
    this.name = "LimitExceededException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _LimitExceededException.prototype);
  }
};
__name(_LimitExceededException, "LimitExceededException");
var LimitExceededException = _LimitExceededException;
var _ResourceAlreadyExistsException = class _ResourceAlreadyExistsException extends CloudWatchLogsServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "ResourceAlreadyExistsException",
      $fault: "client",
      ...opts
    });
    this.name = "ResourceAlreadyExistsException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _ResourceAlreadyExistsException.prototype);
  }
};
__name(_ResourceAlreadyExistsException, "ResourceAlreadyExistsException");
var ResourceAlreadyExistsException = _ResourceAlreadyExistsException;
var LogGroupClass = {
  INFREQUENT_ACCESS: "INFREQUENT_ACCESS",
  STANDARD: "STANDARD"
};
var _DataAlreadyAcceptedException = class _DataAlreadyAcceptedException extends CloudWatchLogsServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "DataAlreadyAcceptedException",
      $fault: "client",
      ...opts
    });
    this.name = "DataAlreadyAcceptedException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _DataAlreadyAcceptedException.prototype);
    this.expectedSequenceToken = opts.expectedSequenceToken;
  }
};
__name(_DataAlreadyAcceptedException, "DataAlreadyAcceptedException");
var DataAlreadyAcceptedException = _DataAlreadyAcceptedException;
var DataProtectionStatus = {
  ACTIVATED: "ACTIVATED",
  ARCHIVED: "ARCHIVED",
  DELETED: "DELETED",
  DISABLED: "DISABLED"
};
var OutputFormat = {
  JSON: "json",
  PARQUET: "parquet",
  PLAIN: "plain",
  RAW: "raw",
  W3C: "w3c"
};
var ExportTaskStatusCode = {
  CANCELLED: "CANCELLED",
  COMPLETED: "COMPLETED",
  FAILED: "FAILED",
  PENDING: "PENDING",
  PENDING_CANCEL: "PENDING_CANCEL",
  RUNNING: "RUNNING"
};
var InheritedProperty = {
  ACCOUNT_DATA_PROTECTION: "ACCOUNT_DATA_PROTECTION"
};
var OrderBy = {
  LastEventTime: "LastEventTime",
  LogStreamName: "LogStreamName"
};
var 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"
};
var QueryStatus = {
  Cancelled: "Cancelled",
  Complete: "Complete",
  Failed: "Failed",
  Running: "Running",
  Scheduled: "Scheduled",
  Timeout: "Timeout",
  Unknown: "Unknown"
};
var Distribution = {
  ByLogStream: "ByLogStream",
  Random: "Random"
};
var _InvalidSequenceTokenException = class _InvalidSequenceTokenException extends CloudWatchLogsServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "InvalidSequenceTokenException",
      $fault: "client",
      ...opts
    });
    this.name = "InvalidSequenceTokenException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _InvalidSequenceTokenException.prototype);
    this.expectedSequenceToken = opts.expectedSequenceToken;
  }
};
__name(_InvalidSequenceTokenException, "InvalidSequenceTokenException");
var InvalidSequenceTokenException = _InvalidSequenceTokenException;
var SuppressionState = {
  SUPPRESSED: "SUPPRESSED",
  UNSUPPRESSED: "UNSUPPRESSED"
};
var _UnrecognizedClientException = class _UnrecognizedClientException extends CloudWatchLogsServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "UnrecognizedClientException",
      $fault: "client",
      ...opts
    });
    this.name = "UnrecognizedClientException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _UnrecognizedClientException.prototype);
  }
};
__name(_UnrecognizedClientException, "UnrecognizedClientException");
var UnrecognizedClientException = _UnrecognizedClientException;
var _SessionStreamingException = class _SessionStreamingException extends CloudWatchLogsServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "SessionStreamingException",
      $fault: "client",
      ...opts
    });
    this.name = "SessionStreamingException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _SessionStreamingException.prototype);
  }
};
__name(_SessionStreamingException, "SessionStreamingException");
var SessionStreamingException = _SessionStreamingException;
var _SessionTimeoutException = class _SessionTimeoutException extends CloudWatchLogsServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "SessionTimeoutException",
      $fault: "client",
      ...opts
    });
    this.name = "SessionTimeoutException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _SessionTimeoutException.prototype);
  }
};
__name(_SessionTimeoutException, "SessionTimeoutException");
var SessionTimeoutException = _SessionTimeoutException;
var StartLiveTailResponseStream;
((StartLiveTailResponseStream3) => {
  StartLiveTailResponseStream3.visit = /* @__PURE__ */ __name((value, visitor) => {
    if (value.sessionStart !== void 0)
      return visitor.sessionStart(value.sessionStart);
    if (value.sessionUpdate !== void 0)
      return visitor.sessionUpdate(value.sessionUpdate);
    if (value.SessionTimeoutException !== void 0)
      return visitor.SessionTimeoutException(value.SessionTimeoutException);
    if (value.SessionStreamingException !== void 0)
      return visitor.SessionStreamingException(value.SessionStreamingException);
    return visitor._(value.$unknown[0], value.$unknown[1]);
  }, "visit");
})(StartLiveTailResponseStream || (StartLiveTailResponseStream = {}));
var _MalformedQueryException = class _MalformedQueryException extends CloudWatchLogsServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "MalformedQueryException",
      $fault: "client",
      ...opts
    });
    this.name = "MalformedQueryException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _MalformedQueryException.prototype);
    this.queryCompileError = opts.queryCompileError;
  }
};
__name(_MalformedQueryException, "MalformedQueryException");
var MalformedQueryException = _MalformedQueryException;
var _TooManyTagsException = class _TooManyTagsException extends CloudWatchLogsServiceException {
  /**
   * @internal
   */
  constructor(opts) {
    super({
      name: "TooManyTagsException",
      $fault: "client",
      ...opts
    });
    this.name = "TooManyTagsException";
    this.$fault = "client";
    Object.setPrototypeOf(this, _TooManyTagsException.prototype);
    this.resourceName = opts.resourceName;
  }
};
__name(_TooManyTagsException, "TooManyTagsException");
var TooManyTagsException = _TooManyTagsException;
var SuppressionUnit = {
  HOURS: "HOURS",
  MINUTES: "MINUTES",
  SECONDS: "SECONDS"
};
var SuppressionType = {
  INFINITE: "INFINITE",
  LIMITED: "LIMITED"
};
var StartLiveTailResponseStreamFilterSensitiveLog = /* @__PURE__ */ __name((obj) => {
  if (obj.sessionStart !== void 0)
    return { sessionStart: obj.sessionStart };
  if (obj.sessionUpdate !== void 0)
    return { sessionUpdate: obj.sessionUpdate };
  if (obj.SessionTimeoutException !== void 0)
    return { SessionTimeoutException: obj.SessionTimeoutException };
  if (obj.SessionStreamingException !== void 0)
    return { SessionStreamingException: obj.SessionStreamingException };
  if (obj.$unknown !== void 0)
    return { [obj.$unknown[0]]: "UNKNOWN" };
}, "StartLiveTailResponseStreamFilterSensitiveLog");
var StartLiveTailResponseFilterSensitiveLog = /* @__PURE__ */ __name((obj) => ({
  ...obj,
  ...obj.responseStream && { responseStream: "STREAMING_CONTENT" }
}), "StartLiveTailResponseFilterSensitiveLog");

// src/protocols/Aws_json1_1.ts
var se_AssociateKmsKeyCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("AssociateKmsKey");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_AssociateKmsKeyCommand");
var se_CancelExportTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("CancelExportTask");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_CancelExportTaskCommand");
var se_CreateDeliveryCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("CreateDelivery");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_CreateDeliveryCommand");
var se_CreateExportTaskCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("CreateExportTask");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_CreateExportTaskCommand");
var se_CreateLogAnomalyDetectorCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("CreateLogAnomalyDetector");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_CreateLogAnomalyDetectorCommand");
var se_CreateLogGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("CreateLogGroup");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_CreateLogGroupCommand");
var se_CreateLogStreamCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("CreateLogStream");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_CreateLogStreamCommand");
var se_DeleteAccountPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteAccountPolicy");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteAccountPolicyCommand");
var se_DeleteDataProtectionPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteDataProtectionPolicy");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteDataProtectionPolicyCommand");
var se_DeleteDeliveryCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteDelivery");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteDeliveryCommand");
var se_DeleteDeliveryDestinationCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteDeliveryDestination");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteDeliveryDestinationCommand");
var se_DeleteDeliveryDestinationPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteDeliveryDestinationPolicy");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteDeliveryDestinationPolicyCommand");
var se_DeleteDeliverySourceCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteDeliverySource");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteDeliverySourceCommand");
var se_DeleteDestinationCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteDestination");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteDestinationCommand");
var se_DeleteLogAnomalyDetectorCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteLogAnomalyDetector");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteLogAnomalyDetectorCommand");
var se_DeleteLogGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteLogGroup");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteLogGroupCommand");
var se_DeleteLogStreamCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteLogStream");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteLogStreamCommand");
var se_DeleteMetricFilterCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteMetricFilter");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteMetricFilterCommand");
var se_DeleteQueryDefinitionCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteQueryDefinition");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteQueryDefinitionCommand");
var se_DeleteResourcePolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteResourcePolicy");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteResourcePolicyCommand");
var se_DeleteRetentionPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteRetentionPolicy");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteRetentionPolicyCommand");
var se_DeleteSubscriptionFilterCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DeleteSubscriptionFilter");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DeleteSubscriptionFilterCommand");
var se_DescribeAccountPoliciesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeAccountPolicies");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeAccountPoliciesCommand");
var se_DescribeDeliveriesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeDeliveries");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeDeliveriesCommand");
var se_DescribeDeliveryDestinationsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeDeliveryDestinations");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeDeliveryDestinationsCommand");
var se_DescribeDeliverySourcesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeDeliverySources");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeDeliverySourcesCommand");
var se_DescribeDestinationsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeDestinations");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeDestinationsCommand");
var se_DescribeExportTasksCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeExportTasks");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeExportTasksCommand");
var se_DescribeLogGroupsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeLogGroups");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeLogGroupsCommand");
var se_DescribeLogStreamsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeLogStreams");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeLogStreamsCommand");
var se_DescribeMetricFiltersCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeMetricFilters");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeMetricFiltersCommand");
var se_DescribeQueriesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeQueries");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeQueriesCommand");
var se_DescribeQueryDefinitionsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeQueryDefinitions");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeQueryDefinitionsCommand");
var se_DescribeResourcePoliciesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeResourcePolicies");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeResourcePoliciesCommand");
var se_DescribeSubscriptionFiltersCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DescribeSubscriptionFilters");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DescribeSubscriptionFiltersCommand");
var se_DisassociateKmsKeyCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("DisassociateKmsKey");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_DisassociateKmsKeyCommand");
var se_FilterLogEventsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("FilterLogEvents");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_FilterLogEventsCommand");
var se_GetDataProtectionPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("GetDataProtectionPolicy");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_GetDataProtectionPolicyCommand");
var se_GetDeliveryCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("GetDelivery");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_GetDeliveryCommand");
var se_GetDeliveryDestinationCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("GetDeliveryDestination");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_GetDeliveryDestinationCommand");
var se_GetDeliveryDestinationPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("GetDeliveryDestinationPolicy");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_GetDeliveryDestinationPolicyCommand");
var se_GetDeliverySourceCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("GetDeliverySource");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_GetDeliverySourceCommand");
var se_GetLogAnomalyDetectorCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("GetLogAnomalyDetector");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_GetLogAnomalyDetectorCommand");
var se_GetLogEventsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("GetLogEvents");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_GetLogEventsCommand");
var se_GetLogGroupFieldsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("GetLogGroupFields");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_GetLogGroupFieldsCommand");
var se_GetLogRecordCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("GetLogRecord");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_GetLogRecordCommand");
var se_GetQueryResultsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("GetQueryResults");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_GetQueryResultsCommand");
var se_ListAnomaliesCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListAnomalies");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListAnomaliesCommand");
var se_ListLogAnomalyDetectorsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListLogAnomalyDetectors");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListLogAnomalyDetectorsCommand");
var se_ListTagsForResourceCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListTagsForResource");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListTagsForResourceCommand");
var se_ListTagsLogGroupCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("ListTagsLogGroup");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_ListTagsLogGroupCommand");
var se_PutAccountPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("PutAccountPolicy");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_PutAccountPolicyCommand");
var se_PutDataProtectionPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("PutDataProtectionPolicy");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_PutDataProtectionPolicyCommand");
var se_PutDeliveryDestinationCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("PutDeliveryDestination");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_PutDeliveryDestinationCommand");
var se_PutDeliveryDestinationPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("PutDeliveryDestinationPolicy");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_PutDeliveryDestinationPolicyCommand");
var se_PutDeliverySourceCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("PutDeliverySource");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_PutDeliverySourceCommand");
var se_PutDestinationCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("PutDestination");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_PutDestinationCommand");
var se_PutDestinationPolicyCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("PutDestinationPolicy");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_PutDestinationPolicyCommand");
var se_PutLogEventsCommand = /* @__PURE__ */ __name(async (input, context) => {
  const headers = sharedHeaders("PutLogEvents");
  let body;
  body = JSON.stringify((0, import_smithy_client._json)(input));
  return buildHttpRpcRequest(context, headers, "/", void 0, body);
}, "se_PutLogEventsCommand");
var se_PutMetr