norbelys 0.1.0

data/docs/ProgramsApi.md

@@ -0,0 +1,1283 @@
+# Norbelys::ProgramsApi
+
+All URIs are relative to *https://api.norbelys.com/v1*
+
+| Method | HTTP request | Description |
+| ------ | ------------ | ----------- |
+| [**programs_archive**](ProgramsApi.md#programs_archive) | **DELETE** /programs/{id} | Archive a program |
+| [**programs_audience_list**](ProgramsApi.md#programs_audience_list) | **GET** /programs/{id}/audience | List a program's audience sources |
+| [**programs_create**](ProgramsApi.md#programs_create) | **POST** /programs | Create a program |
+| [**programs_enroll**](ProgramsApi.md#programs_enroll) | **POST** /programs/{id}/enroll | Enroll people into a program |
+| [**programs_enrollments_find**](ProgramsApi.md#programs_enrollments_find) | **GET** /programs/{programId}/enrollments/{id} | Get an enrollment |
+| [**programs_enrollments_list**](ProgramsApi.md#programs_enrollments_list) | **GET** /programs/{programId}/enrollments | List a program's leads |
+| [**programs_find**](ProgramsApi.md#programs_find) | **GET** /programs/{id} | Get a program |
+| [**programs_launch**](ProgramsApi.md#programs_launch) | **POST** /programs/{id}/launch | Launch a program |
+| [**programs_list**](ProgramsApi.md#programs_list) | **GET** /programs | List programs |
+| [**programs_pause**](ProgramsApi.md#programs_pause) | **POST** /programs/{id}/pause | Pause a program's sending |
+| [**programs_restore**](ProgramsApi.md#programs_restore) | **POST** /programs/{id}/restore | Restore an archived program |
+| [**programs_resume**](ProgramsApi.md#programs_resume) | **POST** /programs/{id}/resume | Resume a paused program |
+| [**programs_senders_add**](ProgramsApi.md#programs_senders_add) | **POST** /programs/{id}/senders | Attach a sender to a program |
+| [**programs_senders_list**](ProgramsApi.md#programs_senders_list) | **GET** /programs/{id}/senders | List a program's senders |
+| [**programs_senders_remove**](ProgramsApi.md#programs_senders_remove) | **DELETE** /programs/{id}/senders/{relId} | Detach a sender from a program |
+| [**programs_share**](ProgramsApi.md#programs_share) | **POST** /programs/{id}/share | Share the campaign report |
+| [**programs_update**](ProgramsApi.md#programs_update) | **PATCH** /programs/{id} | Update a program |
+
+
+## programs_archive
+
+> <Program> programs_archive(id)
+
+Archive a program
+
+Soft-delete the campaign and cancel its in-flight runs. Reversible with programs.restore.
+
+### Examples
+
+```ruby
+require 'time'
+require 'norbelys'
+# setup authorization
+Norbelys.configure do |config|
+  # Configure Bearer authorization: bearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Norbelys::ProgramsApi.new
+id = 'id_example' # String | 
+
+begin
+  # Archive a program
+  result = api_instance.programs_archive(id)
+  p result
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_archive: #{e}"
+end
+```
+
+#### Using the programs_archive_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<Program>, Integer, Hash)> programs_archive_with_http_info(id)
+
+```ruby
+begin
+  # Archive a program
+  data, status_code, headers = api_instance.programs_archive_with_http_info(id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <Program>
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_archive_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** |  |  |
+
+### Return type
+
+[**Program**](Program.md)
+
+### Authorization
+
+[bearerAuth](../README.md#bearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## programs_audience_list
+
+> <ProgramsAudienceList> programs_audience_list(id)
+
+List a program's audience sources
+
+Where this campaign's people came from — one entry per source (segment, group, CSV import, manual), with the people count enrolled from each and whether a segment is kept in continuous sync (dynamic audience).
+
+### Examples
+
+```ruby
+require 'time'
+require 'norbelys'
+# setup authorization
+Norbelys.configure do |config|
+  # Configure Bearer authorization: bearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Norbelys::ProgramsApi.new
+id = 'id_example' # String | 
+
+begin
+  # List a program's audience sources
+  result = api_instance.programs_audience_list(id)
+  p result
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_audience_list: #{e}"
+end
+```
+
+#### Using the programs_audience_list_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<ProgramsAudienceList>, Integer, Hash)> programs_audience_list_with_http_info(id)
+
+```ruby
+begin
+  # List a program's audience sources
+  data, status_code, headers = api_instance.programs_audience_list_with_http_info(id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <ProgramsAudienceList>
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_audience_list_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** |  |  |
+
+### Return type
+
+[**ProgramsAudienceList**](ProgramsAudienceList.md)
+
+### Authorization
+
+[bearerAuth](../README.md#bearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## programs_create
+
+> <ProgramDetail> programs_create(program_create_params, opts)
+
+Create a program
+
+Create a cold-email sequence. Optionally build the WHOLE cadence in one call by passing steps[] (each with inline variants[]); the response returns the program with its steps expanded. Then attach senders, enroll people, and launch.
+
+### Examples
+
+```ruby
+require 'time'
+require 'norbelys'
+# setup authorization
+Norbelys.configure do |config|
+  # Configure Bearer authorization: bearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Norbelys::ProgramsApi.new
+program_create_params = Norbelys::ProgramCreateParams.new({name: 'name_example'}) # ProgramCreateParams | 
+opts = {
+  idempotency_key: 'idempotency_key_example' # String | Opt-in idempotency for a safely retried write: reuse the same key to replay the original result for 24h instead of re-executing. Recommended on every POST.
+}
+
+begin
+  # Create a program
+  result = api_instance.programs_create(program_create_params, opts)
+  p result
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_create: #{e}"
+end
+```
+
+#### Using the programs_create_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<ProgramDetail>, Integer, Hash)> programs_create_with_http_info(program_create_params, opts)
+
+```ruby
+begin
+  # Create a program
+  data, status_code, headers = api_instance.programs_create_with_http_info(program_create_params, opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <ProgramDetail>
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_create_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **program_create_params** | [**ProgramCreateParams**](ProgramCreateParams.md) |  |  |
+| **idempotency_key** | **String** | Opt-in idempotency for a safely retried write: reuse the same key to replay the original result for 24h instead of re-executing. Recommended on every POST. | [optional] |
+
+### Return type
+
+[**ProgramDetail**](ProgramDetail.md)
+
+### Authorization
+
+[bearerAuth](../README.md#bearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## programs_enroll
+
+> <EnrollProgramResult> programs_enroll(id, opts)
+
+Enroll people into a program
+
+Add an audience as leads — the union of personIds, a groupId's members, and a segmentId's current matches (omit all to enroll every active person). Never starts sending on its own; call programs.launch to go live.
+
+### Examples
+
+```ruby
+require 'time'
+require 'norbelys'
+# setup authorization
+Norbelys.configure do |config|
+  # Configure Bearer authorization: bearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Norbelys::ProgramsApi.new
+id = 'id_example' # String | 
+opts = {
+  idempotency_key: 'idempotency_key_example', # String | Opt-in idempotency for a safely retried write: reuse the same key to replay the original result for 24h instead of re-executing. Recommended on every POST.
+  enroll_program_params: Norbelys::EnrollProgramParams.new # EnrollProgramParams | 
+}
+
+begin
+  # Enroll people into a program
+  result = api_instance.programs_enroll(id, opts)
+  p result
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_enroll: #{e}"
+end
+```
+
+#### Using the programs_enroll_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<EnrollProgramResult>, Integer, Hash)> programs_enroll_with_http_info(id, opts)
+
+```ruby
+begin
+  # Enroll people into a program
+  data, status_code, headers = api_instance.programs_enroll_with_http_info(id, opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <EnrollProgramResult>
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_enroll_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** |  |  |
+| **idempotency_key** | **String** | Opt-in idempotency for a safely retried write: reuse the same key to replay the original result for 24h instead of re-executing. Recommended on every POST. | [optional] |
+| **enroll_program_params** | [**EnrollProgramParams**](EnrollProgramParams.md) |  | [optional] |
+
+### Return type
+
+[**EnrollProgramResult**](EnrollProgramResult.md)
+
+### Authorization
+
+[bearerAuth](../README.md#bearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## programs_enrollments_find
+
+> <Enrollment> programs_enrollments_find(program_id, id)
+
+Get an enrollment
+
+### Examples
+
+```ruby
+require 'time'
+require 'norbelys'
+# setup authorization
+Norbelys.configure do |config|
+  # Configure Bearer authorization: bearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Norbelys::ProgramsApi.new
+program_id = 'program_id_example' # String | 
+id = 'id_example' # String | 
+
+begin
+  # Get an enrollment
+  result = api_instance.programs_enrollments_find(program_id, id)
+  p result
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_enrollments_find: #{e}"
+end
+```
+
+#### Using the programs_enrollments_find_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<Enrollment>, Integer, Hash)> programs_enrollments_find_with_http_info(program_id, id)
+
+```ruby
+begin
+  # Get an enrollment
+  data, status_code, headers = api_instance.programs_enrollments_find_with_http_info(program_id, id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <Enrollment>
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_enrollments_find_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **program_id** | **String** |  |  |
+| **id** | **String** |  |  |
+
+### Return type
+
+[**Enrollment**](Enrollment.md)
+
+### Authorization
+
+[bearerAuth](../README.md#bearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## programs_enrollments_list
+
+> <EnrollmentList> programs_enrollments_list(program_id, opts)
+
+List a program's leads
+
+The people enrolled in the program and where each sits in the cadence, with per-status counts for the Leads view.
+
+### Examples
+
+```ruby
+require 'time'
+require 'norbelys'
+# setup authorization
+Norbelys.configure do |config|
+  # Configure Bearer authorization: bearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Norbelys::ProgramsApi.new
+program_id = 'program_id_example' # String | 
+opts = {
+  cursor: 'cursor_example', # String | 
+  include_archived: true, # Boolean | 
+  limit: 56, # Integer | 
+  dir: 'asc', # String | 
+  page: 56, # Integer | 
+  q: 'q_example', # String | 
+  sort: 'created', # String | 
+  status: [['active']] # Array<String> | 
+}
+
+begin
+  # List a program's leads
+  result = api_instance.programs_enrollments_list(program_id, opts)
+  p result
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_enrollments_list: #{e}"
+end
+```
+
+#### Using the programs_enrollments_list_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<EnrollmentList>, Integer, Hash)> programs_enrollments_list_with_http_info(program_id, opts)
+
+```ruby
+begin
+  # List a program's leads
+  data, status_code, headers = api_instance.programs_enrollments_list_with_http_info(program_id, opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <EnrollmentList>
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_enrollments_list_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **program_id** | **String** |  |  |
+| **cursor** | **String** |  | [optional] |
+| **include_archived** | **Boolean** |  | [optional] |
+| **limit** | **Integer** |  | [optional] |
+| **dir** | **String** |  | [optional] |
+| **page** | **Integer** |  | [optional] |
+| **q** | **String** |  | [optional] |
+| **sort** | **String** |  | [optional] |
+| **status** | [**Array&lt;String&gt;**](String.md) |  | [optional] |
+
+### Return type
+
+[**EnrollmentList**](EnrollmentList.md)
+
+### Authorization
+
+[bearerAuth](../README.md#bearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## programs_find
+
+> <ProgramDetail> programs_find(id, opts)
+
+Get a program
+
+Read one program. Pass expand[]=steps to inline the cadence (each step with its arms) and expand[]=senders for the attached mailboxes.
+
+### Examples
+
+```ruby
+require 'time'
+require 'norbelys'
+# setup authorization
+Norbelys.configure do |config|
+  # Configure Bearer authorization: bearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Norbelys::ProgramsApi.new
+id = 'id_example' # String | 
+opts = {
+  expand: [['steps']] # Array<String> | 
+}
+
+begin
+  # Get a program
+  result = api_instance.programs_find(id, opts)
+  p result
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_find: #{e}"
+end
+```
+
+#### Using the programs_find_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<ProgramDetail>, Integer, Hash)> programs_find_with_http_info(id, opts)
+
+```ruby
+begin
+  # Get a program
+  data, status_code, headers = api_instance.programs_find_with_http_info(id, opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <ProgramDetail>
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_find_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** |  |  |
+| **expand** | [**Array&lt;String&gt;**](String.md) |  | [optional] |
+
+### Return type
+
+[**ProgramDetail**](ProgramDetail.md)
+
+### Authorization
+
+[bearerAuth](../README.md#bearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## programs_launch
+
+> <LaunchProgramResult> programs_launch(id, opts)
+
+Launch a program
+
+The go-live gate — the only path a draft becomes active. Requires at least one live sender, one step, and one enrolled lead. Returns any non-blocking compliance warnings.
+
+### Examples
+
+```ruby
+require 'time'
+require 'norbelys'
+# setup authorization
+Norbelys.configure do |config|
+  # Configure Bearer authorization: bearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Norbelys::ProgramsApi.new
+id = 'id_example' # String | 
+opts = {
+  idempotency_key: 'idempotency_key_example', # String | Opt-in idempotency for a safely retried write: reuse the same key to replay the original result for 24h instead of re-executing. Recommended on every POST.
+  launch_program_params: Norbelys::LaunchProgramParams.new # LaunchProgramParams | 
+}
+
+begin
+  # Launch a program
+  result = api_instance.programs_launch(id, opts)
+  p result
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_launch: #{e}"
+end
+```
+
+#### Using the programs_launch_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<LaunchProgramResult>, Integer, Hash)> programs_launch_with_http_info(id, opts)
+
+```ruby
+begin
+  # Launch a program
+  data, status_code, headers = api_instance.programs_launch_with_http_info(id, opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <LaunchProgramResult>
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_launch_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** |  |  |
+| **idempotency_key** | **String** | Opt-in idempotency for a safely retried write: reuse the same key to replay the original result for 24h instead of re-executing. Recommended on every POST. | [optional] |
+| **launch_program_params** | [**LaunchProgramParams**](LaunchProgramParams.md) |  | [optional] |
+
+### Return type
+
+[**LaunchProgramResult**](LaunchProgramResult.md)
+
+### Authorization
+
+[bearerAuth](../README.md#bearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## programs_list
+
+> <ProgramList> programs_list(opts)
+
+List programs
+
+List the org's campaigns (cold-email sequences), newest first, with per-campaign stats (leads, completion, next send).
+
+### Examples
+
+```ruby
+require 'time'
+require 'norbelys'
+# setup authorization
+Norbelys.configure do |config|
+  # Configure Bearer authorization: bearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Norbelys::ProgramsApi.new
+opts = {
+  cursor: 'cursor_example', # String | 
+  include_archived: true, # Boolean | 
+  limit: 56, # Integer | 
+  dir: 'asc', # String | 
+  page: 56, # Integer | 
+  archived: true, # Boolean | 
+  q: 'q_example', # String | 
+  sender_id: 'sender_id_example', # String | 
+  sort: 'created', # String | 
+  status: [['draft']] # Array<String> | 
+}
+
+begin
+  # List programs
+  result = api_instance.programs_list(opts)
+  p result
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_list: #{e}"
+end
+```
+
+#### Using the programs_list_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<ProgramList>, Integer, Hash)> programs_list_with_http_info(opts)
+
+```ruby
+begin
+  # List programs
+  data, status_code, headers = api_instance.programs_list_with_http_info(opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <ProgramList>
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_list_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **cursor** | **String** |  | [optional] |
+| **include_archived** | **Boolean** |  | [optional] |
+| **limit** | **Integer** |  | [optional] |
+| **dir** | **String** |  | [optional] |
+| **page** | **Integer** |  | [optional] |
+| **archived** | **Boolean** |  | [optional] |
+| **q** | **String** |  | [optional] |
+| **sender_id** | **String** |  | [optional] |
+| **sort** | **String** |  | [optional] |
+| **status** | [**Array&lt;String&gt;**](String.md) |  | [optional] |
+
+### Return type
+
+[**ProgramList**](ProgramList.md)
+
+### Authorization
+
+[bearerAuth](../README.md#bearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## programs_pause
+
+> <Program> programs_pause(id, opts)
+
+Pause a program's sending
+
+Stop sending; messages already queued still complete. Resume with programs.resume.
+
+### Examples
+
+```ruby
+require 'time'
+require 'norbelys'
+# setup authorization
+Norbelys.configure do |config|
+  # Configure Bearer authorization: bearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Norbelys::ProgramsApi.new
+id = 'id_example' # String | 
+opts = {
+  idempotency_key: 'idempotency_key_example' # String | Opt-in idempotency for a safely retried write: reuse the same key to replay the original result for 24h instead of re-executing. Recommended on every POST.
+}
+
+begin
+  # Pause a program's sending
+  result = api_instance.programs_pause(id, opts)
+  p result
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_pause: #{e}"
+end
+```
+
+#### Using the programs_pause_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<Program>, Integer, Hash)> programs_pause_with_http_info(id, opts)
+
+```ruby
+begin
+  # Pause a program's sending
+  data, status_code, headers = api_instance.programs_pause_with_http_info(id, opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <Program>
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_pause_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** |  |  |
+| **idempotency_key** | **String** | Opt-in idempotency for a safely retried write: reuse the same key to replay the original result for 24h instead of re-executing. Recommended on every POST. | [optional] |
+
+### Return type
+
+[**Program**](Program.md)
+
+### Authorization
+
+[bearerAuth](../README.md#bearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## programs_restore
+
+> <Program> programs_restore(id, opts)
+
+Restore an archived program
+
+Un-archive the campaign and revive the runs the archive cancelled, resuming what's left of the cadence.
+
+### Examples
+
+```ruby
+require 'time'
+require 'norbelys'
+# setup authorization
+Norbelys.configure do |config|
+  # Configure Bearer authorization: bearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Norbelys::ProgramsApi.new
+id = 'id_example' # String | 
+opts = {
+  idempotency_key: 'idempotency_key_example' # String | Opt-in idempotency for a safely retried write: reuse the same key to replay the original result for 24h instead of re-executing. Recommended on every POST.
+}
+
+begin
+  # Restore an archived program
+  result = api_instance.programs_restore(id, opts)
+  p result
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_restore: #{e}"
+end
+```
+
+#### Using the programs_restore_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<Program>, Integer, Hash)> programs_restore_with_http_info(id, opts)
+
+```ruby
+begin
+  # Restore an archived program
+  data, status_code, headers = api_instance.programs_restore_with_http_info(id, opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <Program>
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_restore_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** |  |  |
+| **idempotency_key** | **String** | Opt-in idempotency for a safely retried write: reuse the same key to replay the original result for 24h instead of re-executing. Recommended on every POST. | [optional] |
+
+### Return type
+
+[**Program**](Program.md)
+
+### Authorization
+
+[bearerAuth](../README.md#bearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## programs_resume
+
+> <Program> programs_resume(id, opts)
+
+Resume a paused program
+
+Resume sending from where it stopped — each lead keeps its place in the cadence.
+
+### Examples
+
+```ruby
+require 'time'
+require 'norbelys'
+# setup authorization
+Norbelys.configure do |config|
+  # Configure Bearer authorization: bearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Norbelys::ProgramsApi.new
+id = 'id_example' # String | 
+opts = {
+  idempotency_key: 'idempotency_key_example' # String | Opt-in idempotency for a safely retried write: reuse the same key to replay the original result for 24h instead of re-executing. Recommended on every POST.
+}
+
+begin
+  # Resume a paused program
+  result = api_instance.programs_resume(id, opts)
+  p result
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_resume: #{e}"
+end
+```
+
+#### Using the programs_resume_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<Program>, Integer, Hash)> programs_resume_with_http_info(id, opts)
+
+```ruby
+begin
+  # Resume a paused program
+  data, status_code, headers = api_instance.programs_resume_with_http_info(id, opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <Program>
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_resume_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** |  |  |
+| **idempotency_key** | **String** | Opt-in idempotency for a safely retried write: reuse the same key to replay the original result for 24h instead of re-executing. Recommended on every POST. | [optional] |
+
+### Return type
+
+[**Program**](Program.md)
+
+### Authorization
+
+[bearerAuth](../README.md#bearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## programs_senders_add
+
+> <ProgramSenderRef> programs_senders_add(id, add_program_sender_params, opts)
+
+Attach a sender to a program
+
+Assign a mailbox the program can send from (a program needs at least one to launch).
+
+### Examples
+
+```ruby
+require 'time'
+require 'norbelys'
+# setup authorization
+Norbelys.configure do |config|
+  # Configure Bearer authorization: bearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Norbelys::ProgramsApi.new
+id = 'id_example' # String | 
+add_program_sender_params = Norbelys::AddProgramSenderParams.new({sender_id: 'sender_id_example'}) # AddProgramSenderParams | 
+opts = {
+  idempotency_key: 'idempotency_key_example' # String | Opt-in idempotency for a safely retried write: reuse the same key to replay the original result for 24h instead of re-executing. Recommended on every POST.
+}
+
+begin
+  # Attach a sender to a program
+  result = api_instance.programs_senders_add(id, add_program_sender_params, opts)
+  p result
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_senders_add: #{e}"
+end
+```
+
+#### Using the programs_senders_add_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<ProgramSenderRef>, Integer, Hash)> programs_senders_add_with_http_info(id, add_program_sender_params, opts)
+
+```ruby
+begin
+  # Attach a sender to a program
+  data, status_code, headers = api_instance.programs_senders_add_with_http_info(id, add_program_sender_params, opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <ProgramSenderRef>
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_senders_add_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** |  |  |
+| **add_program_sender_params** | [**AddProgramSenderParams**](AddProgramSenderParams.md) |  |  |
+| **idempotency_key** | **String** | Opt-in idempotency for a safely retried write: reuse the same key to replay the original result for 24h instead of re-executing. Recommended on every POST. | [optional] |
+
+### Return type
+
+[**ProgramSenderRef**](ProgramSenderRef.md)
+
+### Authorization
+
+[bearerAuth](../README.md#bearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+
+
+## programs_senders_list
+
+> <ProgramsSendersList> programs_senders_list(id)
+
+List a program's senders
+
+The mailboxes assigned to this program, each with its pending queue in the program.
+
+### Examples
+
+```ruby
+require 'time'
+require 'norbelys'
+# setup authorization
+Norbelys.configure do |config|
+  # Configure Bearer authorization: bearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Norbelys::ProgramsApi.new
+id = 'id_example' # String | 
+
+begin
+  # List a program's senders
+  result = api_instance.programs_senders_list(id)
+  p result
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_senders_list: #{e}"
+end
+```
+
+#### Using the programs_senders_list_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<ProgramsSendersList>, Integer, Hash)> programs_senders_list_with_http_info(id)
+
+```ruby
+begin
+  # List a program's senders
+  data, status_code, headers = api_instance.programs_senders_list_with_http_info(id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <ProgramsSendersList>
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_senders_list_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** |  |  |
+
+### Return type
+
+[**ProgramsSendersList**](ProgramsSendersList.md)
+
+### Authorization
+
+[bearerAuth](../README.md#bearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## programs_senders_remove
+
+> <DetachResult> programs_senders_remove(id, rel_id)
+
+Detach a sender from a program
+
+Unassign a mailbox. A running campaign refuses to drop its last live sender — pause it first.
+
+### Examples
+
+```ruby
+require 'time'
+require 'norbelys'
+# setup authorization
+Norbelys.configure do |config|
+  # Configure Bearer authorization: bearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Norbelys::ProgramsApi.new
+id = 'id_example' # String | 
+rel_id = 'rel_id_example' # String | 
+
+begin
+  # Detach a sender from a program
+  result = api_instance.programs_senders_remove(id, rel_id)
+  p result
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_senders_remove: #{e}"
+end
+```
+
+#### Using the programs_senders_remove_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<DetachResult>, Integer, Hash)> programs_senders_remove_with_http_info(id, rel_id)
+
+```ruby
+begin
+  # Detach a sender from a program
+  data, status_code, headers = api_instance.programs_senders_remove_with_http_info(id, rel_id)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <DetachResult>
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_senders_remove_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** |  |  |
+| **rel_id** | **String** |  |  |
+
+### Return type
+
+[**DetachResult**](DetachResult.md)
+
+### Authorization
+
+[bearerAuth](../README.md#bearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## programs_share
+
+> <CampaignReportShare> programs_share(id, opts)
+
+Share the campaign report
+
+Mint a public, read-only link to this campaign's report (send it to a client — no account needed). The link is signed and expires after 30 days; archiving the campaign kills it immediately. Mint again for a fresh link.
+
+### Examples
+
+```ruby
+require 'time'
+require 'norbelys'
+# setup authorization
+Norbelys.configure do |config|
+  # Configure Bearer authorization: bearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Norbelys::ProgramsApi.new
+id = 'id_example' # String | 
+opts = {
+  idempotency_key: 'idempotency_key_example' # String | Opt-in idempotency for a safely retried write: reuse the same key to replay the original result for 24h instead of re-executing. Recommended on every POST.
+}
+
+begin
+  # Share the campaign report
+  result = api_instance.programs_share(id, opts)
+  p result
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_share: #{e}"
+end
+```
+
+#### Using the programs_share_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<CampaignReportShare>, Integer, Hash)> programs_share_with_http_info(id, opts)
+
+```ruby
+begin
+  # Share the campaign report
+  data, status_code, headers = api_instance.programs_share_with_http_info(id, opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <CampaignReportShare>
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_share_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** |  |  |
+| **idempotency_key** | **String** | Opt-in idempotency for a safely retried write: reuse the same key to replay the original result for 24h instead of re-executing. Recommended on every POST. | [optional] |
+
+### Return type
+
+[**CampaignReportShare**](CampaignReportShare.md)
+
+### Authorization
+
+[bearerAuth](../README.md#bearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: Not defined
+- **Accept**: application/json
+
+
+## programs_update
+
+> <ProgramDetail> programs_update(id, opts)
+
+Update a program
+
+Patch program settings and/or edit the cadence in one call. steps[] is a sparse upsert: an item WITH id edits that step, WITHOUT id creates one, archived:true removes it — same for each step's variants[]. Returns the program with its steps expanded.
+
+### Examples
+
+```ruby
+require 'time'
+require 'norbelys'
+# setup authorization
+Norbelys.configure do |config|
+  # Configure Bearer authorization: bearerAuth
+  config.access_token = 'YOUR_BEARER_TOKEN'
+end
+
+api_instance = Norbelys::ProgramsApi.new
+id = 'id_example' # String | 
+opts = {
+  program_update_params: Norbelys::ProgramUpdateParams.new # ProgramUpdateParams | 
+}
+
+begin
+  # Update a program
+  result = api_instance.programs_update(id, opts)
+  p result
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_update: #{e}"
+end
+```
+
+#### Using the programs_update_with_http_info variant
+
+This returns an Array which contains the response data, status code and headers.
+
+> <Array(<ProgramDetail>, Integer, Hash)> programs_update_with_http_info(id, opts)
+
+```ruby
+begin
+  # Update a program
+  data, status_code, headers = api_instance.programs_update_with_http_info(id, opts)
+  p status_code # => 2xx
+  p headers # => { ... }
+  p data # => <ProgramDetail>
+rescue Norbelys::ApiError => e
+  puts "Error when calling ProgramsApi->programs_update_with_http_info: #{e}"
+end
+```
+
+### Parameters
+
+| Name | Type | Description | Notes |
+| ---- | ---- | ----------- | ----- |
+| **id** | **String** |  |  |
+| **program_update_params** | [**ProgramUpdateParams**](ProgramUpdateParams.md) |  | [optional] |
+
+### Return type
+
+[**ProgramDetail**](ProgramDetail.md)
+
+### Authorization
+
+[bearerAuth](../README.md#bearerAuth)
+
+### HTTP request headers
+
+- **Content-Type**: application/json
+- **Accept**: application/json
+