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 ⇒ Object (readonly)

Returns the value of attribute affiliated

Returns:

  • (Object) —

    the current value of affiliated



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 ⇒ Object (readonly)

Returns the value of attribute company_id

Returns:

  • (Object) —

    the current value of 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 ⇒ Object (readonly)

Returns the value of attribute company_size

Returns:

  • (Object) —

    the current value of 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 ⇒ Object (readonly)

Returns the value of attribute country_code

Returns:

  • (Object) —

    the current value of 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 ⇒ Object (readonly)

Returns the value of attribute employees

Returns:

  • (Object) —

    the current value of 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 ⇒ Object (readonly)

Returns the value of attribute employees_in_linkedin

Returns:

  • (Object) —

    the current value of employees_in_linkedin



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 ⇒ Object (readonly)

Returns the value of attribute followers

Returns:

  • (Object) —

    the current value of followers



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 ⇒ Object (readonly)

Returns the value of attribute founded

Returns:

  • (Object) —

    the current value of founded



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 ⇒ Object (readonly)

Returns the value of attribute funding

Returns:

  • (Object) —

    the current value of funding



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 ⇒ Object (readonly)

Returns the value of attribute headquarters

Returns:

  • (Object) —

    the current value of 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 ⇒ Object (readonly)

Returns the value of attribute id

Returns:

  • (Object) —

    the current value of 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 ⇒ Object (readonly)

Returns the value of attribute image

Returns:

  • (Object) —

    the current value of image



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 ⇒ Object (readonly)

Returns the value of attribute industries

Returns:

  • (Object) —

    the current value of 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 ⇒ Object (readonly)

Returns the value of attribute investors

Returns:

  • (Object) —

    the current value of 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 ⇒ Object (readonly)

Returns the value of attribute locations

Returns:

  • (Object) —

    the current value of 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 ⇒ Object (readonly)

Returns the value of attribute logo

Returns:

  • (Object) —

    the current value of logo



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 ⇒ Object (readonly)

Returns the value of attribute name

Returns:

  • (Object) —

    the current value of 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 ⇒ Object (readonly)

Returns the value of attribute raw

Returns:

  • (Object) —

    the current value of raw



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 ⇒ Object (readonly)

Returns the value of attribute similar

Returns:

  • (Object) —

    the current value of similar



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 ⇒ Object (readonly)

Returns the value of attribute specialties

Returns:

  • (Object) —

    the current value of 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 ⇒ Object (readonly)

Returns the value of attribute updates

Returns:

  • (Object) —

    the current value of 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 ⇒ Object (readonly)

Returns the value of attribute website

Returns:

  • (Object) —

    the current value of 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