linkedin-member-data 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: fffdb2d428be752a12be1d391449f8572a2b4d50be3209ef9fed96b3feadf6db
+  data.tar.gz: 6a0912ba3cefa423ef0de9c86d328f7186b1be45e687a3c1cd9bee95d6adea6d
+SHA512:
+  metadata.gz: 1c4e4d4bdfb3a8e4d43e5b08aae421dbd7813d81d332ae055749f4dfc054cfb8922f2105cdc954d4e152fc5828458a5a19a43240c929b27c671a75a7ed451969
+  data.tar.gz: 1102dc284b5355f43ddbcd0ef4d1606cb1cd98473e1a197ec79b884d1a5dc650860c03a8a7551bbbe498f849c7da511540f6eb023e63c2fecade8471ce51f637

data/CHANGELOG.md

@@ -0,0 +1,9 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-10-06
+
+- Initial release: Client, Snapshot, Changelog, Authorization, CLI.
+- Retries on 429, 5xx and network errors. `Retry-After` is capped at 60 seconds.
+- `ConnectionError` for network failures after retries.
+- `Changelog` skips the overlap event and resumes with `Event#processed_at_ms`.
+- CLI exit codes: 0 success, 1 API error, 2 usage error.

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,10 @@
+# Code of Conduct
+
+"linkedin-member-data" follows [The Ruby Community Conduct Guideline](https://www.ruby-lang.org/en/conduct) in all "collaborative space", which is defined as community communications channels (such as mailing lists, submitted patches, commit comments, etc.):
+
+* Participants will be tolerant of opposing views.
+* Participants must ensure that their language and actions are free of personal attacks and disparaging personal remarks.
+* When interpreting the words and actions of others, participants should always assume good intentions.
+* Behaviour which can be reasonably considered harassment will not be tolerated.
+
+If you have any concerns about behaviour within this project, please contact us at [lucianghinda@users.noreply.github.com](mailto:lucianghinda@users.noreply.github.com).

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2026 Lucian Ghinda
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,186 @@
+# linkedin-member-data
+
+Ruby client and CLI for the LinkedIn [Member Data Portability (Member) API](https://learn.microsoft.com/en-us/linkedin/dma/member-data-portability/member-data-portability-member/). Download your own LinkedIn data: 66 snapshot domains (profile, connections, messages, posts, ...) and the changelog of your activity from the last 28 days.
+
+Zero runtime dependencies. Ruby 3.2+.
+
+## Installation
+
+```bash
+bundle add linkedin-member-data
+```
+
+Or install the CLI only:
+
+```bash
+gem install linkedin-member-data
+```
+
+## Getting a token
+
+1. Create an app in the [LinkedIn Developer Portal](https://www.linkedin.com/developers/apps/) using the [Member Data Portability (Member) Default Company](https://www.linkedin.com/company/member-data-portability-member-default-company) page.
+2. Under Products, request access to **Member Data Portability API (Member)**.
+3. Open **Docs and tools > OAuth Token Tools**, create a token with scope `r_dma_portability_self_serve`, and consent.
+
+Tokens last 60 days. Only EEA and Swiss members can consent today.
+
+## Quick start
+
+```ruby
+require "linkedin/member_data"
+
+client = LinkedIn::MemberData::Client.new(access_token: ENV["LINKEDIN_ACCESS_TOKEN"])
+
+client.snapshot(:connections).each do |row|
+  puts row["First Name"], row["Company"]
+end
+
+client.changelog(since: Time.now - 7 * 86_400).each do |event|
+  puts "#{event.method} #{event.resource_name} at #{event.processed_at}"
+end
+```
+
+Row keys differ per domain. These are CONNECTIONS keys.
+
+## Snapshot
+
+```ruby
+snap = client.snapshot(:profile)       # symbol is upcased: "PROFILE"
+snap = client.snapshot("ALL_COMMENTS") # strings are sent as given
+snap = client.snapshot                 # all domains
+
+snap.first                             # first row, fetches one page
+snap.to_a                              # every row, walks all pages
+snap.lazy.select { |row| row["Company"] }.first(5)  # Enumerable, so anything goes
+
+snap.pages.each do |page|
+  page.domain; page.rows; page.start; page.count; page.total; page.next?; page.raw
+end
+
+snap.page(0)                           # one page by index, no walking. Raises past the end.
+
+LinkedIn::MemberData::Domains::ALL     # list of domain names
+```
+
+Rows are plain Hashes with the keys LinkedIn returns, for example `"First Name"`. Keys differ per domain.
+
+Pages are walked until LinkedIn answers "No data found for this memberId". That answer ends iteration and is not raised. A page with no rows also ends iteration.
+
+## Changelog
+
+```ruby
+log = client.changelog(since: Date.new(2026, 9, 1), count: 10)   # since: Time, Date or epoch ms; count: 1..50
+
+log.each do |event|
+  event.id; event.method; event.resource_name; event.resource_id
+  event.captured_at; event.processed_at        # Time (UTC)
+  event.activity; event.processed_activity     # Hash
+  event.raw                                    # the original Hash
+end
+
+log.pages.each { |page| page.events; page.next_start_time }
+```
+
+The API returns the cursor event again on the next page. The gem skips events it has already seen. Iteration stops when a page has no new events, or when the last event has no `processedAt`.
+
+`event.method` is the API field (`CREATE`, `UPDATE`, ...). It shadows Ruby's `Object#method` on purpose, so `event.method(:name)` does not work on an Event.
+
+`count` defaults to 10. A value outside 1..50 raises `ArgumentError` before any request.
+
+Event fields: `id, activity_id, activity_status, config_version, owner, actor, resource_name, resource_id, resource_uri, method, method_name, captured_at, processed_at, activity, processed_activity, sibling_activities, parent_sibling_activities, raw`.
+
+Known limit: when more than `count` events share one `processedAt`, the cursor cannot reach the rest. Raise `count` (max 50) to reduce the chance.
+
+To resume later, store the last `event.processed_at_ms` and pass it as `since:`.
+
+```ruby
+last_seen = client.changelog.to_a.last&.processed_at_ms
+client.changelog(since: last_seen).each { |event| puts event.id }
+```
+
+## Authorization
+
+```ruby
+client.authorization        # => Authorization or nil
+client.authorization.regulated_at
+client.enable_changelog!    # start changelog archiving (usually automatic)
+```
+
+`Authorization` also has `member`, `developer_application`, `scopes` and `raw`.
+
+## Options
+
+```ruby
+require "logger"
+
+LinkedIn::MemberData::Client.new(
+  access_token: "...",
+  retries: 3,       # retries on 429, 5xx and network errors, with backoff; 0 disables
+  timeout: 30,      # seconds
+  logger: Logger.new($stderr)  # logs "GET url -> status" at debug level
+)
+```
+
+Retries wait for `Retry-After` when it is present, capped at 60 seconds. Otherwise the wait grows with each try (exponential backoff).
+
+## Errors
+
+```
+LinkedIn::MemberData::Error
+  ConfigurationError           # missing token
+  ConnectionError              # network failure after retries
+  ApiError                     # status, code, body
+    Unauthorized Forbidden NotFound VersionError RateLimited ServerError
+```
+
+`ConnectionError` covers timeouts, reset connections, DNS and TLS failures. `retryable?` is true for `RateLimited`, `ServerError` and `ConnectionError`. `ApiError#code` comes from `serviceErrorCode` or `code` in the response body. `RateLimited#retry_after` is nil when the header is absent.
+
+```ruby
+begin
+  client.snapshot(:profile).to_a
+rescue LinkedIn::MemberData::Unauthorized
+  warn "Token is invalid or expired"
+rescue LinkedIn::MemberData::ApiError => error
+  warn "#{error.status}: #{error.message}"
+end
+```
+
+## CLI
+
+```bash
+export LINKEDIN_ACCESS_TOKEN=...
+
+linkedin-member-data snapshot CONNECTIONS --out connections.json
+linkedin-member-data snapshot --all --out-dir ./export
+linkedin-member-data changelog --since 2026-09-01 --count 50 --out changelog.json
+linkedin-member-data domains
+linkedin-member-data auth
+linkedin-member-data version
+```
+
+Use `-h` or `--help` to print usage. The DOMAIN argument is upcased, so `snapshot connections` works. The token comes from `--token TOKEN` (before or after the command) or `LINKEDIN_ACCESS_TOKEN`. Data goes to stdout or `--out FILE`. Progress and errors go to stderr. `--since` takes an ISO date (midnight UTC) or an ISO datetime.
+
+`snapshot --all` writes one `<DOMAIN>.json` per domain. Without `--out-dir DIR` it is a usage error (exit 2). A failing domain is reported and the run continues. The exit code is 1 at the end. Unauthorized and Forbidden stop the run, because a bad token fails every domain.
+
+`auth` exits 1 with "No authorization found for this token" when none exists.
+
+Exit codes: 0 success, 1 API error, network error or file write error, 2 usage error.
+
+## Development
+
+```bash
+bin/setup
+bundle exec rake               # tests + rubocop
+bundle exec rake branchproof   # MC/DC coverage (Ruby 4.0+)
+bundle exec rake quality       # quality_gate fast, verify, audit
+bundle exec rake docs          # YARD Markdown docs in doc/ and llms.txt
+ruby bin/prepare_release       # full gate, then builds pkg/<gem>.gem
+```
+
+## For AI agents
+
+The gem ships its API reference as Markdown. Start at `llms.txt` in the gem root, which links every page under `doc/`. The same files are inside the installed gem (`gem contents linkedin-member-data | grep doc/`).
+
+## License
+
+MIT

data/doc/CHANGELOG.md

@@ -0,0 +1,9 @@
+## [Unreleased]
+
+## [0.1.0] - 2026-10-06
+
+- Initial release: Client, Snapshot, Changelog, Authorization, CLI.
+- Retries on 429, 5xx and network errors. `Retry-After` is capped at 60 seconds.
+- `ConnectionError` for network failures after retries.
+- `Changelog` skips the overlap event and resumes with `Event#processed_at_ms`.
+- CLI exit codes: 0 success, 1 API error, 2 usage error.

data/doc/LinkedIn/MemberData/ApiError.md

@@ -0,0 +1,52 @@
+# Class LinkedIn::MemberData::ApiError <a id="class-LinkedIn-MemberData-ApiError"></a>
+
+|  |  |
+| --- | --- |
+| **Inherits** | [LinkedIn::MemberData::Error](Error.md) |
+| **Defined in** | lib/linkedin/member_data/errors.rb |
+
+Defined last because the classes must exist first.
+
+## Constants
+### `STATUS_CLASSES` <a id="constant-STATUS_CLASSES"></a> <a id="STATUS_CLASSES-constant"></a>
+HTTP status => error class. Other statuses use `ServerError` (5xx) or
+`ApiError`.
+- **@api** private
+
+## Attributes
+### `body` [R] <a id="attribute-i-body"></a> <a id="body-instance_method"></a>
+Details of the failed response. `status` is the HTTP status code (Integer).
+`code` is `serviceErrorCode` or `code` from the body (Integer or String, nil
+when the body has neither). `body` is the parsed JSON body (nil when the body
+is empty, not JSON, or not an object).
+- **@return** [Integer, String, Hash, nil] `status`, `code` or `body`.
+
+### `code` [R] <a id="attribute-i-code"></a> <a id="code-instance_method"></a>
+Details of the failed response. `status` is the HTTP status code (Integer).
+`code` is `serviceErrorCode` or `code` from the body (Integer or String, nil
+when the body has neither). `body` is the parsed JSON body (nil when the body
+is empty, not JSON, or not an object).
+- **@return** [Integer, String, Hash, nil] `status`, `code` or `body`.
+
+### `status` [R] <a id="attribute-i-status"></a> <a id="status-instance_method"></a>
+Details of the failed response. `status` is the HTTP status code (Integer).
+`code` is `serviceErrorCode` or `code` from the body (Integer or String, nil
+when the body has neither). `body` is the parsed JSON body (nil when the body
+is empty, not JSON, or not an object).
+- **@return** [Integer, String, Hash, nil] `status`, `code` or `body`.
+
+## Public Instance Methods
+### `initialize(message, status:, code: = nil, body: = nil)` <a id="method-i-initialize"></a> <a id="initialize-instance_method"></a>
+- **@param** `message` [String] `message` from the body, or "HTTP <status>".
+- **@param** `status` [Integer] HTTP status code.
+- **@param** `code` [Integer, String, nil] error code from the body.
+- **@param** `body` [Hash, nil] parsed response body.
+- **@return** [ApiError] a new instance of ApiError
+
+### `retry_after()` <a id="method-i-retry_after"></a> <a id="retry_after-instance_method"></a>
+Only RateLimited knows a Retry-After. Others let the backoff decide.
+- **@return** [nil]
+
+### `retryable?()` <a id="method-i-retryable-3F"></a> <a id="retryable?-instance_method"></a>
+Tells if a retry may help. False for most API errors.
+- **@return** [Boolean]

data/doc/LinkedIn/MemberData/Authorization.md

@@ -0,0 +1,30 @@
+# Class LinkedIn::MemberData::Authorization <a id="class-LinkedIn-MemberData-Authorization"></a>
+
+|  |  |
+| --- | --- |
+| **Inherits** | Data |
+| **Defined in** | lib/linkedin/member_data/authorization.rb |
+
+The member's authorization record from `memberAuthorizations`. Immutable.
+
+## Attributes
+### `developer_application` [R] <a id="attribute-i-developer_application"></a> <a id="developer_application-instance_method"></a>
+- **@return** [String, nil] developer application, as sent by the API.
+
+### `member` [R] <a id="attribute-i-member"></a> <a id="member-instance_method"></a>
+- **@return** [String, nil] member, as sent by the API.
+
+### `raw` [R] <a id="attribute-i-raw"></a> <a id="raw-instance_method"></a>
+- **@return** [Hash] the original element from the API.
+
+### `regulated_at` [R] <a id="attribute-i-regulated_at"></a> <a id="regulated_at-instance_method"></a>
+- **@return** [Time, nil] when the member gave consent. UTC.
+
+### `scopes` [R] <a id="attribute-i-scopes"></a> <a id="scopes-instance_method"></a>
+- **@return** [Array<String>] granted scopes. Empty when the API sends none.
+
+## Public Class Methods
+### `from_api(hash)` <a id="method-c-from_api"></a> <a id="from_api-class_method"></a>
+Builds an authorization from one element of the API response.
+- **@param** `hash` [Hash] one element of `elements` from the `memberAuthorizations` response.
+- **@return** [Authorization]

data/doc/LinkedIn/MemberData/Changelog/Page.md

@@ -0,0 +1,28 @@
+# Class LinkedIn::MemberData::Changelog::Page <a id="class-LinkedIn-MemberData-Changelog-Page"></a>
+
+|  |  |
+| --- | --- |
+| **Inherits** | Data |
+| **Defined in** | lib/linkedin/member_data/changelog/page.rb |
+
+One response page of changelog events. Immutable.
+
+## Attributes
+### `events` [R] <a id="attribute-i-events"></a> <a id="events-instance_method"></a>
+- **@return** [Array<Event>] events of this page, in API order (oldest first).
+
+### `raw` [R] <a id="attribute-i-raw"></a> <a id="raw-instance_method"></a>
+- **@return** [Hash] the parsed response body.
+
+## Public Class Methods
+### `from_api(raw)` <a id="method-c-from_api"></a> <a id="from_api-class_method"></a>
+Builds a page from a parsed response body. A missing `elements` key gives no
+events.
+- **@param** `raw` [Hash] parsed JSON body of the API response.
+- **@return** [Changelog::Page]
+
+## Public Instance Methods
+### `next_start_time()` <a id="method-i-next_start_time"></a> <a id="next_start_time-instance_method"></a>
+Cursor for the next request: `processedAt` of the last event, in epoch
+milliseconds.
+- **@return** [Integer, nil] `nil` when the page has no events or the last event has no `processedAt`.

data/doc/LinkedIn/MemberData/Changelog.md

@@ -0,0 +1,96 @@
+# Class LinkedIn::MemberData::Changelog <a id="class-LinkedIn-MemberData-Changelog"></a>
+
+|  |  |
+| --- | --- |
+| **Inherits** | Object |
+| **Includes** | Enumerable |
+| **Defined in** | lib/linkedin/member_data/changelog.rb, lib/linkedin/member_data/changelog/page.rb |
+
+Lazy view over `GET /rest/memberChangeLogs` (last 28 days). Nothing is fetched
+until you iterate. Each iteration starts a new walk.
+
+The cursor is `startTime` = last `processedAt` seen. LinkedIn returns the
+cursor event again on the next page, so events already seen are skipped and
+iteration stops when a page brings nothing new, or when the last event has no
+processedAt (the cursor cannot move).
+
+Known limit: if more than `count` events share one processedAt, the ones
+beyond the first page are not reachable through the cursor. A higher `count`
+(max 50) makes this less likely.
+
+It includes `Enumerable`, so `first`, `to_a`, `lazy`, `select` and the rest
+work on events.
+
+**@example Print recent events**
+```ruby
+client.changelog(since: Time.now - 7 * 86_400).each do |event|
+  puts "#{event.method} #{event.resource_name} at #{event.processed_at}"
+end
+```
+
+## Constants
+### `COUNT_RANGE` <a id="constant-COUNT_RANGE"></a> <a id="COUNT_RANGE-constant"></a>
+Allowed values for `count`.
+- **@return** [Range<Integer>]
+
+### `DEFAULT_COUNT` <a id="constant-DEFAULT_COUNT"></a> <a id="DEFAULT_COUNT-constant"></a>
+Default for `count`.
+- **@return** [Integer]
+
+### `PATH` <a id="constant-PATH"></a> <a id="PATH-constant"></a>
+API path of the changelog resource.
+- **@return** [String]
+
+## Attributes
+### `count` [R] <a id="attribute-i-count"></a> <a id="count-instance_method"></a>
+Settings of this view. `since` is the first `processedAt` to fetch, in epoch
+milliseconds (`nil` starts at the oldest event). `count` is the number of
+events per request, from 1 to 50.
+- **@return** [Integer, nil] `since` or `count`. `count` is never nil.
+
+### `since` [R] <a id="attribute-i-since"></a> <a id="since-instance_method"></a>
+Settings of this view. `since` is the first `processedAt` to fetch, in epoch
+milliseconds (`nil` starts at the oldest event). `count` is the number of
+events per request, from 1 to 50.
+- **@return** [Integer, nil] `since` or `count`. `count` is never nil.
+
+## Public Instance Methods
+### `each(&block)` <a id="method-i-each"></a> <a id="each-instance_method"></a>
+Yields every new event of every page, oldest first. Pages are fetched one by
+one while you iterate.
+- **@raise** [ApiError] on a non-2xx response.
+- **@raise** [ConnectionError] on a network failure after all retries.
+- **@return** [Changelog] self, when a block is given.
+- **@return** [Enumerator<Event>] when no block is given.
+- **@yieldparam** `event` [Event] one changelog event. Events already seen in the overlap are skipped.
+
+**@example**
+```ruby
+client.changelog(count: 50).each { |event| puts event.id }
+```
+
+**@example Without a block, you get an Enumerator**
+```ruby
+client.changelog.each.first(5)
+```
+
+### `page(start_time)` <a id="method-i-page"></a> <a id="page-instance_method"></a>
+Fetches one raw page. No overlap handling, so the cursor event comes back
+again.
+- **@param** `start_time` [Integer, nil] cursor in epoch milliseconds. `nil` starts at the oldest event.
+- **@raise** [ApiError] on a non-2xx response.
+- **@raise** [ConnectionError] on a network failure after all retries.
+- **@return** [Changelog::Page]
+
+### `pages()` <a id="method-i-pages"></a> <a id="pages-instance_method"></a>
+Lazy Enumerator of pages with already-seen events removed. Stops on the first
+page with no new events, or when the last event has no `processedAt`. A
+yielded Page has filtered `events` but the unfiltered `raw` response.
+- **@raise** [ApiError] while iterating, on a non-2xx response.
+- **@raise** [ConnectionError] while iterating, on a network failure after all retries.
+- **@return** [Enumerator<Changelog::Page>]
+
+**@example Cursor of each page**
+```ruby
+client.changelog.pages.each { |page| puts "#{page.events.size} events, next #{page.next_start_time}" }
+```

data/doc/LinkedIn/MemberData/Client.md

@@ -0,0 +1,97 @@
+# Class LinkedIn::MemberData::Client <a id="class-LinkedIn-MemberData-Client"></a>
+
+|  |  |
+| --- | --- |
+| **Inherits** | Object |
+| **Defined in** | lib/linkedin/member_data/client.rb |
+
+Entry point of the gem. Holds one `Connection`.
+
+**@example Create a client and read a snapshot**
+```ruby
+client = LinkedIn::MemberData::Client.new(access_token: ENV["LINKEDIN_ACCESS_TOKEN"])
+client.snapshot(:connections).each { |row| puts row["First Name"] }
+```
+
+## Constants
+### `AUTHORIZATIONS_PATH` <a id="constant-AUTHORIZATIONS_PATH"></a> <a id="AUTHORIZATIONS_PATH-constant"></a>
+API path of the member authorizations resource.
+- **@return** [String]
+
+## Public Instance Methods
+### `authorization()` <a id="method-i-authorization"></a> <a id="authorization-instance_method"></a>
+Fetches the authorization record of the token. Sends one request.
+- **@raise** [ApiError] on a non-2xx response, for example `Unauthorized` for a bad token.
+- **@raise** [ConnectionError] on a network failure after all retries.
+- **@return** [Authorization, nil] `nil` when LinkedIn returns no authorization.
+
+**@example**
+```ruby
+authorization = client.authorization
+puts authorization.regulated_at if authorization
+```
+
+### `changelog(since: = nil, count: = Changelog::DEFAULT_COUNT)` <a id="method-i-changelog"></a> <a id="changelog-instance_method"></a>
+Returns a lazy view over the changelog of the last 28 days. No request is sent
+until you iterate.
+- **@param** `since` [Time, Date, Integer, nil] first `processedAt` to fetch.
+Integer is epoch milliseconds. A Date is midnight UTC. `nil` starts at the oldest event.
+- **@param** `count` [Integer] events per request, from 1 to 50.
+- **@raise** [ArgumentError] when `count` is outside 1..50 or `since` has an unsupported type.
+Raised before any request.
+- **@return** [Changelog]
+
+**@example Events of the last 7 days**
+```ruby
+client.changelog(since: Time.now - 7 * 86_400).each do |event|
+  puts "#{event.method} #{event.resource_name} at #{event.processed_at}"
+end
+```
+
+**@example Resume from the last event you saw**
+```ruby
+last_seen = client.changelog.to_a.last&.processed_at_ms
+client.changelog(since: last_seen).each { |event| puts event.id }
+```
+
+### `enable_changelog!()` <a id="method-i-enable_changelog-21"></a> <a id="enable_changelog!-instance_method"></a>
+Starts changelog archiving for the member. LinkedIn usually does this by
+itself.
+- **@raise** [ApiError] on a non-2xx response.
+- **@raise** [ConnectionError] on a network failure after all retries.
+- **@return** [true] always true. API failures raise.
+
+**@example**
+```ruby
+client.enable_changelog!  # => true
+```
+
+### `initialize(access_token:, retries: = 3, timeout: = 30, logger: = nil, connection: = nil)` <a id="method-i-initialize"></a> <a id="initialize-instance_method"></a>
+Builds a client. No request is sent.
+- **@param** `access_token` [String] OAuth token with scope `r_dma_portability_self_serve`.
+Leading and trailing spaces are removed.
+- **@param** `retries` [Integer] retries on 429, 5xx and network errors, with backoff. `0` turns retries off.
+- **@param** `timeout` [Integer, Float] open, read and write timeout in seconds.
+- **@param** `logger` [Logger, nil] gets one debug line per request: `GET url -> status`.
+- **@param** `connection` [Connection, nil] ready-made connection. When given, `retries`, `timeout`
+and `logger` are not used. Meant for tests.
+- **@raise** [ConfigurationError] when `access_token` is nil or blank.
+- **@return** [Client] a new instance of Client
+
+### `snapshot(domain = nil)` <a id="method-i-snapshot"></a> <a id="snapshot-instance_method"></a>
+Returns a lazy view over snapshot data. No request is sent until you iterate.
+- **@param** `domain` [Symbol, String, nil] a name from `Domains::ALL`. A Symbol is upcased.
+A String is sent as given, because the API is case sensitive. `nil` means all domains.
+- **@raise** [ArgumentError] when `domain` is not a Symbol, a String or nil.
+- **@return** [Snapshot]
+
+**@example One domain, symbol or string**
+```ruby
+client.snapshot(:profile).first     # symbol is upcased: "PROFILE"
+client.snapshot("ALL_COMMENTS").to_a
+```
+
+**@example All domains**
+```ruby
+client.snapshot.each { |row| puts row.keys.inspect }
+```

data/doc/LinkedIn/MemberData/ConfigurationError.md

@@ -0,0 +1,8 @@
+# Class LinkedIn::MemberData::ConfigurationError <a id="class-LinkedIn-MemberData-ConfigurationError"></a>
+
+|  |  |
+| --- | --- |
+| **Inherits** | [LinkedIn::MemberData::Error](Error.md) |
+| **Defined in** | lib/linkedin/member_data/errors.rb |
+
+Missing or empty access token.

data/doc/LinkedIn/MemberData/ConnectionError.md

@@ -0,0 +1,15 @@
+# Class LinkedIn::MemberData::ConnectionError <a id="class-LinkedIn-MemberData-ConnectionError"></a>
+
+|  |  |
+| --- | --- |
+| **Inherits** | [LinkedIn::MemberData::Error](Error.md) |
+| **Defined in** | lib/linkedin/member_data/errors.rb |
+
+Network failure after all retries (timeouts, reset connections).
+
+## Public Instance Methods
+### `retry_after()` <a id="method-i-retry_after"></a> <a id="retry_after-instance_method"></a>
+- **@return** [nil] there is no Retry-After header, so the backoff decides.
+
+### `retryable?()` <a id="method-i-retryable-3F"></a> <a id="retryable?-instance_method"></a>
+- **@return** [true] network errors are worth a retry.

data/doc/LinkedIn/MemberData/Domains.md

@@ -0,0 +1,22 @@
+# Module LinkedIn::MemberData::Domains <a id="module-LinkedIn-MemberData-Domains"></a>
+
+|  |  |
+| --- | --- |
+| **Defined in** | lib/linkedin/member_data/domains.rb |
+
+Snapshot domains documented at
+https://learn.microsoft.com/en-us/linkedin/dma/member-data-portability/shared/
+snapshot-domain The API is case sensitive. Strings are sent as given; symbols
+are upcased.
+
+## Constants
+### `ALL` <a id="constant-ALL"></a> <a id="ALL-constant"></a>
+Names of all snapshot domains. Pass one to `Client#snapshot`.
+- **@return** [Array<String>]
+
+## Public Class Methods
+### `normalize(domain)` <a id="method-c-normalize"></a> <a id="normalize-class_method"></a>
+Turns a domain argument into the name sent to the API.
+- **@param** `domain` [Symbol, String, nil] a Symbol is upcased. A String is returned as given. `nil` stays `nil`.
+- **@raise** [ArgumentError] when `domain` is not a Symbol, a String or nil.
+- **@return** [String, nil]

data/doc/LinkedIn/MemberData/Error.md

@@ -0,0 +1,8 @@
+# Class LinkedIn::MemberData::Error <a id="class-LinkedIn-MemberData-Error"></a>
+
+|  |  |
+| --- | --- |
+| **Inherits** | StandardError |
+| **Defined in** | lib/linkedin/member_data/errors.rb |
+
+Base class of every error this gem raises on purpose.