Module: BrightData::LinkedIn::Types

Defined in:
lib/brightdata/linkedin/types/profile.rb,
lib/brightdata/linkedin/types/job.rb,
lib/brightdata/linkedin/types/post.rb,
lib/brightdata/linkedin/types/company.rb,
lib/brightdata/linkedin/types/job_url_input.rb,
lib/brightdata/linkedin/types/post_url_input.rb,
lib/brightdata/linkedin/types/company_url_input.rb,
lib/brightdata/linkedin/types/job_keyword_input.rb,
lib/brightdata/linkedin/types/profile_url_input.rb,
lib/brightdata/linkedin/types/discovered_profile.rb,
lib/brightdata/linkedin/types/people_discover_input.rb,
lib/brightdata/linkedin/types/post_company_url_input.rb,
lib/brightdata/linkedin/types/post_profile_url_input.rb

Overview

Typed input and output value objects for LinkedIn endpoints.

Defined Under Namespace

Classes: Company, CompanyUrlInput, DiscoveredProfile, Job, JobKeywordInput, JobUrlInput, PeopleDiscoverInput, Post, PostCompanyUrlInput, PostProfileUrlInput, PostUrlInput, Profile, ProfileUrlInput

Instance Attribute Summary collapse

Instance Attribute Details

#about ⇒ String? (readonly)

Returns about text.

Returns:

  • (String, nil) —

    about text



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/brightdata/linkedin/types/profile.rb', line 46

Profile = Data.define(
  :id, :name, :city, :country_code, :position, :about,
  :current_company, :experience, :education, :connections, :followers,
  :linkedin_id, :linkedin_num_id, :avatar, :banner_image,
  :people_also_viewed, :input_url, :raw
) do
  # Build a profile from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Profile]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      city: hash[:city],
      country_code: hash[:country_code],
      position: hash[:position],
      about: hash[:about],
      current_company: hash[:current_company],
      experience: hash[:experience],
      education: hash[:education],
      connections: hash[:connections],
      followers: hash[:followers],
      linkedin_id: hash[:linkedin_id],
      linkedin_num_id: hash[:linkedin_num_id],
      avatar: hash[:avatar],
      banner_image: hash[:banner_image],
      people_also_viewed: hash[:people_also_viewed],
      input_url: hash[:input_url],
      raw: hash
    )
  end
end

#affiliated ⇒ Array<Hash>? (readonly)

Returns affiliated companies.

Returns:

  • (Array<Hash>, nil) —

    affiliated companies



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/brightdata/linkedin/types/company.rb', line 53

Company = Data.define(
  :id, :name, :country_code, :locations, :followers,
  :employees_in_linkedin, :company_size, :industries, :specialties,
  :website, :founded, :company_id, :employees, :similar, :updates,
  :logo, :image, :headquarters, :funding, :investors, :affiliated, :raw
) do
  # Build a company from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Company]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      country_code: hash[:country_code],
      locations: hash[:locations],
      followers: hash[:followers],
      employees_in_linkedin: hash[:employees_in_linkedin],
      company_size: hash[:company_size],
      industries: hash[:industries],
      specialties: hash[:specialties],
      website: hash[:website],
      founded: hash[:founded],
      company_id: hash[:company_id],
      employees: hash[:employees],
      similar: hash[:similar],
      updates: hash[:updates],
      logo: hash[:logo],
      image: hash[:image],
      headquarters: hash[:headquarters],
      funding: hash[:funding],
      investors: hash[:investors],
      affiliated: hash[:affiliated],
      raw: hash
    )
  end
end

#avatar ⇒ String? (readonly)

Returns avatar URL.

Returns:

  • (String, nil) —

    avatar URL



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/brightdata/linkedin/types/profile.rb', line 46

Profile = Data.define(
  :id, :name, :city, :country_code, :position, :about,
  :current_company, :experience, :education, :connections, :followers,
  :linkedin_id, :linkedin_num_id, :avatar, :banner_image,
  :people_also_viewed, :input_url, :raw
) do
  # Build a profile from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Profile]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      city: hash[:city],
      country_code: hash[:country_code],
      position: hash[:position],
      about: hash[:about],
      current_company: hash[:current_company],
      experience: hash[:experience],
      education: hash[:education],
      connections: hash[:connections],
      followers: hash[:followers],
      linkedin_id: hash[:linkedin_id],
      linkedin_num_id: hash[:linkedin_num_id],
      avatar: hash[:avatar],
      banner_image: hash[:banner_image],
      people_also_viewed: hash[:people_also_viewed],
      input_url: hash[:input_url],
      raw: hash
    )
  end
end

Returns banner image URL.

Returns:

  • (String, nil) —

    banner image URL



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/brightdata/linkedin/types/profile.rb', line 46

Profile = Data.define(
  :id, :name, :city, :country_code, :position, :about,
  :current_company, :experience, :education, :connections, :followers,
  :linkedin_id, :linkedin_num_id, :avatar, :banner_image,
  :people_also_viewed, :input_url, :raw
) do
  # Build a profile from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Profile]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      city: hash[:city],
      country_code: hash[:country_code],
      position: hash[:position],
      about: hash[:about],
      current_company: hash[:current_company],
      experience: hash[:experience],
      education: hash[:education],
      connections: hash[:connections],
      followers: hash[:followers],
      linkedin_id: hash[:linkedin_id],
      linkedin_num_id: hash[:linkedin_num_id],
      avatar: hash[:avatar],
      banner_image: hash[:banner_image],
      people_also_viewed: hash[:people_also_viewed],
      input_url: hash[:input_url],
      raw: hash
    )
  end
end

#city ⇒ String? (readonly)

Returns profile city.

Returns:

  • (String, nil) —

    profile city



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/brightdata/linkedin/types/profile.rb', line 46

Profile = Data.define(
  :id, :name, :city, :country_code, :position, :about,
  :current_company, :experience, :education, :connections, :followers,
  :linkedin_id, :linkedin_num_id, :avatar, :banner_image,
  :people_also_viewed, :input_url, :raw
) do
  # Build a profile from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Profile]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      city: hash[:city],
      country_code: hash[:country_code],
      position: hash[:position],
      about: hash[:about],
      current_company: hash[:current_company],
      experience: hash[:experience],
      education: hash[:education],
      connections: hash[:connections],
      followers: hash[:followers],
      linkedin_id: hash[:linkedin_id],
      linkedin_num_id: hash[:linkedin_num_id],
      avatar: hash[:avatar],
      banner_image: hash[:banner_image],
      people_also_viewed: hash[:people_also_viewed],
      input_url: hash[:input_url],
      raw: hash
    )
  end
end

#comments_count ⇒ Integer, ... (readonly)

Returns comment count.

Returns:

  • (Integer, String, nil) —

    comment count



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/brightdata/linkedin/types/post.rb', line 37

Post = Data.define(
  :id, :user_id, :headline, :post_text, :date_posted, :hashtags,
  :embedded_links, :images, :videos, :likes, :comments_count,
  :repost, :original_post, :raw
) do
  # Build a post from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Post]
  def self.from_api(hash) # rubocop:disable Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      user_id: hash[:user_id],
      headline: hash[:headline],
      post_text: hash[:post_text],
      date_posted: hash[:date_posted],
      hashtags: hash[:hashtags],
      embedded_links: hash[:embedded_links],
      images: hash[:images],
      videos: hash[:videos],
      likes: hash[:likes],
      comments_count: hash[:comments_count],
      repost: hash[:repost],
      original_post: hash[:original_post],
      raw: hash
    )
  end
end

#company ⇒ String? (readonly)

Returns company filter.

Returns:

  • (String, nil) —

    company filter



30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/brightdata/linkedin/types/job_keyword_input.rb', line 30

JobKeywordInput = Data.define(
  :location, :keyword, :country, :time_range, :job_type,
  :experience_level, :remote, :company, :selective_search,
  :jobs_to_not_include, :location_radius
) do
  # Serialize for Bright Data, omitting nil values.
  #
  # @return [Hash] API input payload
  def to_api_hash
    to_h.compact
  end
end

#company_id ⇒ String? (readonly)

Returns LinkedIn company ID.

Returns:

  • (String, nil) —

    LinkedIn company ID



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/brightdata/linkedin/types/company.rb', line 53

Company = Data.define(
  :id, :name, :country_code, :locations, :followers,
  :employees_in_linkedin, :company_size, :industries, :specialties,
  :website, :founded, :company_id, :employees, :similar, :updates,
  :logo, :image, :headquarters, :funding, :investors, :affiliated, :raw
) do
  # Build a company from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Company]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      country_code: hash[:country_code],
      locations: hash[:locations],
      followers: hash[:followers],
      employees_in_linkedin: hash[:employees_in_linkedin],
      company_size: hash[:company_size],
      industries: hash[:industries],
      specialties: hash[:specialties],
      website: hash[:website],
      founded: hash[:founded],
      company_id: hash[:company_id],
      employees: hash[:employees],
      similar: hash[:similar],
      updates: hash[:updates],
      logo: hash[:logo],
      image: hash[:image],
      headquarters: hash[:headquarters],
      funding: hash[:funding],
      investors: hash[:investors],
      affiliated: hash[:affiliated],
      raw: hash
    )
  end
end

#company_logo ⇒ String? (readonly)

Returns company logo URL.

Returns:

  • (String, nil) —

    company logo URL



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/brightdata/linkedin/types/job.rb', line 29

Job = Data.define(
  :url, :job_posting_id, :job_title, :company_name, :job_location,
  :job_summary, :job_base_pay_range, :job_posted_time, :company_logo, :raw
) do
  # Build a job from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Job]
  def self.from_api(hash) # rubocop:disable Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      url: hash[:url],
      job_posting_id: hash[:job_posting_id],
      job_title: hash[:job_title],
      company_name: hash[:company_name],
      job_location: hash[:job_location],
      job_summary: hash[:job_summary],
      job_base_pay_range: hash[:job_base_pay_range],
      job_posted_time: hash[:job_posted_time],
      company_logo: hash[:company_logo],
      raw: hash
    )
  end
end

#company_name ⇒ String? (readonly)

Returns company name.

Returns:

  • (String, nil) —

    company name



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/brightdata/linkedin/types/job.rb', line 29

Job = Data.define(
  :url, :job_posting_id, :job_title, :company_name, :job_location,
  :job_summary, :job_base_pay_range, :job_posted_time, :company_logo, :raw
) do
  # Build a job from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Job]
  def self.from_api(hash) # rubocop:disable Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      url: hash[:url],
      job_posting_id: hash[:job_posting_id],
      job_title: hash[:job_title],
      company_name: hash[:company_name],
      job_location: hash[:job_location],
      job_summary: hash[:job_summary],
      job_base_pay_range: hash[:job_base_pay_range],
      job_posted_time: hash[:job_posted_time],
      company_logo: hash[:company_logo],
      raw: hash
    )
  end
end

#company_size ⇒ String? (readonly)

Returns company size.

Returns:

  • (String, nil) —

    company size



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/brightdata/linkedin/types/company.rb', line 53

Company = Data.define(
  :id, :name, :country_code, :locations, :followers,
  :employees_in_linkedin, :company_size, :industries, :specialties,
  :website, :founded, :company_id, :employees, :similar, :updates,
  :logo, :image, :headquarters, :funding, :investors, :affiliated, :raw
) do
  # Build a company from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Company]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      country_code: hash[:country_code],
      locations: hash[:locations],
      followers: hash[:followers],
      employees_in_linkedin: hash[:employees_in_linkedin],
      company_size: hash[:company_size],
      industries: hash[:industries],
      specialties: hash[:specialties],
      website: hash[:website],
      founded: hash[:founded],
      company_id: hash[:company_id],
      employees: hash[:employees],
      similar: hash[:similar],
      updates: hash[:updates],
      logo: hash[:logo],
      image: hash[:image],
      headquarters: hash[:headquarters],
      funding: hash[:funding],
      investors: hash[:investors],
      affiliated: hash[:affiliated],
      raw: hash
    )
  end
end

#connections ⇒ Integer, ... (readonly)

Returns connection count.

Returns:

  • (Integer, String, nil) —

    connection count



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/brightdata/linkedin/types/profile.rb', line 46

Profile = Data.define(
  :id, :name, :city, :country_code, :position, :about,
  :current_company, :experience, :education, :connections, :followers,
  :linkedin_id, :linkedin_num_id, :avatar, :banner_image,
  :people_also_viewed, :input_url, :raw
) do
  # Build a profile from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Profile]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      city: hash[:city],
      country_code: hash[:country_code],
      position: hash[:position],
      about: hash[:about],
      current_company: hash[:current_company],
      experience: hash[:experience],
      education: hash[:education],
      connections: hash[:connections],
      followers: hash[:followers],
      linkedin_id: hash[:linkedin_id],
      linkedin_num_id: hash[:linkedin_num_id],
      avatar: hash[:avatar],
      banner_image: hash[:banner_image],
      people_also_viewed: hash[:people_also_viewed],
      input_url: hash[:input_url],
      raw: hash
    )
  end
end

#country ⇒ String? (readonly)

Returns country code.

Returns:

  • (String, nil) —

    country code



30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/brightdata/linkedin/types/job_keyword_input.rb', line 30

JobKeywordInput = Data.define(
  :location, :keyword, :country, :time_range, :job_type,
  :experience_level, :remote, :company, :selective_search,
  :jobs_to_not_include, :location_radius
) do
  # Serialize for Bright Data, omitting nil values.
  #
  # @return [Hash] API input payload
  def to_api_hash
    to_h.compact
  end
end

#country_code ⇒ String? (readonly)

Returns profile country code.

Returns:

  • (String, nil) —

    profile country code



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/brightdata/linkedin/types/company.rb', line 53

Company = Data.define(
  :id, :name, :country_code, :locations, :followers,
  :employees_in_linkedin, :company_size, :industries, :specialties,
  :website, :founded, :company_id, :employees, :similar, :updates,
  :logo, :image, :headquarters, :funding, :investors, :affiliated, :raw
) do
  # Build a company from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Company]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      country_code: hash[:country_code],
      locations: hash[:locations],
      followers: hash[:followers],
      employees_in_linkedin: hash[:employees_in_linkedin],
      company_size: hash[:company_size],
      industries: hash[:industries],
      specialties: hash[:specialties],
      website: hash[:website],
      founded: hash[:founded],
      company_id: hash[:company_id],
      employees: hash[:employees],
      similar: hash[:similar],
      updates: hash[:updates],
      logo: hash[:logo],
      image: hash[:image],
      headquarters: hash[:headquarters],
      funding: hash[:funding],
      investors: hash[:investors],
      affiliated: hash[:affiliated],
      raw: hash
    )
  end
end

#current_company ⇒ Hash? (readonly)

Returns current company details.

Returns:

  • (Hash, nil) —

    current company details



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/brightdata/linkedin/types/profile.rb', line 46

Profile = Data.define(
  :id, :name, :city, :country_code, :position, :about,
  :current_company, :experience, :education, :connections, :followers,
  :linkedin_id, :linkedin_num_id, :avatar, :banner_image,
  :people_also_viewed, :input_url, :raw
) do
  # Build a profile from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Profile]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      city: hash[:city],
      country_code: hash[:country_code],
      position: hash[:position],
      about: hash[:about],
      current_company: hash[:current_company],
      experience: hash[:experience],
      education: hash[:education],
      connections: hash[:connections],
      followers: hash[:followers],
      linkedin_id: hash[:linkedin_id],
      linkedin_num_id: hash[:linkedin_num_id],
      avatar: hash[:avatar],
      banner_image: hash[:banner_image],
      people_also_viewed: hash[:people_also_viewed],
      input_url: hash[:input_url],
      raw: hash
    )
  end
end

#date_posted ⇒ String? (readonly)

Returns date posted.

Returns:

  • (String, nil) —

    date posted



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/brightdata/linkedin/types/post.rb', line 37

Post = Data.define(
  :id, :user_id, :headline, :post_text, :date_posted, :hashtags,
  :embedded_links, :images, :videos, :likes, :comments_count,
  :repost, :original_post, :raw
) do
  # Build a post from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Post]
  def self.from_api(hash) # rubocop:disable Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      user_id: hash[:user_id],
      headline: hash[:headline],
      post_text: hash[:post_text],
      date_posted: hash[:date_posted],
      hashtags: hash[:hashtags],
      embedded_links: hash[:embedded_links],
      images: hash[:images],
      videos: hash[:videos],
      likes: hash[:likes],
      comments_count: hash[:comments_count],
      repost: hash[:repost],
      original_post: hash[:original_post],
      raw: hash
    )
  end
end

#education ⇒ String, ... (readonly)

Returns education summary.

Returns:

  • (String, Hash, Array, nil) —

    education summary



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/brightdata/linkedin/types/profile.rb', line 46

Profile = Data.define(
  :id, :name, :city, :country_code, :position, :about,
  :current_company, :experience, :education, :connections, :followers,
  :linkedin_id, :linkedin_num_id, :avatar, :banner_image,
  :people_also_viewed, :input_url, :raw
) do
  # Build a profile from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Profile]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      city: hash[:city],
      country_code: hash[:country_code],
      position: hash[:position],
      about: hash[:about],
      current_company: hash[:current_company],
      experience: hash[:experience],
      education: hash[:education],
      connections: hash[:connections],
      followers: hash[:followers],
      linkedin_id: hash[:linkedin_id],
      linkedin_num_id: hash[:linkedin_num_id],
      avatar: hash[:avatar],
      banner_image: hash[:banner_image],
      people_also_viewed: hash[:people_also_viewed],
      input_url: hash[:input_url],
      raw: hash
    )
  end
end

#embedded_links ⇒ Array<String>? (readonly)

Returns embedded links.

Returns:

  • (Array<String>, nil) —

    embedded links



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/brightdata/linkedin/types/post.rb', line 37

Post = Data.define(
  :id, :user_id, :headline, :post_text, :date_posted, :hashtags,
  :embedded_links, :images, :videos, :likes, :comments_count,
  :repost, :original_post, :raw
) do
  # Build a post from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Post]
  def self.from_api(hash) # rubocop:disable Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      user_id: hash[:user_id],
      headline: hash[:headline],
      post_text: hash[:post_text],
      date_posted: hash[:date_posted],
      hashtags: hash[:hashtags],
      embedded_links: hash[:embedded_links],
      images: hash[:images],
      videos: hash[:videos],
      likes: hash[:likes],
      comments_count: hash[:comments_count],
      repost: hash[:repost],
      original_post: hash[:original_post],
      raw: hash
    )
  end
end

#employees ⇒ Array<Hash>? (readonly)

Returns employees.

Returns:

  • (Array<Hash>, nil) —

    employees



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/brightdata/linkedin/types/company.rb', line 53

Company = Data.define(
  :id, :name, :country_code, :locations, :followers,
  :employees_in_linkedin, :company_size, :industries, :specialties,
  :website, :founded, :company_id, :employees, :similar, :updates,
  :logo, :image, :headquarters, :funding, :investors, :affiliated, :raw
) do
  # Build a company from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Company]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      country_code: hash[:country_code],
      locations: hash[:locations],
      followers: hash[:followers],
      employees_in_linkedin: hash[:employees_in_linkedin],
      company_size: hash[:company_size],
      industries: hash[:industries],
      specialties: hash[:specialties],
      website: hash[:website],
      founded: hash[:founded],
      company_id: hash[:company_id],
      employees: hash[:employees],
      similar: hash[:similar],
      updates: hash[:updates],
      logo: hash[:logo],
      image: hash[:image],
      headquarters: hash[:headquarters],
      funding: hash[:funding],
      investors: hash[:investors],
      affiliated: hash[:affiliated],
      raw: hash
    )
  end
end

#employees_in_linkedin ⇒ Integer, ... (readonly)

Returns LinkedIn employee count.

Returns:

  • (Integer, String, nil) —

    LinkedIn employee count



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/brightdata/linkedin/types/company.rb', line 53

Company = Data.define(
  :id, :name, :country_code, :locations, :followers,
  :employees_in_linkedin, :company_size, :industries, :specialties,
  :website, :founded, :company_id, :employees, :similar, :updates,
  :logo, :image, :headquarters, :funding, :investors, :affiliated, :raw
) do
  # Build a company from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Company]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      country_code: hash[:country_code],
      locations: hash[:locations],
      followers: hash[:followers],
      employees_in_linkedin: hash[:employees_in_linkedin],
      company_size: hash[:company_size],
      industries: hash[:industries],
      specialties: hash[:specialties],
      website: hash[:website],
      founded: hash[:founded],
      company_id: hash[:company_id],
      employees: hash[:employees],
      similar: hash[:similar],
      updates: hash[:updates],
      logo: hash[:logo],
      image: hash[:image],
      headquarters: hash[:headquarters],
      funding: hash[:funding],
      investors: hash[:investors],
      affiliated: hash[:affiliated],
      raw: hash
    )
  end
end

#experience ⇒ String, ... (readonly)

Returns experience summary.

Returns:

  • (String, Hash, Array, nil) —

    experience summary



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/brightdata/linkedin/types/profile.rb', line 46

Profile = Data.define(
  :id, :name, :city, :country_code, :position, :about,
  :current_company, :experience, :education, :connections, :followers,
  :linkedin_id, :linkedin_num_id, :avatar, :banner_image,
  :people_also_viewed, :input_url, :raw
) do
  # Build a profile from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Profile]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      city: hash[:city],
      country_code: hash[:country_code],
      position: hash[:position],
      about: hash[:about],
      current_company: hash[:current_company],
      experience: hash[:experience],
      education: hash[:education],
      connections: hash[:connections],
      followers: hash[:followers],
      linkedin_id: hash[:linkedin_id],
      linkedin_num_id: hash[:linkedin_num_id],
      avatar: hash[:avatar],
      banner_image: hash[:banner_image],
      people_also_viewed: hash[:people_also_viewed],
      input_url: hash[:input_url],
      raw: hash
    )
  end
end

#experience_level ⇒ String? (readonly)

Returns experience level.

Returns:

  • (String, nil) —

    experience level



30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/brightdata/linkedin/types/job_keyword_input.rb', line 30

JobKeywordInput = Data.define(
  :location, :keyword, :country, :time_range, :job_type,
  :experience_level, :remote, :company, :selective_search,
  :jobs_to_not_include, :location_radius
) do
  # Serialize for Bright Data, omitting nil values.
  #
  # @return [Hash] API input payload
  def to_api_hash
    to_h.compact
  end
end

#first_name ⇒ String? (readonly)

Returns first name to search by.

Returns:

  • (String, nil) —

    first name to search by



14
15
16
17
18
19
20
21
 
# File 'lib/brightdata/linkedin/types/people_discover_input.rb', line 14

PeopleDiscoverInput = Data.define(:url, :first_name, :last_name) do
  # Serialize for Bright Data, omitting nil values.
  #
  # @return [Hash] API input payload
  def to_api_hash
    to_h.compact
  end
end

#followers ⇒ Integer, ... (readonly)

Returns follower count.

Returns:

  • (Integer, String, nil) —

    follower count



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/brightdata/linkedin/types/company.rb', line 53

Company = Data.define(
  :id, :name, :country_code, :locations, :followers,
  :employees_in_linkedin, :company_size, :industries, :specialties,
  :website, :founded, :company_id, :employees, :similar, :updates,
  :logo, :image, :headquarters, :funding, :investors, :affiliated, :raw
) do
  # Build a company from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Company]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      country_code: hash[:country_code],
      locations: hash[:locations],
      followers: hash[:followers],
      employees_in_linkedin: hash[:employees_in_linkedin],
      company_size: hash[:company_size],
      industries: hash[:industries],
      specialties: hash[:specialties],
      website: hash[:website],
      founded: hash[:founded],
      company_id: hash[:company_id],
      employees: hash[:employees],
      similar: hash[:similar],
      updates: hash[:updates],
      logo: hash[:logo],
      image: hash[:image],
      headquarters: hash[:headquarters],
      funding: hash[:funding],
      investors: hash[:investors],
      affiliated: hash[:affiliated],
      raw: hash
    )
  end
end

#founded ⇒ String, ... (readonly)

Returns founded year.

Returns:

  • (String, Integer, nil) —

    founded year



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/brightdata/linkedin/types/company.rb', line 53

Company = Data.define(
  :id, :name, :country_code, :locations, :followers,
  :employees_in_linkedin, :company_size, :industries, :specialties,
  :website, :founded, :company_id, :employees, :similar, :updates,
  :logo, :image, :headquarters, :funding, :investors, :affiliated, :raw
) do
  # Build a company from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Company]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      country_code: hash[:country_code],
      locations: hash[:locations],
      followers: hash[:followers],
      employees_in_linkedin: hash[:employees_in_linkedin],
      company_size: hash[:company_size],
      industries: hash[:industries],
      specialties: hash[:specialties],
      website: hash[:website],
      founded: hash[:founded],
      company_id: hash[:company_id],
      employees: hash[:employees],
      similar: hash[:similar],
      updates: hash[:updates],
      logo: hash[:logo],
      image: hash[:image],
      headquarters: hash[:headquarters],
      funding: hash[:funding],
      investors: hash[:investors],
      affiliated: hash[:affiliated],
      raw: hash
    )
  end
end

#funding ⇒ Hash? (readonly)

Returns funding details.

Returns:

  • (Hash, nil) —

    funding details



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/brightdata/linkedin/types/company.rb', line 53

Company = Data.define(
  :id, :name, :country_code, :locations, :followers,
  :employees_in_linkedin, :company_size, :industries, :specialties,
  :website, :founded, :company_id, :employees, :similar, :updates,
  :logo, :image, :headquarters, :funding, :investors, :affiliated, :raw
) do
  # Build a company from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Company]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      country_code: hash[:country_code],
      locations: hash[:locations],
      followers: hash[:followers],
      employees_in_linkedin: hash[:employees_in_linkedin],
      company_size: hash[:company_size],
      industries: hash[:industries],
      specialties: hash[:specialties],
      website: hash[:website],
      founded: hash[:founded],
      company_id: hash[:company_id],
      employees: hash[:employees],
      similar: hash[:similar],
      updates: hash[:updates],
      logo: hash[:logo],
      image: hash[:image],
      headquarters: hash[:headquarters],
      funding: hash[:funding],
      investors: hash[:investors],
      affiliated: hash[:affiliated],
      raw: hash
    )
  end
end

#hashtags ⇒ Array<String>? (readonly)

Returns hashtags.

Returns:

  • (Array<String>, nil) —

    hashtags



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/brightdata/linkedin/types/post.rb', line 37

Post = Data.define(
  :id, :user_id, :headline, :post_text, :date_posted, :hashtags,
  :embedded_links, :images, :videos, :likes, :comments_count,
  :repost, :original_post, :raw
) do
  # Build a post from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Post]
  def self.from_api(hash) # rubocop:disable Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      user_id: hash[:user_id],
      headline: hash[:headline],
      post_text: hash[:post_text],
      date_posted: hash[:date_posted],
      hashtags: hash[:hashtags],
      embedded_links: hash[:embedded_links],
      images: hash[:images],
      videos: hash[:videos],
      likes: hash[:likes],
      comments_count: hash[:comments_count],
      repost: hash[:repost],
      original_post: hash[:original_post],
      raw: hash
    )
  end
end

#headline ⇒ String? (readonly)

Returns author headline.

Returns:

  • (String, nil) —

    author headline



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/brightdata/linkedin/types/post.rb', line 37

Post = Data.define(
  :id, :user_id, :headline, :post_text, :date_posted, :hashtags,
  :embedded_links, :images, :videos, :likes, :comments_count,
  :repost, :original_post, :raw
) do
  # Build a post from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Post]
  def self.from_api(hash) # rubocop:disable Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      user_id: hash[:user_id],
      headline: hash[:headline],
      post_text: hash[:post_text],
      date_posted: hash[:date_posted],
      hashtags: hash[:hashtags],
      embedded_links: hash[:embedded_links],
      images: hash[:images],
      videos: hash[:videos],
      likes: hash[:likes],
      comments_count: hash[:comments_count],
      repost: hash[:repost],
      original_post: hash[:original_post],
      raw: hash
    )
  end
end

#headquarters ⇒ Hash? (readonly)

Returns headquarters.

Returns:

  • (Hash, nil) —

    headquarters



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/brightdata/linkedin/types/company.rb', line 53

Company = Data.define(
  :id, :name, :country_code, :locations, :followers,
  :employees_in_linkedin, :company_size, :industries, :specialties,
  :website, :founded, :company_id, :employees, :similar, :updates,
  :logo, :image, :headquarters, :funding, :investors, :affiliated, :raw
) do
  # Build a company from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Company]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      country_code: hash[:country_code],
      locations: hash[:locations],
      followers: hash[:followers],
      employees_in_linkedin: hash[:employees_in_linkedin],
      company_size: hash[:company_size],
      industries: hash[:industries],
      specialties: hash[:specialties],
      website: hash[:website],
      founded: hash[:founded],
      company_id: hash[:company_id],
      employees: hash[:employees],
      similar: hash[:similar],
      updates: hash[:updates],
      logo: hash[:logo],
      image: hash[:image],
      headquarters: hash[:headquarters],
      funding: hash[:funding],
      investors: hash[:investors],
      affiliated: hash[:affiliated],
      raw: hash
    )
  end
end

#id ⇒ String? (readonly)

Returns profile ID.

Returns:

  • (String, nil) —

    profile ID



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/brightdata/linkedin/types/post.rb', line 37

Post = Data.define(
  :id, :user_id, :headline, :post_text, :date_posted, :hashtags,
  :embedded_links, :images, :videos, :likes, :comments_count,
  :repost, :original_post, :raw
) do
  # Build a post from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Post]
  def self.from_api(hash) # rubocop:disable Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      user_id: hash[:user_id],
      headline: hash[:headline],
      post_text: hash[:post_text],
      date_posted: hash[:date_posted],
      hashtags: hash[:hashtags],
      embedded_links: hash[:embedded_links],
      images: hash[:images],
      videos: hash[:videos],
      likes: hash[:likes],
      comments_count: hash[:comments_count],
      repost: hash[:repost],
      original_post: hash[:original_post],
      raw: hash
    )
  end
end

#image ⇒ String? (readonly)

Returns image URL.

Returns:

  • (String, nil) —

    image URL



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/brightdata/linkedin/types/company.rb', line 53

Company = Data.define(
  :id, :name, :country_code, :locations, :followers,
  :employees_in_linkedin, :company_size, :industries, :specialties,
  :website, :founded, :company_id, :employees, :similar, :updates,
  :logo, :image, :headquarters, :funding, :investors, :affiliated, :raw
) do
  # Build a company from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Company]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      country_code: hash[:country_code],
      locations: hash[:locations],
      followers: hash[:followers],
      employees_in_linkedin: hash[:employees_in_linkedin],
      company_size: hash[:company_size],
      industries: hash[:industries],
      specialties: hash[:specialties],
      website: hash[:website],
      founded: hash[:founded],
      company_id: hash[:company_id],
      employees: hash[:employees],
      similar: hash[:similar],
      updates: hash[:updates],
      logo: hash[:logo],
      image: hash[:image],
      headquarters: hash[:headquarters],
      funding: hash[:funding],
      investors: hash[:investors],
      affiliated: hash[:affiliated],
      raw: hash
    )
  end
end

#images ⇒ Array<String>? (readonly)

Returns image URLs.

Returns:

  • (Array<String>, nil) —

    image URLs



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/brightdata/linkedin/types/post.rb', line 37

Post = Data.define(
  :id, :user_id, :headline, :post_text, :date_posted, :hashtags,
  :embedded_links, :images, :videos, :likes, :comments_count,
  :repost, :original_post, :raw
) do
  # Build a post from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Post]
  def self.from_api(hash) # rubocop:disable Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      user_id: hash[:user_id],
      headline: hash[:headline],
      post_text: hash[:post_text],
      date_posted: hash[:date_posted],
      hashtags: hash[:hashtags],
      embedded_links: hash[:embedded_links],
      images: hash[:images],
      videos: hash[:videos],
      likes: hash[:likes],
      comments_count: hash[:comments_count],
      repost: hash[:repost],
      original_post: hash[:original_post],
      raw: hash
    )
  end
end

#industries ⇒ Array<String>? (readonly)

Returns industries.

Returns:

  • (Array<String>, nil) —

    industries



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/brightdata/linkedin/types/company.rb', line 53

Company = Data.define(
  :id, :name, :country_code, :locations, :followers,
  :employees_in_linkedin, :company_size, :industries, :specialties,
  :website, :founded, :company_id, :employees, :similar, :updates,
  :logo, :image, :headquarters, :funding, :investors, :affiliated, :raw
) do
  # Build a company from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Company]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      country_code: hash[:country_code],
      locations: hash[:locations],
      followers: hash[:followers],
      employees_in_linkedin: hash[:employees_in_linkedin],
      company_size: hash[:company_size],
      industries: hash[:industries],
      specialties: hash[:specialties],
      website: hash[:website],
      founded: hash[:founded],
      company_id: hash[:company_id],
      employees: hash[:employees],
      similar: hash[:similar],
      updates: hash[:updates],
      logo: hash[:logo],
      image: hash[:image],
      headquarters: hash[:headquarters],
      funding: hash[:funding],
      investors: hash[:investors],
      affiliated: hash[:affiliated],
      raw: hash
    )
  end
end

#input_url ⇒ String? (readonly)

Returns requested input URL.

Returns:

  • (String, nil) —

    requested input URL



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/brightdata/linkedin/types/profile.rb', line 46

Profile = Data.define(
  :id, :name, :city, :country_code, :position, :about,
  :current_company, :experience, :education, :connections, :followers,
  :linkedin_id, :linkedin_num_id, :avatar, :banner_image,
  :people_also_viewed, :input_url, :raw
) do
  # Build a profile from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Profile]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      city: hash[:city],
      country_code: hash[:country_code],
      position: hash[:position],
      about: hash[:about],
      current_company: hash[:current_company],
      experience: hash[:experience],
      education: hash[:education],
      connections: hash[:connections],
      followers: hash[:followers],
      linkedin_id: hash[:linkedin_id],
      linkedin_num_id: hash[:linkedin_num_id],
      avatar: hash[:avatar],
      banner_image: hash[:banner_image],
      people_also_viewed: hash[:people_also_viewed],
      input_url: hash[:input_url],
      raw: hash
    )
  end
end

#investors ⇒ Array<Hash>? (readonly)

Returns investors.

Returns:

  • (Array<Hash>, nil) —

    investors



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/brightdata/linkedin/types/company.rb', line 53

Company = Data.define(
  :id, :name, :country_code, :locations, :followers,
  :employees_in_linkedin, :company_size, :industries, :specialties,
  :website, :founded, :company_id, :employees, :similar, :updates,
  :logo, :image, :headquarters, :funding, :investors, :affiliated, :raw
) do
  # Build a company from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Company]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      country_code: hash[:country_code],
      locations: hash[:locations],
      followers: hash[:followers],
      employees_in_linkedin: hash[:employees_in_linkedin],
      company_size: hash[:company_size],
      industries: hash[:industries],
      specialties: hash[:specialties],
      website: hash[:website],
      founded: hash[:founded],
      company_id: hash[:company_id],
      employees: hash[:employees],
      similar: hash[:similar],
      updates: hash[:updates],
      logo: hash[:logo],
      image: hash[:image],
      headquarters: hash[:headquarters],
      funding: hash[:funding],
      investors: hash[:investors],
      affiliated: hash[:affiliated],
      raw: hash
    )
  end
end

#job_base_pay_range ⇒ String? (readonly)

Returns base pay range.

Returns:

  • (String, nil) —

    base pay range



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/brightdata/linkedin/types/job.rb', line 29

Job = Data.define(
  :url, :job_posting_id, :job_title, :company_name, :job_location,
  :job_summary, :job_base_pay_range, :job_posted_time, :company_logo, :raw
) do
  # Build a job from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Job]
  def self.from_api(hash) # rubocop:disable Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      url: hash[:url],
      job_posting_id: hash[:job_posting_id],
      job_title: hash[:job_title],
      company_name: hash[:company_name],
      job_location: hash[:job_location],
      job_summary: hash[:job_summary],
      job_base_pay_range: hash[:job_base_pay_range],
      job_posted_time: hash[:job_posted_time],
      company_logo: hash[:company_logo],
      raw: hash
    )
  end
end

#job_location ⇒ String? (readonly)

Returns job location.

Returns:

  • (String, nil) —

    job location



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/brightdata/linkedin/types/job.rb', line 29

Job = Data.define(
  :url, :job_posting_id, :job_title, :company_name, :job_location,
  :job_summary, :job_base_pay_range, :job_posted_time, :company_logo, :raw
) do
  # Build a job from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Job]
  def self.from_api(hash) # rubocop:disable Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      url: hash[:url],
      job_posting_id: hash[:job_posting_id],
      job_title: hash[:job_title],
      company_name: hash[:company_name],
      job_location: hash[:job_location],
      job_summary: hash[:job_summary],
      job_base_pay_range: hash[:job_base_pay_range],
      job_posted_time: hash[:job_posted_time],
      company_logo: hash[:company_logo],
      raw: hash
    )
  end
end

#job_posted_time ⇒ String? (readonly)

Returns posted time.

Returns:

  • (String, nil) —

    posted time



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/brightdata/linkedin/types/job.rb', line 29

Job = Data.define(
  :url, :job_posting_id, :job_title, :company_name, :job_location,
  :job_summary, :job_base_pay_range, :job_posted_time, :company_logo, :raw
) do
  # Build a job from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Job]
  def self.from_api(hash) # rubocop:disable Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      url: hash[:url],
      job_posting_id: hash[:job_posting_id],
      job_title: hash[:job_title],
      company_name: hash[:company_name],
      job_location: hash[:job_location],
      job_summary: hash[:job_summary],
      job_base_pay_range: hash[:job_base_pay_range],
      job_posted_time: hash[:job_posted_time],
      company_logo: hash[:company_logo],
      raw: hash
    )
  end
end

#job_posting_id ⇒ String? (readonly)

Returns job posting ID.

Returns:

  • (String, nil) —

    job posting ID



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/brightdata/linkedin/types/job.rb', line 29

Job = Data.define(
  :url, :job_posting_id, :job_title, :company_name, :job_location,
  :job_summary, :job_base_pay_range, :job_posted_time, :company_logo, :raw
) do
  # Build a job from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Job]
  def self.from_api(hash) # rubocop:disable Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      url: hash[:url],
      job_posting_id: hash[:job_posting_id],
      job_title: hash[:job_title],
      company_name: hash[:company_name],
      job_location: hash[:job_location],
      job_summary: hash[:job_summary],
      job_base_pay_range: hash[:job_base_pay_range],
      job_posted_time: hash[:job_posted_time],
      company_logo: hash[:company_logo],
      raw: hash
    )
  end
end

#job_summary ⇒ String? (readonly)

Returns job summary.

Returns:

  • (String, nil) —

    job summary



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/brightdata/linkedin/types/job.rb', line 29

Job = Data.define(
  :url, :job_posting_id, :job_title, :company_name, :job_location,
  :job_summary, :job_base_pay_range, :job_posted_time, :company_logo, :raw
) do
  # Build a job from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Job]
  def self.from_api(hash) # rubocop:disable Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      url: hash[:url],
      job_posting_id: hash[:job_posting_id],
      job_title: hash[:job_title],
      company_name: hash[:company_name],
      job_location: hash[:job_location],
      job_summary: hash[:job_summary],
      job_base_pay_range: hash[:job_base_pay_range],
      job_posted_time: hash[:job_posted_time],
      company_logo: hash[:company_logo],
      raw: hash
    )
  end
end

#job_title ⇒ String? (readonly)

Returns job title.

Returns:

  • (String, nil) —

    job title



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/brightdata/linkedin/types/job.rb', line 29

Job = Data.define(
  :url, :job_posting_id, :job_title, :company_name, :job_location,
  :job_summary, :job_base_pay_range, :job_posted_time, :company_logo, :raw
) do
  # Build a job from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Job]
  def self.from_api(hash) # rubocop:disable Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      url: hash[:url],
      job_posting_id: hash[:job_posting_id],
      job_title: hash[:job_title],
      company_name: hash[:company_name],
      job_location: hash[:job_location],
      job_summary: hash[:job_summary],
      job_base_pay_range: hash[:job_base_pay_range],
      job_posted_time: hash[:job_posted_time],
      company_logo: hash[:company_logo],
      raw: hash
    )
  end
end

#job_type ⇒ String? (readonly)

Returns job type.

Returns:

  • (String, nil) —

    job type



30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/brightdata/linkedin/types/job_keyword_input.rb', line 30

JobKeywordInput = Data.define(
  :location, :keyword, :country, :time_range, :job_type,
  :experience_level, :remote, :company, :selective_search,
  :jobs_to_not_include, :location_radius
) do
  # Serialize for Bright Data, omitting nil values.
  #
  # @return [Hash] API input payload
  def to_api_hash
    to_h.compact
  end
end

#jobs_to_not_include ⇒ String, ... (readonly)

Returns excluded jobs.

Returns:

  • (String, Array<String>, nil) —

    excluded jobs



30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/brightdata/linkedin/types/job_keyword_input.rb', line 30

JobKeywordInput = Data.define(
  :location, :keyword, :country, :time_range, :job_type,
  :experience_level, :remote, :company, :selective_search,
  :jobs_to_not_include, :location_radius
) do
  # Serialize for Bright Data, omitting nil values.
  #
  # @return [Hash] API input payload
  def to_api_hash
    to_h.compact
  end
end

#keyword ⇒ String? (readonly)

Returns job keyword.

Returns:

  • (String, nil) —

    job keyword



30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/brightdata/linkedin/types/job_keyword_input.rb', line 30

JobKeywordInput = Data.define(
  :location, :keyword, :country, :time_range, :job_type,
  :experience_level, :remote, :company, :selective_search,
  :jobs_to_not_include, :location_radius
) do
  # Serialize for Bright Data, omitting nil values.
  #
  # @return [Hash] API input payload
  def to_api_hash
    to_h.compact
  end
end

#last_name ⇒ String? (readonly)

Returns last name to search by.

Returns:

  • (String, nil) —

    last name to search by



14
15
16
17
18
19
20
21
 
# File 'lib/brightdata/linkedin/types/people_discover_input.rb', line 14

PeopleDiscoverInput = Data.define(:url, :first_name, :last_name) do
  # Serialize for Bright Data, omitting nil values.
  #
  # @return [Hash] API input payload
  def to_api_hash
    to_h.compact
  end
end

#likes ⇒ Integer, ... (readonly)

Returns like count.

Returns:

  • (Integer, String, nil) —

    like count



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/brightdata/linkedin/types/post.rb', line 37

Post = Data.define(
  :id, :user_id, :headline, :post_text, :date_posted, :hashtags,
  :embedded_links, :images, :videos, :likes, :comments_count,
  :repost, :original_post, :raw
) do
  # Build a post from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Post]
  def self.from_api(hash) # rubocop:disable Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      user_id: hash[:user_id],
      headline: hash[:headline],
      post_text: hash[:post_text],
      date_posted: hash[:date_posted],
      hashtags: hash[:hashtags],
      embedded_links: hash[:embedded_links],
      images: hash[:images],
      videos: hash[:videos],
      likes: hash[:likes],
      comments_count: hash[:comments_count],
      repost: hash[:repost],
      original_post: hash[:original_post],
      raw: hash
    )
  end
end

#linkedin_id ⇒ String? (readonly)

Returns LinkedIn vanity ID.

Returns:

  • (String, nil) —

    LinkedIn vanity ID



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/brightdata/linkedin/types/profile.rb', line 46

Profile = Data.define(
  :id, :name, :city, :country_code, :position, :about,
  :current_company, :experience, :education, :connections, :followers,
  :linkedin_id, :linkedin_num_id, :avatar, :banner_image,
  :people_also_viewed, :input_url, :raw
) do
  # Build a profile from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Profile]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      city: hash[:city],
      country_code: hash[:country_code],
      position: hash[:position],
      about: hash[:about],
      current_company: hash[:current_company],
      experience: hash[:experience],
      education: hash[:education],
      connections: hash[:connections],
      followers: hash[:followers],
      linkedin_id: hash[:linkedin_id],
      linkedin_num_id: hash[:linkedin_num_id],
      avatar: hash[:avatar],
      banner_image: hash[:banner_image],
      people_also_viewed: hash[:people_also_viewed],
      input_url: hash[:input_url],
      raw: hash
    )
  end
end

#linkedin_num_id ⇒ String, ... (readonly)

Returns LinkedIn numeric ID.

Returns:

  • (String, Integer, nil) —

    LinkedIn numeric ID



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/brightdata/linkedin/types/profile.rb', line 46

Profile = Data.define(
  :id, :name, :city, :country_code, :position, :about,
  :current_company, :experience, :education, :connections, :followers,
  :linkedin_id, :linkedin_num_id, :avatar, :banner_image,
  :people_also_viewed, :input_url, :raw
) do
  # Build a profile from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Profile]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      city: hash[:city],
      country_code: hash[:country_code],
      position: hash[:position],
      about: hash[:about],
      current_company: hash[:current_company],
      experience: hash[:experience],
      education: hash[:education],
      connections: hash[:connections],
      followers: hash[:followers],
      linkedin_id: hash[:linkedin_id],
      linkedin_num_id: hash[:linkedin_num_id],
      avatar: hash[:avatar],
      banner_image: hash[:banner_image],
      people_also_viewed: hash[:people_also_viewed],
      input_url: hash[:input_url],
      raw: hash
    )
  end
end

#location ⇒ String? (readonly)

Returns profile location.

Returns:

  • (String, nil) —

    profile location



30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/brightdata/linkedin/types/job_keyword_input.rb', line 30

JobKeywordInput = Data.define(
  :location, :keyword, :country, :time_range, :job_type,
  :experience_level, :remote, :company, :selective_search,
  :jobs_to_not_include, :location_radius
) do
  # Serialize for Bright Data, omitting nil values.
  #
  # @return [Hash] API input payload
  def to_api_hash
    to_h.compact
  end
end

#location_radius ⇒ Integer, ... (readonly)

Returns location radius.

Returns:

  • (Integer, String, nil) —

    location radius



30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/brightdata/linkedin/types/job_keyword_input.rb', line 30

JobKeywordInput = Data.define(
  :location, :keyword, :country, :time_range, :job_type,
  :experience_level, :remote, :company, :selective_search,
  :jobs_to_not_include, :location_radius
) do
  # Serialize for Bright Data, omitting nil values.
  #
  # @return [Hash] API input payload
  def to_api_hash
    to_h.compact
  end
end

#locations ⇒ Array<Hash>? (readonly)

Returns company locations.

Returns:

  • (Array<Hash>, nil) —

    company locations



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/brightdata/linkedin/types/company.rb', line 53

Company = Data.define(
  :id, :name, :country_code, :locations, :followers,
  :employees_in_linkedin, :company_size, :industries, :specialties,
  :website, :founded, :company_id, :employees, :similar, :updates,
  :logo, :image, :headquarters, :funding, :investors, :affiliated, :raw
) do
  # Build a company from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Company]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      country_code: hash[:country_code],
      locations: hash[:locations],
      followers: hash[:followers],
      employees_in_linkedin: hash[:employees_in_linkedin],
      company_size: hash[:company_size],
      industries: hash[:industries],
      specialties: hash[:specialties],
      website: hash[:website],
      founded: hash[:founded],
      company_id: hash[:company_id],
      employees: hash[:employees],
      similar: hash[:similar],
      updates: hash[:updates],
      logo: hash[:logo],
      image: hash[:image],
      headquarters: hash[:headquarters],
      funding: hash[:funding],
      investors: hash[:investors],
      affiliated: hash[:affiliated],
      raw: hash
    )
  end
end

#logo ⇒ String? (readonly)

Returns logo URL.

Returns:

  • (String, nil) —

    logo URL



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/brightdata/linkedin/types/company.rb', line 53

Company = Data.define(
  :id, :name, :country_code, :locations, :followers,
  :employees_in_linkedin, :company_size, :industries, :specialties,
  :website, :founded, :company_id, :employees, :similar, :updates,
  :logo, :image, :headquarters, :funding, :investors, :affiliated, :raw
) do
  # Build a company from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Company]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      country_code: hash[:country_code],
      locations: hash[:locations],
      followers: hash[:followers],
      employees_in_linkedin: hash[:employees_in_linkedin],
      company_size: hash[:company_size],
      industries: hash[:industries],
      specialties: hash[:specialties],
      website: hash[:website],
      founded: hash[:founded],
      company_id: hash[:company_id],
      employees: hash[:employees],
      similar: hash[:similar],
      updates: hash[:updates],
      logo: hash[:logo],
      image: hash[:image],
      headquarters: hash[:headquarters],
      funding: hash[:funding],
      investors: hash[:investors],
      affiliated: hash[:affiliated],
      raw: hash
    )
  end
end

#name ⇒ String? (readonly)

Returns profile name.

Returns:

  • (String, nil) —

    profile name



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/brightdata/linkedin/types/company.rb', line 53

Company = Data.define(
  :id, :name, :country_code, :locations, :followers,
  :employees_in_linkedin, :company_size, :industries, :specialties,
  :website, :founded, :company_id, :employees, :similar, :updates,
  :logo, :image, :headquarters, :funding, :investors, :affiliated, :raw
) do
  # Build a company from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Company]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      country_code: hash[:country_code],
      locations: hash[:locations],
      followers: hash[:followers],
      employees_in_linkedin: hash[:employees_in_linkedin],
      company_size: hash[:company_size],
      industries: hash[:industries],
      specialties: hash[:specialties],
      website: hash[:website],
      founded: hash[:founded],
      company_id: hash[:company_id],
      employees: hash[:employees],
      similar: hash[:similar],
      updates: hash[:updates],
      logo: hash[:logo],
      image: hash[:image],
      headquarters: hash[:headquarters],
      funding: hash[:funding],
      investors: hash[:investors],
      affiliated: hash[:affiliated],
      raw: hash
    )
  end
end

#original_post ⇒ Hash? (readonly)

Returns original post details.

Returns:

  • (Hash, nil) —

    original post details



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/brightdata/linkedin/types/post.rb', line 37

Post = Data.define(
  :id, :user_id, :headline, :post_text, :date_posted, :hashtags,
  :embedded_links, :images, :videos, :likes, :comments_count,
  :repost, :original_post, :raw
) do
  # Build a post from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Post]
  def self.from_api(hash) # rubocop:disable Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      user_id: hash[:user_id],
      headline: hash[:headline],
      post_text: hash[:post_text],
      date_posted: hash[:date_posted],
      hashtags: hash[:hashtags],
      embedded_links: hash[:embedded_links],
      images: hash[:images],
      videos: hash[:videos],
      likes: hash[:likes],
      comments_count: hash[:comments_count],
      repost: hash[:repost],
      original_post: hash[:original_post],
      raw: hash
    )
  end
end

#people_also_viewed ⇒ Array<Hash>? (readonly)

Returns related profiles.

Returns:

  • (Array<Hash>, nil) —

    related profiles



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/brightdata/linkedin/types/profile.rb', line 46

Profile = Data.define(
  :id, :name, :city, :country_code, :position, :about,
  :current_company, :experience, :education, :connections, :followers,
  :linkedin_id, :linkedin_num_id, :avatar, :banner_image,
  :people_also_viewed, :input_url, :raw
) do
  # Build a profile from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Profile]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      city: hash[:city],
      country_code: hash[:country_code],
      position: hash[:position],
      about: hash[:about],
      current_company: hash[:current_company],
      experience: hash[:experience],
      education: hash[:education],
      connections: hash[:connections],
      followers: hash[:followers],
      linkedin_id: hash[:linkedin_id],
      linkedin_num_id: hash[:linkedin_num_id],
      avatar: hash[:avatar],
      banner_image: hash[:banner_image],
      people_also_viewed: hash[:people_also_viewed],
      input_url: hash[:input_url],
      raw: hash
    )
  end
end

#position ⇒ String? (readonly)

Returns current position.

Returns:

  • (String, nil) —

    current position



46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
 
# File 'lib/brightdata/linkedin/types/profile.rb', line 46

Profile = Data.define(
  :id, :name, :city, :country_code, :position, :about,
  :current_company, :experience, :education, :connections, :followers,
  :linkedin_id, :linkedin_num_id, :avatar, :banner_image,
  :people_also_viewed, :input_url, :raw
) do
  # Build a profile from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Profile]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      city: hash[:city],
      country_code: hash[:country_code],
      position: hash[:position],
      about: hash[:about],
      current_company: hash[:current_company],
      experience: hash[:experience],
      education: hash[:education],
      connections: hash[:connections],
      followers: hash[:followers],
      linkedin_id: hash[:linkedin_id],
      linkedin_num_id: hash[:linkedin_num_id],
      avatar: hash[:avatar],
      banner_image: hash[:banner_image],
      people_also_viewed: hash[:people_also_viewed],
      input_url: hash[:input_url],
      raw: hash
    )
  end
end

#post_text ⇒ String? (readonly)

Returns post text.

Returns:

  • (String, nil) —

    post text



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/brightdata/linkedin/types/post.rb', line 37

Post = Data.define(
  :id, :user_id, :headline, :post_text, :date_posted, :hashtags,
  :embedded_links, :images, :videos, :likes, :comments_count,
  :repost, :original_post, :raw
) do
  # Build a post from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Post]
  def self.from_api(hash) # rubocop:disable Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      user_id: hash[:user_id],
      headline: hash[:headline],
      post_text: hash[:post_text],
      date_posted: hash[:date_posted],
      hashtags: hash[:hashtags],
      embedded_links: hash[:embedded_links],
      images: hash[:images],
      videos: hash[:videos],
      likes: hash[:likes],
      comments_count: hash[:comments_count],
      repost: hash[:repost],
      original_post: hash[:original_post],
      raw: hash
    )
  end
end

#raw ⇒ Hash (readonly)

Returns full parsed API response.

Returns:

  • (Hash) —

    full parsed API response



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/brightdata/linkedin/types/job.rb', line 29

Job = Data.define(
  :url, :job_posting_id, :job_title, :company_name, :job_location,
  :job_summary, :job_base_pay_range, :job_posted_time, :company_logo, :raw
) do
  # Build a job from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Job]
  def self.from_api(hash) # rubocop:disable Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      url: hash[:url],
      job_posting_id: hash[:job_posting_id],
      job_title: hash[:job_title],
      company_name: hash[:company_name],
      job_location: hash[:job_location],
      job_summary: hash[:job_summary],
      job_base_pay_range: hash[:job_base_pay_range],
      job_posted_time: hash[:job_posted_time],
      company_logo: hash[:company_logo],
      raw: hash
    )
  end
end

#remote ⇒ String, ... (readonly)

Returns remote filter.

Returns:

  • (String, Boolean, nil) —

    remote filter



30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/brightdata/linkedin/types/job_keyword_input.rb', line 30

JobKeywordInput = Data.define(
  :location, :keyword, :country, :time_range, :job_type,
  :experience_level, :remote, :company, :selective_search,
  :jobs_to_not_include, :location_radius
) do
  # Serialize for Bright Data, omitting nil values.
  #
  # @return [Hash] API input payload
  def to_api_hash
    to_h.compact
  end
end

#repost ⇒ Hash? (readonly)

Returns repost details.

Returns:

  • (Hash, nil) —

    repost details



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/brightdata/linkedin/types/post.rb', line 37

Post = Data.define(
  :id, :user_id, :headline, :post_text, :date_posted, :hashtags,
  :embedded_links, :images, :videos, :likes, :comments_count,
  :repost, :original_post, :raw
) do
  # Build a post from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Post]
  def self.from_api(hash) # rubocop:disable Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      user_id: hash[:user_id],
      headline: hash[:headline],
      post_text: hash[:post_text],
      date_posted: hash[:date_posted],
      hashtags: hash[:hashtags],
      embedded_links: hash[:embedded_links],
      images: hash[:images],
      videos: hash[:videos],
      likes: hash[:likes],
      comments_count: hash[:comments_count],
      repost: hash[:repost],
      original_post: hash[:original_post],
      raw: hash
    )
  end
end

#selective_search ⇒ String, ... (readonly)

Returns selective search flag.

Returns:

  • (String, Boolean, nil) —

    selective search flag



30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/brightdata/linkedin/types/job_keyword_input.rb', line 30

JobKeywordInput = Data.define(
  :location, :keyword, :country, :time_range, :job_type,
  :experience_level, :remote, :company, :selective_search,
  :jobs_to_not_include, :location_radius
) do
  # Serialize for Bright Data, omitting nil values.
  #
  # @return [Hash] API input payload
  def to_api_hash
    to_h.compact
  end
end

#similar ⇒ Array<Hash>? (readonly)

Returns similar companies.

Returns:

  • (Array<Hash>, nil) —

    similar companies



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/brightdata/linkedin/types/company.rb', line 53

Company = Data.define(
  :id, :name, :country_code, :locations, :followers,
  :employees_in_linkedin, :company_size, :industries, :specialties,
  :website, :founded, :company_id, :employees, :similar, :updates,
  :logo, :image, :headquarters, :funding, :investors, :affiliated, :raw
) do
  # Build a company from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Company]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      country_code: hash[:country_code],
      locations: hash[:locations],
      followers: hash[:followers],
      employees_in_linkedin: hash[:employees_in_linkedin],
      company_size: hash[:company_size],
      industries: hash[:industries],
      specialties: hash[:specialties],
      website: hash[:website],
      founded: hash[:founded],
      company_id: hash[:company_id],
      employees: hash[:employees],
      similar: hash[:similar],
      updates: hash[:updates],
      logo: hash[:logo],
      image: hash[:image],
      headquarters: hash[:headquarters],
      funding: hash[:funding],
      investors: hash[:investors],
      affiliated: hash[:affiliated],
      raw: hash
    )
  end
end

#specialties ⇒ Array<String>? (readonly)

Returns specialties.

Returns:

  • (Array<String>, nil) —

    specialties



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/brightdata/linkedin/types/company.rb', line 53

Company = Data.define(
  :id, :name, :country_code, :locations, :followers,
  :employees_in_linkedin, :company_size, :industries, :specialties,
  :website, :founded, :company_id, :employees, :similar, :updates,
  :logo, :image, :headquarters, :funding, :investors, :affiliated, :raw
) do
  # Build a company from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Company]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      country_code: hash[:country_code],
      locations: hash[:locations],
      followers: hash[:followers],
      employees_in_linkedin: hash[:employees_in_linkedin],
      company_size: hash[:company_size],
      industries: hash[:industries],
      specialties: hash[:specialties],
      website: hash[:website],
      founded: hash[:founded],
      company_id: hash[:company_id],
      employees: hash[:employees],
      similar: hash[:similar],
      updates: hash[:updates],
      logo: hash[:logo],
      image: hash[:image],
      headquarters: hash[:headquarters],
      funding: hash[:funding],
      investors: hash[:investors],
      affiliated: hash[:affiliated],
      raw: hash
    )
  end
end

#subtitle ⇒ String? (readonly)

Returns profile subtitle.

Returns:

  • (String, nil) —

    profile subtitle



25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 
# File 'lib/brightdata/linkedin/types/discovered_profile.rb', line 25

DiscoveredProfile = Data.define(:url, :name, :subtitle, :location, :experience, :education, :avatar, :raw) do
  # Build a discovered profile from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::DiscoveredProfile]
  def self.from_api(hash)
    new(
      url: hash[:url],
      name: hash[:name],
      subtitle: hash[:subtitle],
      location: hash[:location],
      experience: hash[:experience],
      education: hash[:education],
      avatar: hash[:avatar],
      raw: hash
    )
  end
end

#time_range ⇒ String? (readonly)

Returns posting time range.

Returns:

  • (String, nil) —

    posting time range



30
31
32
33
34
35
36
37
38
39
40
41
 
# File 'lib/brightdata/linkedin/types/job_keyword_input.rb', line 30

JobKeywordInput = Data.define(
  :location, :keyword, :country, :time_range, :job_type,
  :experience_level, :remote, :company, :selective_search,
  :jobs_to_not_include, :location_radius
) do
  # Serialize for Bright Data, omitting nil values.
  #
  # @return [Hash] API input payload
  def to_api_hash
    to_h.compact
  end
end

#updates ⇒ Array<Hash>? (readonly)

Returns updates.

Returns:

  • (Array<Hash>, nil) —

    updates



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/brightdata/linkedin/types/company.rb', line 53

Company = Data.define(
  :id, :name, :country_code, :locations, :followers,
  :employees_in_linkedin, :company_size, :industries, :specialties,
  :website, :founded, :company_id, :employees, :similar, :updates,
  :logo, :image, :headquarters, :funding, :investors, :affiliated, :raw
) do
  # Build a company from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Company]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      country_code: hash[:country_code],
      locations: hash[:locations],
      followers: hash[:followers],
      employees_in_linkedin: hash[:employees_in_linkedin],
      company_size: hash[:company_size],
      industries: hash[:industries],
      specialties: hash[:specialties],
      website: hash[:website],
      founded: hash[:founded],
      company_id: hash[:company_id],
      employees: hash[:employees],
      similar: hash[:similar],
      updates: hash[:updates],
      logo: hash[:logo],
      image: hash[:image],
      headquarters: hash[:headquarters],
      funding: hash[:funding],
      investors: hash[:investors],
      affiliated: hash[:affiliated],
      raw: hash
    )
  end
end

#url ⇒ String (readonly)

Returns LinkedIn profile URL.

Returns:

  • (String) —

    LinkedIn profile URL



29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
 
# File 'lib/brightdata/linkedin/types/job.rb', line 29

Job = Data.define(
  :url, :job_posting_id, :job_title, :company_name, :job_location,
  :job_summary, :job_base_pay_range, :job_posted_time, :company_logo, :raw
) do
  # Build a job from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Job]
  def self.from_api(hash) # rubocop:disable Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      url: hash[:url],
      job_posting_id: hash[:job_posting_id],
      job_title: hash[:job_title],
      company_name: hash[:company_name],
      job_location: hash[:job_location],
      job_summary: hash[:job_summary],
      job_base_pay_range: hash[:job_base_pay_range],
      job_posted_time: hash[:job_posted_time],
      company_logo: hash[:company_logo],
      raw: hash
    )
  end
end

#user_id ⇒ String? (readonly)

Returns author user ID.

Returns:

  • (String, nil) —

    author user ID



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/brightdata/linkedin/types/post.rb', line 37

Post = Data.define(
  :id, :user_id, :headline, :post_text, :date_posted, :hashtags,
  :embedded_links, :images, :videos, :likes, :comments_count,
  :repost, :original_post, :raw
) do
  # Build a post from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Post]
  def self.from_api(hash) # rubocop:disable Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      user_id: hash[:user_id],
      headline: hash[:headline],
      post_text: hash[:post_text],
      date_posted: hash[:date_posted],
      hashtags: hash[:hashtags],
      embedded_links: hash[:embedded_links],
      images: hash[:images],
      videos: hash[:videos],
      likes: hash[:likes],
      comments_count: hash[:comments_count],
      repost: hash[:repost],
      original_post: hash[:original_post],
      raw: hash
    )
  end
end

#videos ⇒ Array<String>? (readonly)

Returns video URLs.

Returns:

  • (Array<String>, nil) —

    video URLs



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
 
# File 'lib/brightdata/linkedin/types/post.rb', line 37

Post = Data.define(
  :id, :user_id, :headline, :post_text, :date_posted, :hashtags,
  :embedded_links, :images, :videos, :likes, :comments_count,
  :repost, :original_post, :raw
) do
  # Build a post from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Post]
  def self.from_api(hash) # rubocop:disable Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      user_id: hash[:user_id],
      headline: hash[:headline],
      post_text: hash[:post_text],
      date_posted: hash[:date_posted],
      hashtags: hash[:hashtags],
      embedded_links: hash[:embedded_links],
      images: hash[:images],
      videos: hash[:videos],
      likes: hash[:likes],
      comments_count: hash[:comments_count],
      repost: hash[:repost],
      original_post: hash[:original_post],
      raw: hash
    )
  end
end

#website ⇒ String? (readonly)

Returns company website.

Returns:

  • (String, nil) —

    company website



53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
 
# File 'lib/brightdata/linkedin/types/company.rb', line 53

Company = Data.define(
  :id, :name, :country_code, :locations, :followers,
  :employees_in_linkedin, :company_size, :industries, :specialties,
  :website, :founded, :company_id, :employees, :similar, :updates,
  :logo, :image, :headquarters, :funding, :investors, :affiliated, :raw
) do
  # Build a company from a symbol-keyed API response.
  #
  # @param hash [Hash] symbolized-key API response object
  # @return [BrightData::LinkedIn::Types::Company]
  def self.from_api(hash) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength -- flat field-by-field mapping from the API response
    new(
      id: hash[:id],
      name: hash[:name],
      country_code: hash[:country_code],
      locations: hash[:locations],
      followers: hash[:followers],
      employees_in_linkedin: hash[:employees_in_linkedin],
      company_size: hash[:company_size],
      industries: hash[:industries],
      specialties: hash[:specialties],
      website: hash[:website],
      founded: hash[:founded],
      company_id: hash[:company_id],
      employees: hash[:employees],
      similar: hash[:similar],
      updates: hash[:updates],
      logo: hash[:logo],
      image: hash[:image],
      headquarters: hash[:headquarters],
      funding: hash[:funding],
      investors: hash[:investors],
      affiliated: hash[:affiliated],
      raw: hash
    )
  end
end