class Aws::ECR::Client

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

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

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

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

def build_request(operation_name, params = {})
  handlers = @handlers.for(operation_name)
  context = Seahorse::Client::RequestContext.new(
    operation_name: operation_name,
    operation: config.api.operation(operation_name),
    client: self,
    params: params,
    config: config)
  context[:gem_name] = 'aws-sdk-ecr'
  context[:gem_version] = '1.60.0'
  Seahorse::Client::Request.new(handlers, context)
end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

def errors_module
  Errors
end

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

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

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

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

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

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

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

def initialize(*args)
  super
end

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

def list_images(params = {}, options = {})
  req = build_request(:list_images, 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_image(params = {}, options = {})
  req = build_request(:put_image, params)
  req.send_request(options)
end

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

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

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

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

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

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

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

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

def start_lifecycle_policy_preview(params = {}, options = {})
  req = build_request(:start_lifecycle_policy_preview, 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 upload_layer_part(params = {}, options = {})
  req = build_request(:upload_layer_part, params)
  req.send_request(options)
end

def wait_until(waiter_name, params = {}, options = {})
  w = waiter(waiter_name, options)
  yield(w.waiter) if block_given? # deprecated
  w.wait(params)
end

def waiter(waiter_name, options = {})
  waiter_class = waiters[waiter_name]
  if waiter_class
    waiter_class.new(options.merge(client: self))
  else
    raise Aws::Waiters::Errors::NoSuchWaiterError.new(waiter_name, waiters.keys)
  end
end

def waiter_names
  waiters.keys
end

def waiters
  {
    image_scan_complete: Waiters::ImageScanComplete,
    lifecycle_policy_preview_complete: Waiters::LifecyclePolicyPreviewComplete
  }
end