Class: BrightData::LinkedIn::Types::Company

Inherits:
Data
  • Object
show all
Defined in:
lib/brightdata/linkedin/types/company.rb

Overview

Note:

Use #raw to access fields not yet typed by this gem.

Typed representation of a LinkedIn company response.

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Attribute Details

#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

#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_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

#country_code ⇒ String? (readonly)

Returns country code.

Returns:

  • (String, nil) —

    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

#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

#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

#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 company ID.

Returns:

  • (String, nil) —

    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

#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

#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

#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

#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 company name.

Returns:

  • (String, nil) —

    company 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

#raw ⇒ Hash (readonly)

Returns full parsed API response.

Returns:

  • (Hash) —

    full parsed API response



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

#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

#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

#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

Class Method Details

.from_api(hash) ⇒ BrightData::LinkedIn::Types::Company

Build a company from a symbol-keyed API response.

Parameters:

  • hash (Hash) —

    symbolized-key API response object

Returns:



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
 
# File 'lib/brightdata/linkedin/types/company.rb', line 63

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