hivehook 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 83773b61f9eeb24c46400c370de13e0a9fc01a4cc72b5cb38eb2f8b2596574c0
+  data.tar.gz: 158c806493df64e7af4c6cbc094f5006273e3ba3f81bf5f07c97b98f38cbdd7d
+SHA512:
+  metadata.gz: ab0801f1c2be0e6d206b2b3be255305993561591b49043f5884c4092a6fb229fe01057af4c97731228d43a148dbb7669ee1cedde40343022181f36ffcd63a238
+  data.tar.gz: 9f1f8ad4047ac983cc1cc21cb5eb739f172745c01fdbc727bb9b26b79755ea3c415cf05875a245f262556f0effc7b330215a068d6638bd193a031e7eaf6937a6

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Hivehook
+
+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,53 @@
+# hivehook (Ruby)
+
+Official Ruby client for [Hivehook](https://hivehook.com), the self-hostable webhook gateway (inbound + outbound).
+
+## Install
+
+```bash
+gem install hivehook
+```
+
+Or in your `Gemfile`:
+
+```ruby
+gem "hivehook"
+```
+
+## Quick start
+
+```ruby
+require "hivehook"
+
+client = Hivehook::Client.new(
+  base_url: "http://localhost:8080",
+  api_key: ENV.fetch("HIVEHOOK_API_KEY"),
+)
+
+source = client.sources.create(
+  "name" => "Stripe production",
+  "slug" => "stripe-prod",
+  "providerType" => "stripe",
+  "verifyConfig" => { "secret" => "whsec_..." },
+)
+
+puts "created source #{source['id']}. POST webhooks to /ingest/#{source['slug']}"
+```
+
+## Webhook signature verification
+
+```ruby
+require "hivehook/webhook"
+
+signature = request.headers["X-Hivehook-Signature"]
+timestamp = request.headers["X-Hivehook-Timestamp"].to_i
+ok = Hivehook::Webhook.verify(body, "your-signing-secret", signature, timestamp, 300)
+```
+
+## Documentation
+
+See the full reference at [hivehook.com/docs](https://hivehook.com/docs).
+
+## License
+
+MIT. See [LICENSE](LICENSE).

data/lib/hivehook/errors.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Hivehook
+  class HivehookError < StandardError; end
+
+  class APIError < HivehookError
+    attr_reader :status_code, :extensions, :graphql_code
+
+    def initialize(message, status_code = nil, extensions: nil, graphql_code: nil)
+      super(message)
+      @status_code = status_code
+      @extensions = extensions
+      @graphql_code = graphql_code
+    end
+  end
+
+  class AuthError < APIError
+    def initialize(message = "unauthorized", status_code = 401, extensions: nil, graphql_code: nil)
+      super(message, status_code, extensions: extensions, graphql_code: graphql_code)
+    end
+  end
+
+  class NotFoundError < APIError; end
+  class ConflictError < APIError; end
+  class ValidationError < APIError; end
+  class ServerError < APIError; end
+
+  class RateLimitError < APIError
+    attr_reader :retry_after
+
+    def initialize(message, status_code = 429, retry_after: nil, extensions: nil, graphql_code: nil)
+      super(message, status_code, extensions: extensions, graphql_code: graphql_code)
+      @retry_after = retry_after
+    end
+  end
+end

data/lib/hivehook/resources/alert_rule_service.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Hivehook
+  module Resources
+    class AlertRuleService < BaseService
+      FRAGMENT = "id name conditionType threshold webhookUrl channel emailConfig { to subjectTemplate } slackConfig { webhookUrl channel } cooldown enabled createdAt"
+
+      def list(options = {})
+        query = "query($enabled: Boolean, $search: String, $limit: Int, $offset: Int, $after: String, $first: Int) {
+          alertRules(enabled: $enabled, search: $search, limit: $limit, offset: $offset, after: $after, first: $first) {
+            nodes { #{FRAGMENT} }
+            pageInfo { total limit offset endCursor hasNextPage }
+          }
+        }"
+        @transport.execute(query, build_variables(options, %w[enabled search limit offset after first]))["alertRules"]
+      end
+
+      def get(id)
+        query = "query($id: UUID!) { alertRule(id: $id) { #{FRAGMENT} } }"
+        @transport.execute(query, { "id" => id })["alertRule"]
+      end
+
+      def create(input)
+        query = "mutation($input: CreateAlertRuleInput!) { createAlertRule(input: $input) { #{FRAGMENT} } }"
+        @transport.execute(query, { "input" => input })["createAlertRule"]
+      end
+
+      def update(id, input)
+        query = "mutation($id: UUID!, $input: UpdateAlertRuleInput!) { updateAlertRule(id: $id, input: $input) { #{FRAGMENT} } }"
+        @transport.execute(query, { "id" => id, "input" => input })["updateAlertRule"]
+      end
+
+      def delete(id)
+        query = "mutation($id: UUID!) { deleteAlertRule(id: $id) }"
+        @transport.execute(query, { "id" => id })["deleteAlertRule"]
+      end
+
+      def test(id)
+        query = "mutation($id: UUID!) { testAlertRule(id: $id) }"
+        @transport.execute(query, { "id" => id })["testAlertRule"]
+      end
+    end
+  end
+end

data/lib/hivehook/resources/api_key_service.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Hivehook
+  module Resources
+    class APIKeyService < BaseService
+      FRAGMENT = "id name keyPrefix scopes sourceIds createdAt expiresAt revokedAt lastUsedAt"
+
+      def list(options = {})
+        query = "query($search: String, $limit: Int, $offset: Int) {
+          apiKeys(search: $search, limit: $limit, offset: $offset) {
+            nodes { #{FRAGMENT} }
+            pageInfo { total limit offset endCursor hasNextPage }
+          }
+        }"
+        @transport.execute(query, build_variables(options, %w[search limit offset]))["apiKeys"]
+      end
+
+      def get(id)
+        query = "query($id: UUID!) { apiKey(id: $id) { #{FRAGMENT} } }"
+        @transport.execute(query, { "id" => id })["apiKey"]
+      end
+
+      def create(input)
+        query = "mutation($input: CreateAPIKeyInput!) { createAPIKey(input: $input) { apiKey { #{FRAGMENT} } rawKey } }"
+        @transport.execute(query, { "input" => input })["createAPIKey"]
+      end
+
+      def revoke(id)
+        query = "mutation($id: UUID!) { revokeAPIKey(id: $id) }"
+        @transport.execute(query, { "id" => id })["revokeAPIKey"]
+      end
+    end
+  end
+end

data/lib/hivehook/resources/application_service.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Hivehook
+  module Resources
+    class ApplicationService < BaseService
+      FRAGMENT = "id name uid createdAt"
+
+      def list(options = {})
+        query = "query($search: String, $limit: Int, $offset: Int, $after: String, $first: Int) {
+          applications(search: $search, limit: $limit, offset: $offset, after: $after, first: $first) {
+            nodes { #{FRAGMENT} }
+            pageInfo { total limit offset endCursor hasNextPage }
+          }
+        }"
+        @transport.execute(query, build_variables(options, %w[search limit offset after first]))["applications"]
+      end
+
+      def get(id)
+        query = "query($id: UUID!) { application(id: $id) { #{FRAGMENT} } }"
+        @transport.execute(query, { "id" => id })["application"]
+      end
+
+      def create(input)
+        query = "mutation($input: CreateApplicationInput!) { createApplication(input: $input) { #{FRAGMENT} } }"
+        @transport.execute(query, { "input" => input })["createApplication"]
+      end
+
+      def update(id, input)
+        query = "mutation($id: UUID!, $input: UpdateApplicationInput!) { updateApplication(id: $id, input: $input) { #{FRAGMENT} } }"
+        @transport.execute(query, { "id" => id, "input" => input })["updateApplication"]
+      end
+
+      def delete(id)
+        query = "mutation($id: UUID!) { deleteApplication(id: $id) }"
+        @transport.execute(query, { "id" => id })["deleteApplication"]
+      end
+    end
+  end
+end

data/lib/hivehook/resources/audit_log_service.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Hivehook
+  module Resources
+    class AuditLogService < BaseService
+      FRAGMENT = "id actorType actorId actorName action resourceType resourceId orgId ipAddress userAgent details createdAt"
+
+      def list(options = {})
+        query = "query($actorType: String, $resourceType: String, $resourceId: UUID, $action: String, $since: Time, $until: Time, $search: String, $limit: Int, $offset: Int, $after: String, $first: Int) {
+          auditLogs(actorType: $actorType, resourceType: $resourceType, resourceId: $resourceId, action: $action, since: $since, until: $until, search: $search, limit: $limit, offset: $offset, after: $after, first: $first) {
+            nodes { #{FRAGMENT} }
+            pageInfo { total limit offset endCursor hasNextPage }
+          }
+        }"
+        @transport.execute(query, build_variables(options, %w[actorType resourceType resourceId action since until search limit offset after first]))["auditLogs"]
+      end
+
+      def get(id)
+        query = "query($id: UUID!) { auditLog(id: $id) { #{FRAGMENT} } }"
+        @transport.execute(query, { "id" => id })["auditLog"]
+      end
+    end
+  end
+end

data/lib/hivehook/resources/base_service.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Hivehook
+  module Resources
+    class BaseService
+      def initialize(transport)
+        @transport = transport
+      end
+
+      private
+
+      def build_variables(options, allowed)
+        vars = {}
+        allowed.each do |key|
+          sym = key.to_sym
+          vars[key] = options[sym] if options.key?(sym)
+        end
+        vars
+      end
+    end
+  end
+end

data/lib/hivehook/resources/bookmark_service.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Hivehook
+  module Resources
+    class BookmarkService < BaseService
+      FRAGMENT = "id eventId name notes createdAt"
+
+      def list(options = {})
+        query = "query($eventId: UUID, $search: String, $limit: Int, $offset: Int, $after: String, $first: Int) {
+          bookmarks(eventId: $eventId, search: $search, limit: $limit, offset: $offset, after: $after, first: $first) {
+            nodes { #{FRAGMENT} }
+            pageInfo { total limit offset endCursor hasNextPage }
+          }
+        }"
+        @transport.execute(query, build_variables(options, %w[eventId search limit offset after first]))["bookmarks"]
+      end
+
+      def create(input)
+        query = "mutation($input: CreateBookmarkInput!) { createBookmark(input: $input) { #{FRAGMENT} } }"
+        @transport.execute(query, { "input" => input })["createBookmark"]
+      end
+
+      def delete(id)
+        query = "mutation($id: UUID!) { deleteBookmark(id: $id) }"
+        @transport.execute(query, { "id" => id })["deleteBookmark"]
+      end
+    end
+  end
+end

data/lib/hivehook/resources/delivery_service.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Hivehook
+  module Resources
+    class DeliveryService < BaseService
+      FRAGMENT = "id eventId subscriptionId destinationId status attempts maxAttempts nextAttemptAt createdAt"
+
+      def list(options = {})
+        query = "query($eventId: UUID, $destinationId: UUID, $subscriptionId: UUID, $status: DeliveryStatus, $search: String, $limit: Int, $offset: Int, $after: String, $first: Int) {
+          deliveries(eventId: $eventId, destinationId: $destinationId, subscriptionId: $subscriptionId, status: $status, search: $search, limit: $limit, offset: $offset, after: $after, first: $first) {
+            nodes { #{FRAGMENT} }
+            pageInfo { total limit offset endCursor hasNextPage }
+          }
+        }"
+        @transport.execute(query, build_variables(options, %w[eventId destinationId subscriptionId status search limit offset after first]))["deliveries"]
+      end
+
+      def get(id)
+        query = "query($id: UUID!) { delivery(id: $id) { #{FRAGMENT} } }"
+        @transport.execute(query, { "id" => id })["delivery"]
+      end
+    end
+  end
+end

data/lib/hivehook/resources/destination_service.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Hivehook
+  module Resources
+    class DestinationService < BaseService
+      FRAGMENT = "id name url signingSecret status type typeConfig timeoutMs rateLimitRps headers authType deliveryMode ordered blockedDeliveryId healthScore disabledReason healthConfig { windowHours disableBelow } outputFormat createdAt"
+
+      def list(options = {})
+        query = "query($status: DestinationStatus, $search: String, $limit: Int, $offset: Int, $after: String, $first: Int) {
+          destinations(status: $status, search: $search, limit: $limit, offset: $offset, after: $after, first: $first) {
+            nodes { #{FRAGMENT} }
+            pageInfo { total limit offset endCursor hasNextPage }
+          }
+        }"
+        @transport.execute(query, build_variables(options, %w[status search limit offset after first]))["destinations"]
+      end
+
+      def get(id)
+        query = "query($id: UUID!) { destination(id: $id) { #{FRAGMENT} } }"
+        @transport.execute(query, { "id" => id })["destination"]
+      end
+
+      def create(input)
+        query = "mutation($input: CreateDestinationInput!) { createDestination(input: $input) { #{FRAGMENT} } }"
+        @transport.execute(query, { "input" => input })["createDestination"]
+      end
+
+      def update(id, input)
+        query = "mutation($id: UUID!, $input: UpdateDestinationInput!) { updateDestination(id: $id, input: $input) { #{FRAGMENT} } }"
+        @transport.execute(query, { "id" => id, "input" => input })["updateDestination"]
+      end
+
+      def delete(id)
+        query = "mutation($id: UUID!) { deleteDestination(id: $id) }"
+        @transport.execute(query, { "id" => id })["deleteDestination"]
+      end
+
+      def rotate_secret(id)
+        query = "mutation($id: UUID!) { rotateDestinationSecret(id: $id) { #{FRAGMENT} } }"
+        @transport.execute(query, { "id" => id })["rotateDestinationSecret"]
+      end
+    end
+  end
+end

data/lib/hivehook/resources/dlq_service.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Hivehook
+  module Resources
+    class DLQService < BaseService
+      FRAGMENT = "id deliveryId eventId lastError replayedAt createdAt"
+
+      def list(options = {})
+        query = "query($eventId: UUID, $replayed: Boolean, $search: String, $limit: Int, $offset: Int, $after: String, $first: Int) {
+          dlqEntries(eventId: $eventId, replayed: $replayed, search: $search, limit: $limit, offset: $offset, after: $after, first: $first) {
+            nodes { #{FRAGMENT} }
+            pageInfo { total limit offset endCursor hasNextPage }
+          }
+        }"
+        @transport.execute(query, build_variables(options, %w[eventId replayed search limit offset after first]))["dlqEntries"]
+      end
+
+      def get(id)
+        query = "query($id: UUID!) { dlqEntry(id: $id) { #{FRAGMENT} } }"
+        @transport.execute(query, { "id" => id })["dlqEntry"]
+      end
+
+      def replay(id)
+        query = "mutation($id: UUID!) { replayDLQEntry(id: $id) }"
+        @transport.execute(query, { "id" => id })["replayDLQEntry"]
+      end
+
+      def replay_all
+        query = "mutation { replayAllDLQ { deliveries } }"
+        @transport.execute(query)["replayAllDLQ"]
+      end
+
+      def purge(older_than)
+        query = "mutation($olderThan: String!) { purgeDLQ(olderThan: $olderThan) { purged } }"
+        @transport.execute(query, { "olderThan" => older_than })["purgeDLQ"]
+      end
+    end
+  end
+end

data/lib/hivehook/resources/endpoint_service.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Hivehook
+  module Resources
+    class EndpointService < BaseService
+      FRAGMENT = "id applicationId url signingSecret status type typeConfig rateLimitRps timeoutMs headers authType deliveryMode ordered blockedDeliveryId healthScore disabledReason healthConfig { windowHours disableBelow } outputFormat createdAt"
+
+      def list(options = {})
+        query = "query($applicationId: UUID, $status: EndpointStatus, $search: String, $limit: Int, $offset: Int, $after: String, $first: Int) {
+          endpoints(applicationId: $applicationId, status: $status, search: $search, limit: $limit, offset: $offset, after: $after, first: $first) {
+            nodes { #{FRAGMENT} }
+            pageInfo { total limit offset endCursor hasNextPage }
+          }
+        }"
+        @transport.execute(query, build_variables(options, %w[applicationId status search limit offset after first]))["endpoints"]
+      end
+
+      def get(id)
+        query = "query($id: UUID!) { endpoint(id: $id) { #{FRAGMENT} } }"
+        @transport.execute(query, { "id" => id })["endpoint"]
+      end
+
+      def create(input)
+        query = "mutation($input: CreateEndpointInput!) { createEndpoint(input: $input) { #{FRAGMENT} } }"
+        @transport.execute(query, { "input" => input })["createEndpoint"]
+      end
+
+      def update(id, input)
+        query = "mutation($id: UUID!, $input: UpdateEndpointInput!) { updateEndpoint(id: $id, input: $input) { #{FRAGMENT} } }"
+        @transport.execute(query, { "id" => id, "input" => input })["updateEndpoint"]
+      end
+
+      def delete(id)
+        query = "mutation($id: UUID!) { deleteEndpoint(id: $id) }"
+        @transport.execute(query, { "id" => id })["deleteEndpoint"]
+      end
+
+      def rotate_secret(id)
+        query = "mutation($id: UUID!) { rotateEndpointSecret(id: $id) { #{FRAGMENT} } }"
+        @transport.execute(query, { "id" => id })["rotateEndpointSecret"]
+      end
+    end
+  end
+end

data/lib/hivehook/resources/event_service.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Hivehook
+  module Resources
+    class EventService < BaseService
+      FRAGMENT = "id sourceId idempotencyKey eventType rawBody status receivedAt"
+
+      def list(options = {})
+        query = "query($sourceId: UUID, $eventType: String, $status: EventStatus, $search: String, $limit: Int, $offset: Int, $after: String, $first: Int) {
+          events(sourceId: $sourceId, eventType: $eventType, status: $status, search: $search, limit: $limit, offset: $offset, after: $after, first: $first) {
+            nodes { #{FRAGMENT} }
+            pageInfo { total limit offset endCursor hasNextPage }
+          }
+        }"
+        @transport.execute(query, build_variables(options, %w[sourceId eventType status search limit offset after first]))["events"]
+      end
+
+      def get(id)
+        query = "query($id: UUID!) { event(id: $id) { #{FRAGMENT} } }"
+        @transport.execute(query, { "id" => id })["event"]
+      end
+    end
+  end
+end

data/lib/hivehook/resources/event_type_schema_service.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Hivehook
+  module Resources
+    class EventTypeSchemaService < BaseService
+      FRAGMENT = "id eventType description schema example createdAt updatedAt"
+
+      def list(options = {})
+        query = "query($search: String, $limit: Int, $offset: Int, $after: String, $first: Int) {
+          eventTypeSchemas(search: $search, limit: $limit, offset: $offset, after: $after, first: $first) {
+            nodes { #{FRAGMENT} }
+            pageInfo { total limit offset endCursor hasNextPage }
+          }
+        }"
+        @transport.execute(query, build_variables(options, %w[search limit offset after first]))["eventTypeSchemas"]
+      end
+
+      def get(id)
+        query = "query($id: UUID!) { eventTypeSchema(id: $id) { #{FRAGMENT} } }"
+        @transport.execute(query, { "id" => id })["eventTypeSchema"]
+      end
+
+      def create(input)
+        query = "mutation($input: CreateEventTypeSchemaInput!) { createEventTypeSchema(input: $input) { #{FRAGMENT} } }"
+        @transport.execute(query, { "input" => input })["createEventTypeSchema"]
+      end
+
+      def update(id, input)
+        query = "mutation($id: UUID!, $input: UpdateEventTypeSchemaInput!) { updateEventTypeSchema(id: $id, input: $input) { #{FRAGMENT} } }"
+        @transport.execute(query, { "id" => id, "input" => input })["updateEventTypeSchema"]
+      end
+
+      def delete(id)
+        query = "mutation($id: UUID!) { deleteEventTypeSchema(id: $id) }"
+        @transport.execute(query, { "id" => id })["deleteEventTypeSchema"]
+      end
+    end
+  end
+end

data/lib/hivehook/resources/message_service.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Hivehook
+  module Resources
+    class MessageService < BaseService
+      FRAGMENT = "id applicationId eventType payload idempotencyKey status createdAt"
+
+      def list(options = {})
+        query = "query($applicationId: UUID, $eventType: String, $status: MessageStatus, $search: String, $limit: Int, $offset: Int, $after: String, $first: Int) {
+          messages(applicationId: $applicationId, eventType: $eventType, status: $status, search: $search, limit: $limit, offset: $offset, after: $after, first: $first) {
+            nodes { #{FRAGMENT} }
+            pageInfo { total limit offset endCursor hasNextPage }
+          }
+        }"
+        @transport.execute(query, build_variables(options, %w[applicationId eventType status search limit offset after first]))["messages"]
+      end
+
+      def get(id)
+        query = "query($id: UUID!) { message(id: $id) { #{FRAGMENT} } }"
+        @transport.execute(query, { "id" => id })["message"]
+      end
+
+      def send(input)
+        query = "mutation($input: SendMessageInput!) { sendMessage(input: $input) { #{FRAGMENT} } }"
+        @transport.execute(query, { "input" => input })["sendMessage"]
+      end
+
+      def broadcast(input)
+        query = "mutation($input: BroadcastMessageInput!) { broadcastMessage(input: $input) { #{FRAGMENT} } }"
+        @transport.execute(query, { "input" => input })["broadcastMessage"]
+      end
+
+      def send_dynamic(input)
+        query = "mutation($input: SendDynamicMessageInput!) { sendDynamicMessage(input: $input) { #{FRAGMENT} } }"
+        @transport.execute(query, { "input" => input })["sendDynamicMessage"]
+      end
+    end
+  end
+end

data/lib/hivehook/resources/organization_service.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Hivehook
+  module Resources
+    class OrganizationService < BaseService
+      FRAGMENT = "id name slug ssoEnabled ssoProvider retentionEvents retentionMessages otlpConfig { endpoint headers insecure sampleRate } createdAt updatedAt"
+
+      def list(options = {})
+        query = "query($search: String, $limit: Int, $offset: Int) {
+          organizations(search: $search, limit: $limit, offset: $offset) {
+            nodes { #{FRAGMENT} }
+            pageInfo { total limit offset endCursor hasNextPage }
+          }
+        }"
+        @transport.execute(query, build_variables(options, %w[search limit offset]))["organizations"]
+      end
+
+      def get(id)
+        query = "query($id: UUID!) { organization(id: $id) { #{FRAGMENT} } }"
+        @transport.execute(query, { "id" => id })["organization"]
+      end
+
+      def create(input)
+        query = "mutation($input: CreateOrganizationInput!) { createOrganization(input: $input) { #{FRAGMENT} } }"
+        @transport.execute(query, { "input" => input })["createOrganization"]
+      end
+
+      def update(id, input)
+        query = "mutation($id: UUID!, $input: UpdateOrganizationInput!) { updateOrganization(id: $id, input: $input) { #{FRAGMENT} } }"
+        @transport.execute(query, { "id" => id, "input" => input })["updateOrganization"]
+      end
+
+      def delete(id)
+        query = "mutation($id: UUID!) { deleteOrganization(id: $id) }"
+        @transport.execute(query, { "id" => id })["deleteOrganization"]
+      end
+
+      def configure_sso(organization_id, input)
+        query = "mutation($organizationId: UUID!, $input: SSOConfigInput!) { configureSSO(organizationId: $organizationId, input: $input) { #{FRAGMENT} } }"
+        @transport.execute(query, { "organizationId" => organization_id, "input" => input })["configureSSO"]
+      end
+
+      def disable_sso(organization_id)
+        query = "mutation($organizationId: UUID!) { disableSSO(organizationId: $organizationId) { #{FRAGMENT} } }"
+        @transport.execute(query, { "organizationId" => organization_id })["disableSSO"]
+      end
+
+      def update_retention(organization_id, input)
+        query = "mutation($organizationId: UUID!, $input: RetentionInput!) { updateOrganizationRetention(organizationId: $organizationId, input: $input) { #{FRAGMENT} } }"
+        @transport.execute(query, { "organizationId" => organization_id, "input" => input })["updateOrganizationRetention"]
+      end
+
+      def delete_data(organization_id)
+        query = "mutation($organizationId: UUID!) { deleteOrganizationData(organizationId: $organizationId) }"
+        @transport.execute(query, { "organizationId" => organization_id })["deleteOrganizationData"]
+      end
+
+      def export_data(organization_id)
+        query = "mutation($organizationId: UUID!) { exportOrganizationData(organizationId: $organizationId) }"
+        @transport.execute(query, { "organizationId" => organization_id })["exportOrganizationData"]
+      end
+
+      def configure_otlp(organization_id, input)
+        query = "mutation($organizationId: UUID!, $input: OTLPConfigInput!) { configureOTLP(organizationId: $organizationId, input: $input) { #{FRAGMENT} } }"
+        @transport.execute(query, { "organizationId" => organization_id, "input" => input })["configureOTLP"]
+      end
+
+      def disable_otlp(organization_id)
+        query = "mutation($organizationId: UUID!) { disableOTLP(organizationId: $organizationId) { #{FRAGMENT} } }"
+        @transport.execute(query, { "organizationId" => organization_id })["disableOTLP"]
+      end
+    end
+  end
+end