calendlyr 0.10.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 201abcc548a1e1a59386fefc1416cf05e91dc28c83e7cc057c7a5c207eef4f1d
-  data.tar.gz: 94aee4dc1740d031eea51a32309225340178ee2ec59fdcf4987b7413eacb8bd2
+  metadata.gz: ca7216a6bc050ebad873636af0bb988c8841d7828fe6cebc0a0497947c0a9dc7
+  data.tar.gz: e36f58a64ad9277fdd38bb44fe69aeb4e7d84fe10fb6b9274a474bb609406340
 SHA512:
-  metadata.gz: 7837b5d47c2e989c5d2221e344269713427efd21639a8b5a23ff7a85e0a8baff2eebfa028469c1e17d1bb353eac2dfb5346747de63653d564c312d03cb3dd77a
-  data.tar.gz: d13ae93dd51ac622139c19c2bbd9e328a8dd2275c5a1fcce3b825a08291b33139831ddae74256a1a39a2d25f9d541bf5b6656ab8b293b54d717302812f0c7ec5
+  metadata.gz: 36c382f6725f7fdc22acfd11bee564dbcd5c448df265f49d07c450e074ab23c3a1f165970e4f5f925feebbcfbd7f3dae827ecc144a5ca0fb0c0524f9dcaa2d3c
+  data.tar.gz: 2e60e92afb872bb9590cda26e3208ed1bed7f069ea644a55738c5c6284447241c0c90358ff2a19d1e3c1149a790db2e69648c8ed945cd9ed6e4a9ed36526d575

data/.gitignore

@@ -24,3 +24,4 @@ vendor
 .idea/
 bin/my_console
 .atl/*
+.DS_Store

data/CHANGELOG.md

@@ -2,9 +2,46 @@
 
 All notable changes to this project will be documented in this file.
 
+## [1.0.0]
+
+### Added
+* Auto-pagination via `Enumerator::Lazy` — `collection.auto_paginate` returns a lazy enumerator that traverses all pages on demand without pre-fetching. Compose with `.take(n)`, `.select { }`, `.map { }`, etc.
+* `#next_page` method on `Collection` — returns the next page as a new `Collection`, or `nil` when there are no more pages.
+* `#next_page_url` attr_reader on `Collection` — exposes the raw next-page URL string.
+* `list_all` convenience methods on every resource with list endpoints:
+  - `client.events.list_all`, `client.events.list_all_invitees`
+  - `client.event_types.list_all`, `client.event_types.list_all_availability_schedules`, `client.event_types.list_all_memberships`
+  - `client.organizations.list_all_memberships`, `client.organizations.list_all_invitations`, `client.organizations.list_all_activity_log`
+  - `client.groups.list_all`, `client.groups.list_all_relationships`
+  - `client.availability.list_all_user_busy_times`, `client.availability.list_all_user_schedules`
+  - `client.routing_forms.list_all`, `client.routing_forms.list_all_submissions`
+  - `client.webhooks.list_all`
+  - `client.locations.list_all`
+  - `client.outgoing_communications.list_all`
+* `GET /event_type_available_times` — `client.event_types.list_available_times(event_type:, start_time:, end_time:)` returns a `Collection` of `EventTypes::AvailableTime` objects. No pagination (not supported by this endpoint).
+* `GET /event_type_memberships` — `client.event_types.list_memberships(event_type:)` and `list_all_memberships`. Returns `EventTypes::Membership` objects.
+* `POST /scheduling_links` — `client.scheduling_links.create(owner:, owner_type:, max_event_count:)` returns a `SchedulingLink` object. Bare UUID expansion for `owner`.
+* `GET /organizations/{uuid}` — `client.organizations.retrieve(uuid:)` returns an `Organization` object.
+* `GET /outgoing_communications` — `client.outgoing_communications.list(organization:)` and `list_all`. Returns `OutgoingCommunication` objects.
+* `GET /sample_webhook_data` — `client.webhooks.sample(event:, organization:, scope:)` returns the raw response hash (shape varies by event type).
+
+### Changed — Breaking
+* **`Collection#next_page`** (attr_reader returning the raw URL string) is now **`Collection#next_page_url`**. If you were reading the raw next-page URL via `collection.next_page`, change to `collection.next_page_url`.
+* **`Collection#next_page`** is now a **method** that returns the next `Collection` object (or `nil`), not the raw URL string.
+
+### Notes
+* Version 1.0.0 signals complete Calendly API v2 coverage. All documented endpoints are now implemented.
+* Changes originally prepared for an unreleased `0.11.0` were shipped as part of `1.0.0`.
+
+[1.0.0]: https://github.com/araluce/calendlyr/compare/v0.10.0...v1.0.0
+
 ## [0.10.0]
 
 ### Added
+* `Calendlyr::Webhook.verify!`, `valid?`, and `parse` — verify signed webhook payloads with HMAC-SHA256, optional timestamp tolerance, and typed payload parsing
+* `Calendlyr.configure`, `Calendlyr.configuration`, `Calendlyr.client`, and `Calendlyr.reset!` — module-level global configuration and default client support with token/timeout settings
+* Optional request/response logging via `Client.new(logger:)` or `Calendlyr.configure { |c| c.logger = ... }` — INFO for method/URL/status/duration, DEBUG for response body (truncated), WARN for retries, ERROR for API errors. Authorization header is never logged.
+* `Object#to_json` — Serialize any API object to JSON. Works with `JSON.generate`, nested objects, and arrays. The internal `client` reference is automatically excluded from serialization.
 * `client.data_compliance.delete_scheduled_event_data` — Remove scheduled events data within a time range (`POST /data_compliance/deletion/events`)
 * `put_request` support in `Resource` base class for PUT HTTP verb
 * `Collection` now includes `Enumerable` — use `each`, `map`, `select` directly on collections
@@ -17,6 +54,7 @@ All notable changes to this project will be documented in this file.
 * Requires Ruby >= 3.2.0 (dropped support for Ruby 2.4–3.1)
 
 ### Fixed
+* Error messages now include request context (`GET /path`) and expose structured attributes on `Calendlyr::Error` (`status`, `http_method`, `path`, `response_body`) for easier debugging
 * **Security:** Removed `OpenSSL::SSL::VERIFY_NONE` — SSL connections now properly verify certificates
 * **Security:** Bare `rescue` replaced with `rescue JSON::ParserError` — non-JSON errors are no longer silently swallowed
 * `Invitee#cancel` now correctly uses the event UUID instead of the invitee UUID

data/README.md

@@ -5,10 +5,14 @@
 
 # Calendlyr
 
-The simplest way to interact with [Calendly's API v2](https://developer.calendly.com/api-docs) in Ruby. No dependencies, no complexity — just a Personal Access Token and you're good to go.
+![Calendlyr logo](logos/calendlyr_bg_white.png)
+
+The simplest way to interact with [Calendly's API v2](https://developer.calendly.com/api-docs) in Ruby. No runtime dependencies, no ceremony — just a Personal Access Token and you're good to go.
 
 ## Installation
 
+Calendlyr requires **Ruby >= 3.2.0**.
+
 Add to your Gemfile:
 
 ```ruby
@@ -22,8 +26,8 @@ Then run `bundle install`. That's it.
 ```ruby
 client = Calendlyr::Client.new(token: ENV["CALENDLY_TOKEN"])
 
-# List your scheduled events
-events = client.events.list(user: "https://api.calendly.com/users/YOUR_USER_UUID")
+# List your scheduled events — just pass the UUID, no full URI needed
+events = client.events.list(user: "YOUR_USER_UUID")
 events.data
 #=> [#<Calendlyr::Event>, #<Calendlyr::Event>, ...]
 
@@ -38,15 +42,195 @@ invitees = client.events.list_invitees(uuid: event.uuid)
 invitees.data.first.email  #=> "john@example.com"
 ```
 
+## Global configuration
+
+For single-tenant apps, you can configure `Calendlyr` once and reuse a default client:
+
+```ruby
+Calendlyr.configure do |config|
+  config.token = ENV.fetch("CALENDLY_TOKEN")
+  config.open_timeout = 5
+  config.read_timeout = 15
+end
+
+client = Calendlyr.client
+events = client.events.list(user: "YOUR_USER_UUID")
+```
+
+`Calendlyr.client` memoizes a client instance and rebuilds it if token or timeout values change.
+
+### Optional request/response logging
+
+Calendlyr can emit request lifecycle logs with any logger-like object that responds to `info`, `debug`, `warn`, and `error`. Logging is opt-in, and the gem does not ship a logger implementation for you.
+
+```ruby
+require "logger"
+
+client = Calendlyr::Client.new(token: ENV["CALENDLY_TOKEN"], logger: Logger.new($stdout))
+```
+
+`Logger` is just an example. You can pass any object that responds to `info`, `debug`, `warn`, and `error`.
+
+If you're on Ruby 4 and want to use Ruby's `Logger`, make sure your application includes the `logger` gem.
+
+Or configure it globally:
+
+```ruby
+Calendlyr.configure do |config|
+  config.token = ENV.fetch("CALENDLY_TOKEN")
+  config.logger = Logger.new($stdout)
+end
+```
+
+In Rails, this is typically configured in an initializer:
+
+```ruby
+# config/initializers/calendlyr.rb
+Calendlyr.configure do |config|
+  config.token = ENV.fetch("CALENDLY_TOKEN")
+end
+```
+
+> [!IMPORTANT]
+> `Calendlyr.client` is module-global and **not thread-safe for multi-tenant usage**.
+> If your app serves multiple tenants or uses per-request credentials, use `Calendlyr::Client.new(token:)` per request.
+
+### Bare UUIDs
+
+Most methods that take a Calendly resource reference (like `user:`, `organization:`, `event_type:`, or `owner:`) accept both bare UUIDs and full URIs. When supported, the gem expands bare UUIDs automatically:
+
+```ruby
+# Both are equivalent:
+client.events.list(user: "YOUR_USER_UUID")
+client.events.list(user: "https://api.calendly.com/users/YOUR_USER_UUID")
+```
+
 The gem mirrors the Calendly API closely, so converting API examples into gem code is straightforward. Responses are wrapped in Ruby objects with dot-access for every field.
 
+> **Note:** A few endpoints still expect a full Calendly URI for specific parameters. When that matters, the resource docs call it out explicitly.
+
+### Webhook signature verification
+
+`Calendlyr::Webhook` (singular) verifies signed webhook payloads. This is separate from `client.webhooks` / `Calendlyr::Webhooks` (plural), which are API resources for managing webhook subscriptions.
+
+- Calendly sends the signature in the `Calendly-Webhook-Signature` HTTP header.
+- In Rack/Rails, that header is available as `HTTP_CALENDLY_WEBHOOK_SIGNATURE`.
+- `verify!` raises on invalid signature/timestamp; `valid?` returns `true`/`false`; `parse` verifies first, then JSON-parses and wraps the payload.
+
+```ruby
+payload = request.body.read
+signature_header = request.get_header("HTTP_CALENDLY_WEBHOOK_SIGNATURE")
+signing_key = ENV.fetch("CALENDLY_WEBHOOK_SIGNING_KEY")
+
+if Calendlyr::Webhook.valid?(payload: payload, signature_header: signature_header, signing_key: signing_key)
+  webhook = Calendlyr::Webhook.parse(
+    payload: payload,
+    signature_header: signature_header,
+    signing_key: signing_key
+  )
+
+  webhook.event   #=> "invitee.created"
+  webhook.payload #=> Calendlyr::Webhooks::InviteePayload (for invitee.* events)
+                 #=> Calendlyr::Object (for other/unknown events)
+end
+```
+
+### JSON serialization
+
+All API objects support `#to_json` for easy serialization (caching, logging, API proxying):
+
+```ruby
+event = client.events.retrieve(uuid: "ABC123")
+
+event.to_json
+#=> '{"uri":"https://api.calendly.com/scheduled_events/ABC123","name":"30 Minute Meeting",...}'
+
+# Works with JSON.generate and nested objects
+JSON.generate(event)
+
+# Round-trip: parse back into an Object
+parsed = Calendlyr::Object.new(JSON.parse(event.to_json))
+parsed.name  #=> "30 Minute Meeting"
+```
+
+> **Note:** `#to_json` and `#to_h` exclude the internal `client` reference — only API data is serialized.
+
+### Error context
+
+API errors now include the HTTP method and path in the message, and expose structured attributes for debugging:
+
+```ruby
+begin
+  client.events.retrieve(uuid: "INVALID_UUID")
+rescue Calendlyr::NotFound => error
+  error.message       #=> "[Error 404] GET /scheduled_events/INVALID_UUID — Not Found. The resource you requested does not exist."
+  error.status        #=> 404
+  error.http_method   #=> "GET"
+  error.path          #=> "/scheduled_events/INVALID_UUID"
+  error.response_body #=> { "title" => "Not Found", "message" => "..." }
+end
+```
+
+This makes debugging failed requests much easier without changing existing `rescue Calendlyr::Error` patterns.
+
+## Auto-pagination
+
+Calendlyr supports lazy auto-pagination for paginated collection endpoints. There are two ways to consume paginated results:
+
+### `list_all` — Eager, returns a flat Array
+
+The simplest option. Fetches every page and returns all items as an Array.
+
+```ruby
+# Get all events across all pages (e.g., hundreds of events)
+events = client.events.list_all(organization: "YOUR_ORG_UUID")
+events  #=> [#<Calendlyr::Event>, #<Calendlyr::Event>, ...]
+
+# Same pattern works for every resource with a list method:
+client.event_types.list_all(organization: "YOUR_ORG_UUID")
+client.webhooks.list_all(organization: "YOUR_ORG_UUID", scope: "organization")
+client.organizations.list_all_memberships(organization: "YOUR_ORG_UUID")
+client.organizations.list_all_invitations(uuid: "YOUR_ORG_UUID")
+client.organizations.list_all_activity_log(organization: "YOUR_ORG_UUID")
+client.groups.list_all(organization: "YOUR_ORG_UUID")
+client.groups.list_all_relationships(organization: "YOUR_ORG_UUID")
+client.routing_forms.list_all(organization: "YOUR_ORG_UUID")
+client.routing_forms.list_all_submissions(form: "YOUR_FORM_UUID")
+client.availability.list_all_user_busy_times(user: "YOUR_USER_UUID", start_time: "...", end_time: "...")
+client.availability.list_all_user_schedules(user: "YOUR_USER_UUID")
+client.locations.list_all
+client.event_types.list_all_memberships(event_type: "YOUR_EVENT_TYPE_UUID")
+client.outgoing_communications.list_all(organization: "YOUR_ORG_UUID")
+```
+
+### `auto_paginate` — Lazy Enumerator
+
+Returns an `Enumerator::Lazy` that fetches pages on demand. Pages are only requested as you consume items, so you can stop early without fetching all pages.
+
+```ruby
+collection = client.events.list(organization: "YOUR_ORG_UUID")
+
+# Take only the first 50 events — fetches only as many pages as needed
+first_50 = collection.auto_paginate.take(50)
+
+# Filter lazily — stops fetching once the condition is met
+active = collection.auto_paginate.select { |e| e.status == "active" }.first(10)
+
+# Consume all items lazily
+collection.auto_paginate.each do |event|
+  puts event.name
+end
+```
+
 ## Documentation
 
 For the full list of available resources and methods, check out the [API Reference](docs/resources/).
 
+The docs in this repository focus on the Ruby wrapper API. For request/response schemas and endpoint-level behavior, use the official Calendly API docs linked from each resource page.
+
 ## Contributing
 
-1. Fork it ( https://github.com/araluce/calendlyr/fork )
+1. [Fork it](https://github.com/araluce/calendlyr/fork)
 2. Create your feature branch (`git checkout -b my-new-feature`)
 3. Commit your changes (`git commit -am 'Add some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)

data/calendlyr.gemspec

@@ -7,16 +7,19 @@ Gem::Specification.new do |spec|
   spec.email = ["araluce11@gmail.com"]
 
   spec.summary = "Ruby bindings for Calendly API."
-  spec.description = "Ruby bindings for Calendly API. Calendly APIs can be found here: https://calendly.stoplight.io/docs/api-docs/"
+  spec.description = "Ruby bindings for Calendly API v2. Full docs: https://developer.calendly.com/api-docs/"
   spec.homepage = "https://github.com/araluce/calendlyr"
   spec.license = "MIT"
   spec.required_ruby_version = Gem::Requirement.new(">= 3.2.0")
   spec.metadata["homepage_uri"] = spec.homepage
+  spec.metadata["changelog_uri"] = "https://github.com/araluce/calendlyr/blob/master/CHANGELOG.md"
+  spec.metadata["documentation_uri"] = "https://github.com/araluce/calendlyr/tree/master/docs"
 
   spec.files = `git ls-files -z`.split("\x0")
   spec.executables = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_development_dependency "logger", "~> 1.6"
   spec.add_development_dependency "minitest", "~> 5.25"
   spec.add_development_dependency "rake", "~> 13.2"
   spec.add_development_dependency "simplecov", "~> 0.21"

data/docs/resources/activity_log/list_activity_log_entries.md

@@ -13,7 +13,8 @@ Visit official [API Doc](https://developer.calendly.com/api-docs/d37c7f031f339-l
 For the example bellow we will use only required parameters, but you can use any other parameter as well.
 
 ```ruby
-client.organizations.activity_log(organization: `organization_uri`)
+# organization: accepts a bare UUID or full Calendly URI
+client.organizations.activity_log(organization: "ORG_UUID")
 #=> #<Calendlyr::Collection @data=[#<Calendlyr::ActivityLog, ...], @client=#<Calendlyr::Client>>
 ```
 

data/docs/resources/availabilities/user_availability_schedule.md

@@ -20,8 +20,9 @@ client.availabilities.retrieve_user_schedule(uuid: @uuid)
 Return the availability schedules of the given user. See [official API doc](https://developer.calendly.com/api-docs/8098de44af94c-list-user-availability-schedules)
 
 ```ruby
-client.availabilities.list_user_schedules(user: @user)
-#=> #<Calendlyr::Collection @data=[#<Calendlyr::Availabilities::UserSchedule uri="https://api.calendly.com/user_availability_schedule/abc123", default=true, name="Working Hours", user="https://api.calendly.com/users/abc123", timezone="America/New_York", rules=[#<OpenStruct type="wday", intervals=[#<OpenStruct from="08:30", to="09:30">], wday="sunday", date="2022-12-31">], client=#<Calendlyr::Client>, uuid="abc123">, #<Calendlyr::Availabilities::UserSchedule uri="https://api.calendly.com/user_availability_schedule/abc456", default=false, name="Evening Hours", user="https://api.calendly.com/users/abc123", timezone="America/New_York", rules=[#<OpenStruct type="wday", intervals=[#<OpenStruct from="08:30", to="17:00">], wday="monday">, #<OpenStruct type="wday", intervals=[#<OpenStruct from="08:30", to="17:00">], wday="tuesday">, #<OpenStruct type="wday", intervals=[], wday="wednesday">, #<OpenStruct type="wday", intervals=[#<OpenStruct from="08:30", to="17:00">], wday="thursday">, #<OpenStruct type="wday", intervals=[#<OpenStruct from="08:30", to="17:00">], wday="friday">, #<OpenStruct type="wday", intervals=[], wday="saturday">, #<OpenStruct type="date", intervals=[#<OpenStruct from="08:30", to="09:30">], date="2028-12-31">], client=#<Calendlyr::Client>, uuid="abc456">], @count=nil, @next_page=nil, @next_page_token=nil, @client=#<Calendlyr::Client>>
+# user: accepts a bare UUID or full Calendly URI
+client.availabilities.list_user_schedules(user: "USER_UUID")
+#=> #<Calendlyr::Collection @data=[#<Calendlyr::Availabilities::UserSchedule>, ...], @count=nil, @next_page=nil, @next_page_token=nil, @client=#<Calendlyr::Client>>
 ```
 
 #### List on me

data/docs/resources/availabilities/user_busy_time.md

@@ -14,8 +14,9 @@ Date range can be no greater than 1 week (7 days).
 
 For the example bellow we will use only required parameters, but you can use any other parameter as well.
 ```ruby
-client.availabilities.list_user_busy_times(user: `user_uri`, start_time: `start_time`, end_time: `end_time`)
-#=> #<Calendlyr::Collection @data=[#<Calendlyr::Availabilities::UserBusyTime type="calendly", start_time="2020-01-02T20:00:00.000000Z", end_time="2020-01-02T20:30:00.000000Z", buffered_start_time="2020-01-02T19:30:00.000000Z", buffered_end_time="2020-01-02T21:00:00.000000Z", event=#<OpenStruct uri="https://api.calendly.com/scheduled_events/abc123">, client=#<Calendlyr::Client>, uuid=nil>, #<Calendlyr::UserBusyTime type="calendly", start_time="2020-01-05T20:00:00.000000Z", end_time="2020-01-05T20:30:00.000000Z", buffered_start_time="2020-01-05T19:30:00.000000Z", buffered_end_time="2020-01-05T21:00:00.000000Z", event=#<OpenStruct uri="https://api.calendly.com/scheduled_events/abc12345">, client=#<Calendlyr::Client>, uuid=nil>, #<Calendlyr::UserBusyTime type="external", start_time="2020-01-07T20:00:00.000000Z", end_time="2020-01-07T20:30:00.000000Z", client=#<Calendlyr::Client>, uuid=nil>], @count=nil, @next_page=nil, @next_page_token=nil, @client=#<Calendlyr::Client>>
+# user: accepts a bare UUID or full Calendly URI
+client.availabilities.list_user_busy_times(user: "USER_UUID", start_time: start_time, end_time: end_time)
+#=> #<Calendlyr::Collection @data=[#<Calendlyr::Availabilities::UserBusyTime>, ...], @count=nil, @next_page=nil, @next_page_token=nil, @client=#<Calendlyr::Client>>
 ```
 
 ## Object methods

data/docs/resources/event_types/available_time.md

@@ -0,0 +1,25 @@
+# Available Time (`Calendlyr::EventTypes::AvailableTime`)
+
+Available time for a specific Event Type in a given time window.
+
+Visit official [API Doc](https://developer.calendly.com/api-docs)
+
+## Client requests
+
+### List Available Times
+
+Returns available time slots for an Event Type between `start_time` and `end_time`.
+
+Visit official [API Doc](https://developer.calendly.com/api-docs)
+
+```ruby
+# event_type: accepts a bare UUID or full Calendly URI
+client.event_types.list_available_times(
+  event_type: "EVENT_TYPE_UUID",
+  start_time: "2026-04-07T09:00:00Z",
+  end_time: "2026-04-07T18:00:00Z"
+)
+#=> #<Calendlyr::Collection @data=[#<Calendlyr::EventTypes::AvailableTime>, ...], ...>
+```
+
+This endpoint does not support pagination.

data/docs/resources/event_types/event_type.md

@@ -24,10 +24,11 @@ Visit official [API Doc](https://developer.calendly.com/api-docs/25a4ece03c1bc-l
 
 For the examples bellow we will use only required parameters, but you can use any other parameter as well.
 ```ruby
-client.event_types.list(user: @user)
+# user: and organization: accept bare UUIDs or full Calendly URIs
+client.event_types.list(user: "USER_UUID")
 #=> #<Calendlyr::Collection @data=[#<Calendlyr::EventType>, ...], @count=nil, @next_page=nil, @next_page_token=nil, @client=#<Calendlyr::Client>>
 
-client.event_types.list(organization: @organization)
+client.event_types.list(organization: "ORG_UUID")
 #=> #<Calendlyr::Collection @data=[#<Calendlyr::EventType>, ...], @count=nil, @next_page=nil, @next_page_token=nil, @client=#<Calendlyr::Client>>
 ```
 

data/docs/resources/event_types/membership.md

@@ -0,0 +1,28 @@
+# Event Type Membership (`Calendlyr::EventTypes::Membership`)
+
+Membership object for an Event Type.
+
+Visit official [API Doc](https://developer.calendly.com/api-docs)
+
+## Client requests
+
+### List
+
+Returns memberships for a specified Event Type.
+
+Visit official [API Doc](https://developer.calendly.com/api-docs)
+
+```ruby
+# event_type: accepts a bare UUID or full Calendly URI
+client.event_types.list_memberships(event_type: "EVENT_TYPE_UUID")
+#=> #<Calendlyr::Collection @data=[#<Calendlyr::EventTypes::Membership>, ...], ...>
+```
+
+### List All
+
+Fetches every membership page and returns a flat Array.
+
+```ruby
+client.event_types.list_all_memberships(event_type: "EVENT_TYPE_UUID")
+#=> [#<Calendlyr::EventTypes::Membership>, ...]
+```

data/docs/resources/events/event.md

@@ -24,13 +24,14 @@ Returns a list of Events.
 Visit official [API Doc](https://developer.calendly.com/api-docs/2d5ed9bbd2952-list-events)
 
 ```ruby
-client.events.list(organization: organization, user: user)
+# You can pass bare UUIDs or full Calendly URIs for user:, organization:, and group:
+client.events.list(organization: "ORG_UUID", user: "USER_UUID")
 #=> #<Calendlyr::Collection @data=[#<Calendlyr::Event>, ...], @count=nil, @next_page=nil, @next_page_token=nil, @client=#<Calendlyr::Client>>
 
-client.events.list(organization: organization, group: group)
+client.events.list(organization: "ORG_UUID", group: group)
 #=> #<Calendlyr::Collection @data=[#<Calendlyr::Event>, ...], @count=nil, @next_page=nil, @next_page_token=nil, @client=#<Calendlyr::Client>>
 
-client.events.list(user: user)
+client.events.list(user: "USER_UUID")
 #=> #<Calendlyr::Collection @data=[#<Calendlyr::Event>, ...], @count=nil, @next_page=nil, @next_page_token=nil, @client=#<Calendlyr::Client>>
 ```
 

data/docs/resources/events/invitee.md

@@ -32,8 +32,9 @@ client.events.list_invitees(uuid: uuid)
 Creates and schedules an Invitee.
 
 ```ruby
+# event_type: accepts a bare UUID or full Calendly URI
 client.events.create_invitee(
-  event_type: event_type_uri,
+  event_type: "EVENT_TYPE_UUID",
   start_time: "2019-08-07T06:05:04.321123Z",
   invitee: {
     name: "John Doe",

data/docs/resources/events/invitee_no_show.md

@@ -24,7 +24,8 @@ Marks an Invitee as a No Show.
 Visit official [API Doc](https://developer.calendly.com/api-docs/cebd8c3170790-create-invitee-no-show)
 
 ```ruby
-client.events.create_invitee_no_show(invitee: invitee_uri)
+# invitee: accepts a bare UUID or full Calendly URI
+client.events.create_invitee_no_show(invitee: "INVITEE_UUID")
 #=> #<Calendlyr::Events::InviteeNoShow>
 ```
 

data/docs/resources/groups/group.md

@@ -24,7 +24,8 @@ Returns a list of groups.
 Visit official [API Doc](https://developer.calendly.com/api-docs/6rb6dtdln74sy-list-groups)
 
 ```ruby
-client.groups.list(organization: organization_uri)
+# organization: accepts a bare UUID or full Calendly URI
+client.groups.list(organization: "ORG_UUID")
 #=> #<Calendlyr::Collection @data=[#<Calendlyr::Group>, ...], @count=nil, @next_page=nil, @next_page_token=nil, @client=#<Calendlyr::Client>>
 ```
 

data/docs/resources/organizations/membership.md

@@ -26,10 +26,11 @@ Visit official [API Doc](https://developer.calendly.com/api-docs/eaed2e61a6bc3-l
 For the example bellow we will use only required parameters, but you can use any other parameter as well.
 
 ```ruby
-client.organizations.list_memberships(user: user)
+# user: and organization: accept bare UUIDs or full Calendly URIs
+client.organizations.list_memberships(user: "USER_UUID")
 #=> #<Calendlyr::Collection @data=[#<Calendlyr::Organizations::Membership>, ...], @count=nil, @next_page=nil, @next_page_token=nil, @client=#<Calendlyr::Client>>
 
-client.organizations.list_memberships(organization: organization)
+client.organizations.list_memberships(organization: "ORG_UUID")
 #=> #<Calendlyr::Collection @data=[#<Calendlyr::Organizations::Membership>, ...], @count=nil, @next_page=nil, @next_page_token=nil, @client=#<Calendlyr::Client>>
 ```
 

data/docs/resources/organizations/organization.md

@@ -13,6 +13,19 @@ organization = client.organization
 #=> #<Calendlyr::Organization>
 ```
 
+## Client requests
+
+### Retrieve
+
+Returns information about a specified Organization.
+
+Visit official [API Doc](https://developer.calendly.com/api-docs)
+
+```ruby
+client.organizations.retrieve(uuid: "ORG_UUID")
+#=> #<Calendlyr::Organization>
+```
+
 ## Object methods
 
 ### Activity Logs

data/docs/resources/outgoing_communications/outgoing_communication.md

@@ -0,0 +1,28 @@
+# Outgoing Communication (`Calendlyr::OutgoingCommunication`)
+
+Outgoing communication object.
+
+Visit official [API Doc](https://developer.calendly.com/api-docs)
+
+## Client requests
+
+### List
+
+Returns outgoing communications for a specified Organization.
+
+Visit official [API Doc](https://developer.calendly.com/api-docs)
+
+```ruby
+# organization: accepts a bare UUID or full Calendly URI
+client.outgoing_communications.list(organization: "ORG_UUID")
+#=> #<Calendlyr::Collection @data=[#<Calendlyr::OutgoingCommunication>, ...], ...>
+```
+
+### List All
+
+Fetches every page and returns a flat Array.
+
+```ruby
+client.outgoing_communications.list_all(organization: "ORG_UUID")
+#=> [#<Calendlyr::OutgoingCommunication>, ...]
+```

data/docs/resources/routing_forms/routing_form.md

@@ -26,7 +26,8 @@ Visit official [API Doc](https://developer.calendly.com/api-docs/9fe7334bec6ad-l
 For the example bellow we will use only required parameters, but you can use any other parameter as well.
 
 ```ruby
-client.routing_forms.list(organization: organization_uri)
+# organization: accepts a bare UUID or full Calendly URI
+client.routing_forms.list(organization: "ORG_UUID")
 #=> #<Calendlyr::Collection @data=[#<Calendlyr::RoutingForm>, ...], @count=nil, @next_page=nil, @next_page_token=nil, @client=#<Calendlyr::Client>>
 ```
 

data/docs/resources/routing_forms/submission.md

@@ -26,7 +26,8 @@ Visit official [API Doc](https://developer.calendly.com/api-docs/17db5cb915a57-l
 For the example bellow we will use only required parameters, but you can use any other parameter as well.
 
 ```ruby
-client.routing_forms.list_submissions(form: routing_form_uri)
+# form: accepts a bare UUID or full Calendly URI
+client.routing_forms.list_submissions(form: "ROUTING_FORM_UUID")
 #=> #<Calendlyr::Collection @data=[#<Calendlyr::RoutingForms::Submission>, ...], @count=nil, @next_page=nil, @next_page_token=nil, @client=#<Calendlyr::Client>>
 ```
 

data/docs/resources/scheduling_links/scheduling_link.md

@@ -0,0 +1,26 @@
+# Scheduling Link (`Calendlyr::SchedulingLink`)
+
+Scheduling link object.
+
+Visit official [API Doc](https://developer.calendly.com/api-docs)
+
+## Client requests
+
+### Create
+
+Creates a scheduling link for an Event Type owner.
+
+Visit official [API Doc](https://developer.calendly.com/api-docs)
+
+```ruby
+# owner: accepts a bare UUID or full Calendly URI
+client.scheduling_links.create(owner: "EVENT_TYPE_UUID")
+#=> #<Calendlyr::SchedulingLink>
+
+client.scheduling_links.create(
+  owner: "EVENT_TYPE_UUID",
+  owner_type: "EventType",
+  max_event_count: 3
+)
+#=> #<Calendlyr::SchedulingLink>
+```

data/docs/resources/share.md

@@ -14,7 +14,8 @@ Endpoint for our Customize Once and Share feature. This allows you to customize
 Visit official [API Doc](https://developer.calendly.com/api-docs/fdcac06abfc8c-create-share)
 
 ```ruby
-client.shares.create(create: event_type_uri, name: "15 minute meeting", duration: ...)
+# event_type: accepts a bare UUID or full Calendly URI
+client.shares.create(event_type: "EVENT_TYPE_UUID", name: "15 minute meeting", duration: ...)
 #=> #<Calendlyr::Share>
 ```
 

data/docs/resources/webhooks/invitee_payload.md

@@ -1,6 +1,12 @@
-# Webhooks Invitee Payload Calendlyr::Wehooks::InviteePayload
+# Webhooks Invitee Payload (`Calendlyr::Webhooks::InviteePayload`)
 
-The payload that is sent via Webhook when an invitee creates or schedules a meeting, and when an invitee cancels.
+Typed payload wrapper used by `Calendlyr::Webhook.parse` when `event` is one of:
+- `invitee.created`
+- `invitee.canceled`
+- `invitee_no_show.created`
+- `invitee_no_show.deleted`
+
+For other events, `parsed.payload` is returned as a generic `Calendlyr::Object`.
 
 Visit official [API Doc](https://developer.calendly.com/api-docs/b92768854bc06-invitee-payload)
 
@@ -9,7 +15,7 @@ Visit official [API Doc](https://developer.calendly.com/api-docs/b92768854bc06-i
 ### Associated Event
 
 ```ruby
-webhook_invitee_payload.associated_organization
+webhook_invitee_payload.associated_event
 #=> #<Calendlyr::Event>
 ```
 
@@ -27,16 +33,4 @@ webhook_invitee_payload.associated_invitee_no_show
 #=> #<Calendlyr::Events::InviteeNoShow>
 ```
 
-### active?
-
-```ruby
-webhook_subscription.active?
-#=> true
-```
-
-### disabled?
-
-```ruby
-webhook_subscription.disabled?
-#=> false
-```
+`active?` / `disabled?` are methods on `Calendlyr::Webhooks::Subscription`, not on invitee payloads.