class Aws::IoTAnalytics::Client

def batch_put_message(params = {}, options = {})
  req = build_request(:batch_put_message, params)
  req.send_request(options)
end

def build_request(operation_name, params = {})
  handlers = @handlers.for(operation_name)
  tracer = config.telemetry_provider.tracer_provider.tracer(
    Aws::Telemetry.module_to_tracer_name('Aws::IoTAnalytics')
  )
  context = Seahorse::Client::RequestContext.new(
    operation_name: operation_name,
    operation: config.api.operation(operation_name),
    client: self,
    params: params,
    config: config,
    tracer: tracer
  )
  context[:gem_name] = 'aws-sdk-iotanalytics'
  context[:gem_version] = '1.80.0'
  Seahorse::Client::Request.new(handlers, context)
end

def cancel_pipeline_reprocessing(params = {}, options = {})
  req = build_request(:cancel_pipeline_reprocessing, params)
  req.send_request(options)
end

def create_channel(params = {}, options = {})
  req = build_request(:create_channel, params)
  req.send_request(options)
end

def create_dataset(params = {}, options = {})
  req = build_request(:create_dataset, params)
  req.send_request(options)
end

def create_dataset_content(params = {}, options = {})
  req = build_request(:create_dataset_content, params)
  req.send_request(options)
end

def create_datastore(params = {}, options = {})
  req = build_request(:create_datastore, params)
  req.send_request(options)
end

def create_pipeline(params = {}, options = {})
  req = build_request(:create_pipeline, params)
  req.send_request(options)
end

def delete_channel(params = {}, options = {})
  req = build_request(:delete_channel, params)
  req.send_request(options)
end

def delete_dataset(params = {}, options = {})
  req = build_request(:delete_dataset, params)
  req.send_request(options)
end

def delete_dataset_content(params = {}, options = {})
  req = build_request(:delete_dataset_content, params)
  req.send_request(options)
end

def delete_datastore(params = {}, options = {})
  req = build_request(:delete_datastore, params)
  req.send_request(options)
end

def delete_pipeline(params = {}, options = {})
  req = build_request(:delete_pipeline, params)
  req.send_request(options)
end

def describe_channel(params = {}, options = {})
  req = build_request(:describe_channel, params)
  req.send_request(options)
end

def describe_dataset(params = {}, options = {})
  req = build_request(:describe_dataset, params)
  req.send_request(options)
end

def describe_datastore(params = {}, options = {})
  req = build_request(:describe_datastore, params)
  req.send_request(options)
end

def describe_logging_options(params = {}, options = {})
  req = build_request(:describe_logging_options, params)
  req.send_request(options)
end

def describe_pipeline(params = {}, options = {})
  req = build_request(:describe_pipeline, params)
  req.send_request(options)
end

def errors_module
  Errors
end

def get_dataset_content(params = {}, options = {})
  req = build_request(:get_dataset_content, params)
  req.send_request(options)
end

def initialize(*args)
  super
end

def list_channels(params = {}, options = {})
  req = build_request(:list_channels, params)
  req.send_request(options)
end

def list_dataset_contents(params = {}, options = {})
  req = build_request(:list_dataset_contents, params)
  req.send_request(options)
end

def list_datasets(params = {}, options = {})
  req = build_request(:list_datasets, params)
  req.send_request(options)
end

def list_datastores(params = {}, options = {})
  req = build_request(:list_datastores, params)
  req.send_request(options)
end

def list_pipelines(params = {}, options = {})
  req = build_request(:list_pipelines, params)
  req.send_request(options)
end

def list_tags_for_resource(params = {}, options = {})
  req = build_request(:list_tags_for_resource, params)
  req.send_request(options)
end

def put_logging_options(params = {}, options = {})
  req = build_request(:put_logging_options, params)
  req.send_request(options)
end

def run_pipeline_activity(params = {}, options = {})
  req = build_request(:run_pipeline_activity, params)
  req.send_request(options)
end

def sample_channel_data(params = {}, options = {})
  req = build_request(:sample_channel_data, params)
  req.send_request(options)
end

def start_pipeline_reprocessing(params = {}, options = {})
  req = build_request(:start_pipeline_reprocessing, params)
  req.send_request(options)
end

def tag_resource(params = {}, options = {})
  req = build_request(:tag_resource, params)
  req.send_request(options)
end

def untag_resource(params = {}, options = {})
  req = build_request(:untag_resource, params)
  req.send_request(options)
end

def update_channel(params = {}, options = {})
  req = build_request(:update_channel, params)
  req.send_request(options)
end

def update_dataset(params = {}, options = {})
  req = build_request(:update_dataset, params)
  req.send_request(options)
end

def update_datastore(params = {}, options = {})
  req = build_request(:update_datastore, params)
  req.send_request(options)
end

def update_pipeline(params = {}, options = {})
  req = build_request(:update_pipeline, params)
  req.send_request(options)
end

def waiter_names
  []
end