Chronicle integrates Datomic into Ruby on Rails Active Record, providing seamless CRuby/JRuby transport auto-detection, immutable time-travel queries, and cross-database ACID transaction coordination.
Include "Lightning-Fast Modular CSS with No Side Effects" Basscss in Rails. Basscss is a lightweight collection of base element styles and immutable utilities designed for speed, clarity, performance, and scalability.
PCN (Portable Chess Notation) provides a comprehensive, JSON-based format for representing complete chess game records across variants. This gem implements the PCN Specification v1.0.0 with a modern Ruby interface featuring immutable game objects and functional programming principles. PCN integrates the Sashité ecosystem specifications (PMN for moves, FEEN for positions, and SNN for style identification) to create a unified, rule-agnostic game recording system. Supports traditional single-variant games and cross-variant scenarios where players use different game systems, with complete metadata tracking including player information, tournament context, and game status. Perfect for game engines, database storage, game analysis tools, and archival systems requiring comprehensive game record management across diverse abstract strategy board games.
A Ruby library for terminal text styling with ANSI colors and effects. Provides an elegant, functional API with immutable style objects that can be composed using the >> operator. Supports standard colors, hex values, and comprehensive text effects including bold, faint, italic, underline, overline, blink, inverse, and concealed text. Features type-safe argument validation using dry-schema and dry-types.
STN (State Transition Notation) provides a rule-agnostic format for describing state transitions in abstract strategy board games. This gem implements the STN Specification v1.0.0 with a modern Ruby interface featuring immutable transition objects and functional programming principles. STN captures net changes between game positions by recording modifications in piece locations, hand/reserve contents, and active player status using standardized CELL coordinates and QPI piece identification. Perfect for game engines, position diff tracking, undo/redo systems, and network synchronization requiring efficient state delta representation across multiple game types and traditions.
Immutable Attributes is an ActiveRecord extension that prevents existing data from changing
Immutable Attributes is an ActiveRecord extension that prevents existing data from changing
Killer Frost provides a simple and easy way to make objects immutable in Ruby. Creating immutable objects help to remove undesired side effects.
Declare methods as immutable.
Immutable configuration management for disposable infrastructures
I8 (Immutable) is an extension of Hamster with a convenient name.
Immutable
An immutable, part-aware builder and renderer for Cypher statements, modelled on the design of Neo4j's Cypher-DSL for Java.
Framework-independent Ruby SDK for supported AP2 Checkout profiles: Merchant JWT signing, Direct and conditional Mandate issuance and presentation, full verification with immutable Evidence, Checkout Receipts, Direct and conditional Payment Mandates, and Payment Receipts. Adds selective Checkout/Payment, PISP/date constraints opt-in transactional Payment acceptance/idempotency support and explicit bounded JPY/ON_DEMAND quotas and separate long Open UTC-monthly JPY profiles with protected current authority and Root/key continuity. Requires independently trusted application inputs; verification does not grant purchase or payment permission.
Declares the shape of a result and renders entities into immutable Data
Manage tmux sessions, windows and panes with Ruby handles, immutable snapshots and control connections.
Adornment Core provides declarative method annotations for Ruby. Define annotation types, attach immutable metadata to the next method definition, and inspect annotations along Ruby's method lookup chain. Detects annotation declarations left without a method. Pure Ruby with no runtime dependencies. Does not wrap or replace methods. Supports CRuby 3.3 and later.
Module-based grammars, immutable Data matchers and AST nodes with source spans, packrat memoization, commit points, labels, and Success/Failure results.
Reusable configuration documents, command declarations, platform profiles, immutable results and parsing primitives for network automation.
Independent configuration and runtime parsers for VXLAN fabrics, with immutable snapshots and injected collection sessions.
Parses the payload of the Swiss QR Code on a Swiss QR-bill (QR-Rechnung, QR-facture, QR-fattura; Switzerland and Liechtenstein) per the SIX Swiss Implementation Guidelines for the QR-bill ("SPC"/"0200") into immutable value objects: account and QR-IBAN, creditor and debtor addresses, amount, currency, QR/creditor reference, message, Swico S1 billing information and alternative procedures. Validates every rule of the guidelines, including IBAN, QR reference and ISO 11649 check digits. Optionally reads the QR codes from images and PDFs with the qr_reader gem.
Sequential declared command execution over injected sessions, with immutable receipts, failure classification and source digests.
A client for the sferik.net API: Erik Berlin's bio, GitHub contributions, projects, talks, and resume (as JSON Resume, LaTeX, or PDF), with immutable response objects
Domain matching, cached DNS, IP address ranges, service encoding and immutable interval sets.
IPv4/IPv6 UDP, ICMP and TCP SYN traceroute with immutable observations, cancellation, and structured batch results.
Immutable, shareable Redis, Sentinel and Cluster configuration with isolated runtime state, pools, and sockets per Ractor. Supports pipelines, blocking commands, and Pub/Sub.
Build service objects with isolated execution contexts, immutable results, and named callbacks.
Provides immutable session records, event envelopes, an in-memory store with concurrency guardrails, a durable provider-backed store for restart-safe sessions, a replayable host with subscriptions, a runtime tool-lifecycle sink, and a state reducer that reconstructs session snapshots from event history.
Define an immutable collection of named callbacks and invoke them with arguments.
The single owner of the tebako factories' release machinery: the de-rendezvoused per-leg uploader (shards + sidecars, byte-immutable keeps, convergence and rate-limit ride-outs) and the no-fold OpenPGP release signer. Factories consume the gem; they never carry copies of the machinery.
The durable record layer for EventEngine: an immutable, append-only event table the host owns, a handler that records every dispatched event, and event-sourcing replay. Depends on event_engine for event definitions.
Texel provides a compact immutable image container, stb-based codecs, QOI, color and channel conversion, mipmap generation, and GPU upload helpers.
Immutable text ropes plus bounded-memory, file-backed editing with line and UTF-16 indexing.
EventRail adds immutable domain events, stable, fact-derived identity, logical context propagation, and Rails-native durable fanout without replacing Active Job or its queue adapter.
Issue immutable invoices with a small, idiomatic Ruby client.
kit-rb wraps the Kit v4 REST API with API-key and OAuth 2.0 auth, cursor pagination, typed errors, and immutable value objects.
Immutable, typed Ruby enums with RBS comments and no runtime dependencies.
Styxable turns deletion into a three-stage lifecycle for ActiveRecord models: active, archived, purged. Calling styx_archive soft-deletes a record — it (optionally) vanishes from default scopes like being in a trash can or recycle bin, but the row survives, so foreign keys, joins, reports and audits keep working. Archived records can still be listed, counted and restored during a configurable grace or retention period, giving you an undo window or restore window instead of an irreversible destroy. While a record sits in the archive it is immutable: writes are rejected, so nothing can be silently edited between archiving and erasure — like in a vault. styx_unarchive brings a record back, unless it cannot, for example when a newer record has claimed a unique attribute in the meantime. Archiving cascades along dependent: associations, so closing an account, deactivating a user or tearing down a tenant can archive everything it owns in a single call, with callbacks around each step. Each model declares its own data retention period. A recurring background job then permanently destroys records whose retention window has expired, expressing your retention schedule, records disposition and automatic purge in code rather than in a runbook — useful for GDPR storage limitation and right to erasure ("right to be forgotten") obligations, or any policy with a TTL or expiry date. A before-purge callback lets you detach ActiveStorage blobs, delete remote files or notify external systems before a record crosses the Styx for good.
An HTTP client with immutable models for the Tama neural, memory, perception, agentic, and broadcast APIs.
Pluckr lets you declare the shape of the data you need and compiles it into a single SQL statement, returning lightweight immutable result objects instead of ActiveRecord models. Works on PostgreSQL, MySQL and SQLite.
A dependency-free Ruby core for immutable WebMCP definitions and safe manifests, with optional MCP SDK projection and Rails 7.1+ integration.
# 1MSG Ruby SDK Official Ruby SDK for the **1MSG WhatsApp Business API**. This document is generated from the public OpenAPI contract. It covers install, auth, quick start, and every public operation available in the client. | | | |---|---| | **RubyGems** | [`one_msg_sdk`](https://rubygems.org/gems/one_msg_sdk) | | **Source** | [github.com/1msg/1msg-sdk/ruby](https://github.com/1msg/1msg-sdk/tree/main/ruby) | | **API docs** | [docs.1msg.io](https://docs.1msg.io/) | | **Platform** | [platform.1msg.io](https://platform.1msg.io/) | | **Support** | support@1msg.io | | **OpenAPI version** | 1.0.0 | | **Operations** | 60 | | **AI agent guide** | [AGENTS.md](./AGENTS.md) | --- ## Install ```bash gem install one_msg_sdk -v 2.0.2 ``` ## Requirements | Variable | Where to get it | Example | |----------|-----------------|---------| | `baseUrl` | Platform → channel → API host | `https://api.1msg.io` | | `instanceId` | Platform → channel id | `ODI371267300` | | `token` | Platform → channel → API token | JWT or API key | Use environment variables (`MSG_API_TOKEN`, `MSG_INSTANCE_ID`). Never commit tokens. ## Quick start ```ruby require 'one_msg_sdk' OneMsgSdk.configure do |config| config.host = "https://api.1msg.io/#{ENV.fetch('MSG_INSTANCE_ID')}" end messaging = OneMsgSdk::MessagingApi.new messaging.send_message( ENV.fetch('MSG_API_TOKEN'), 'Hello from 1MSG SDK', nil, '12020721369@c.us' ) ``` ## Authentication All requests use query-token auth: ```text https://{baseUrl}/{instanceId}/{path}?token={token} ``` Pass the channel token as the first argument to generated API methods. ## Recipient addressing - `chatId`: `12020721369@c.us` (1:1) or `...@g.us` (group) - `phone`: country code + number, no `+` - Exactly one of `chatId` | `phone` per request ## 24-hour messaging window Free-form `sendMessage` only works inside the 24h customer-care window. Outside that window use `sendTemplate`. ## Client map ```ruby MessagingApi # send/list messages, media, interactive ProfileApi # getMe GroupsApi # create/list/manage groups FlowsApi # WhatsApp Flows lifecycle TemplatesApi # listTemplates ChannelApi # channel helpers CallingApi # calling WebhooksApi # webhooks ``` ## Package notes Gem name is `one_msg_sdk`. Module is `OneMsgSdk`. ## API reference API groups: calling, catalog, channel, flows, groups, messaging, profile, templates, users, webhooks. ### calling #### `getCallingSettings` Get calling settings Return WhatsApp Calling API settings for this channel (beta). Proxies upstream `GET /calling/settings`. **Prerequisites** - Number must be eligible for Meta Calling (Cloud API; not COEX) - Trial / `subscriptionBlocked` channels receive **403** plain text - You need your own WebRTC or SIP stack; 1msg is a **signaling proxy** only and does **not** store call history or recordings See the **Calling** tag overview for inbound/outbound flows and webhooks. ```yaml http: GET /callingSettings operationId: getCallingSettings clientGroup: calling responses: 200, 401, 500 ``` #### `initiateCall` Call action (connect / pre_accept / accept / reject / terminate) Perform a WhatsApp Calling action (beta). Proxies upstream `POST /calling/calls`. Despite the historical path name `/initiateCall`, this endpoint handles **all** call actions: | action | Use | Required | |--------|-----|----------| | `connect` | Outbound business → user | `to` + `session` (`sdp_type: offer`) | | `pre_accept` | Inbound (optional, reduces audio clipping) | `call_id` + `session` (`sdp_type: answer`) | | `accept` | Inbound answer | `call_id` + `session` (`sdp_type: answer`) | | `reject` | Decline inbound | `call_id` | | `terminate` | Hang up | `call_id` | **SDP / media (critical)** - `accept` / `pre_accept` require a **WebRTC-generated SDP answer**. - Do **not** send Meta's offer SDP back as the answer. - Postman (or curl) alone **cannot** establish real media — you need a WebRTC or SIP stack. 1msg only proxies signaling. Answer within ~**30–60 seconds** of an inbound `connect` webhook or Meta terminates as unanswered. Common Meta errors include Calling not enabled (`138000`), no permission (`138006`), SDP validation failures. **Outbound** requires a prior Call Permission Request (CPR) acceptance. See the **Calling** tag overview for the full outbound flow and CPR limits. Trial / `subscriptionBlocked` → **403** plain text. Upstream failures often return HTTP 200 with `{ "response": { "error": "..." } }`. ```yaml http: POST /initiateCall operationId: initiateCall clientGroup: calling responses: 200, 401, 500 ``` #### `updateCallingSettings` Update calling settings Enable, disable, or update WhatsApp Calling settings (beta). Proxies upstream `POST /calling/settings`. Body is forwarded as-is (1msg does not validate fields). **Common fields under `calling`** - `status` (`ENABLED` | `DISABLED`) — required to turn calling on/off - `call_icon_visibility` (`DEFAULT` | `DISABLE_ALL`) — optional - `callback_permission_status` (`ENABLED` | `DISABLED`) — optional; when enabled, inbound user calls grant callback permission - `call_hours` — optional hours / timezone object - `sip` — optional SIP trunk; when SIP is ENABLED, Graph call actions and calling webhooks are not used - `srtp_key_exchange_protocol` (`DTLS` | `SDES`) — SDES only with SIP - `video.status` — optional Meta may accept only one feature group per request — prefer focused updates (e.g. enable status first, then SIP). Trial / `subscriptionBlocked` → **403** plain text. ```yaml http: POST /callingSettings operationId: updateCallingSettings clientGroup: calling responses: 200, 401, 500 ``` ### catalog #### `createCommerce` Set Commerce Settings Update catalog/cart commerce settings via the `params` object. - `params.is_catalog_visible` — show catalog storefront icon (`true`) or hide it (`false`). - `params.is_cart_enabled` — enable cart (`true`) or disable it (`false`). Blocked when the channel subscription limit is exceeded. Requires a commerce-capable channel (Cloud Functions `/commerceWAV2`). ```yaml http: POST /commerce operationId: createCommerce clientGroup: catalog responses: 200, 401, 500 ``` #### `getCommerce` Get Commerce Settings Returns catalog/cart commerce settings for the channel. - `is_catalog_visible` — show catalog storefront icon (`true`) or hide it (`false`). - `is_cart_enabled` — enable cart (`true`) or disable it (`false`). ```yaml http: GET /commerce operationId: getCommerce clientGroup: catalog responses: 200, 401, 500 ``` ### channel #### `getConversationalAutomation` Get conversational automation settings Get WhatsApp conversational components for the channel (welcome message, ice-breaker prompts, and slash commands). Proxies Meta/360dialog `GET /conversational_automation`. When `enable_welcome_message` is true and a user opens chat for the first time, Meta delivers a webhook message with `type: request_welcome`. The inbound formatter exposes that as `type: "request_welcome"` and `meta.request_welcome: true` so your webhook can send a custom welcome reply. ```yaml http: GET /conversationalAutomation operationId: getConversationalAutomation clientGroup: channel responses: 200, 401, 500 ``` #### `getStatus` Get channel status Returns WhatsApp Business API client connection status. ```yaml http: GET /status operationId: getStatus clientGroup: channel responses: 200, 401, 500 ``` #### `setConversationalAutomation` Set conversational automation settings Update WhatsApp conversational components. Allowed body fields (others are ignored): - `enable_welcome_message` (boolean) - `prompts` (string[], max 4, each ≤ 80 chars) - `commands` (`{ command_name, command_description }[]`) Proxies Meta/360dialog `POST /conversational_automation`. ```yaml http: POST /conversationalAutomation operationId: setConversationalAutomation clientGroup: channel responses: 200, 401, 500 ``` ### flows #### `createFlows` Create Flow ```yaml http: POST /flows operationId: createFlows clientGroup: flows responses: 200 ``` #### `createFlowsFlowIdDeprecate` Deprecate Flow ```yaml http: POST /flows/{flowId}/deprecate operationId: createFlowsFlowIdDeprecate clientGroup: flows responses: 200 ``` #### `createFlowsFlowIdPublish` Publish Flow ```yaml http: POST /flows/{flowId}/publish operationId: createFlowsFlowIdPublish clientGroup: flows responses: 200 ``` #### `deleteFlowsFlowId` Delete Flow ```yaml http: DELETE /flows/{flowId} operationId: deleteFlowsFlowId clientGroup: flows responses: 200 ``` #### `getFlowsFlowId` Get Flow Details ```yaml http: GET /flows/{flowId} operationId: getFlowsFlowId clientGroup: flows responses: 200 ``` #### `getFlowsFlowIdPreview` Preview Flow ```yaml http: GET /flows/{flowId}/preview operationId: getFlowsFlowIdPreview clientGroup: flows responses: 200 ``` #### `getWhatsappBusinessEncryption` Get business encryption public key Retrieve the WhatsApp business public key and signature status for this channel's phone number. Required before publishing or sending Flows that use data encryption. ```yaml http: GET /whatsapp_business_encryption operationId: getWhatsappBusinessEncryption clientGroup: flows responses: 200, 401, 500 ``` #### `listFlows` List Flows ```yaml http: GET /flows operationId: listFlows clientGroup: flows responses: 200 ``` #### `patchFlowsFlowIdAssets` Update Flow Structure ```yaml http: PATCH /flows/{flowId}/assets operationId: patchFlowsFlowIdAssets clientGroup: flows responses: 200 ``` #### `patchFlowsFlowIdMetadata` Update Flow Metadata ```yaml http: PATCH /flows/{flowId}/metadata operationId: patchFlowsFlowIdMetadata clientGroup: flows responses: 200 ``` #### `setWhatsappBusinessEncryption` Set business encryption public key Upload and sign a 2048-bit RSA business public key (PEM) for this channel's phone number. Meta requires a signed key before Flow publish/send. Only one active key per number; a new upload replaces the previous key. ```yaml http: POST /whatsapp_business_encryption operationId: setWhatsappBusinessEncryption clientGroup: flows responses: 200, 400, 401, 500 ``` ### groups #### `createGroups` Create Group ```yaml http: POST /groups operationId: createGroups clientGroup: groups responses: 200 ``` #### `createGroupsGroupId` Update Group Info ```yaml http: POST /groups/{groupId} operationId: createGroupsGroupId clientGroup: groups responses: 200 ``` #### `createGroupsGroupIdInvitelink` Reset Invite Link ```yaml http: POST /groups/{groupId}/inviteLink operationId: createGroupsGroupIdInvitelink clientGroup: groups responses: 200 ``` #### `deleteGroupsGroupId` Delete Group ```yaml http: DELETE /groups/{groupId} operationId: deleteGroupsGroupId clientGroup: groups responses: 200 ``` #### `getGroupsGroupId` Get Group Info ```yaml http: GET /groups/{groupId} operationId: getGroupsGroupId clientGroup: groups responses: 200 ``` #### `getGroupsGroupIdInvitelink` Get Invite Link ```yaml http: GET /groups/{groupId}/inviteLink operationId: getGroupsGroupIdInvitelink clientGroup: groups responses: 200 ``` #### `listGroups` Get Groups List ```yaml http: GET /groups operationId: listGroups clientGroup: groups responses: 200 ``` ### messaging #### `createReadMessage` Mark message as read ```yaml http: POST /readMessage operationId: createReadMessage clientGroup: messaging responses: 200, 401 ``` #### `createUploadMedia` Upload media ```yaml http: POST /uploadMedia operationId: createUploadMedia clientGroup: messaging responses: 200 ``` #### `deleteMedia` Delete media from WABA storage Delete previously uploaded media by numeric `mediaId` (from `/uploadMedia`). This is the canonical deletion endpoint and uses the REST `DELETE` verb on the media resource path. The older `POST /deleteMedia` is a deprecated alias. ```yaml http: DELETE /media/{mediaId} operationId: deleteMedia clientGroup: messaging responses: 200, 400, 401, 500 ``` #### `deleteMediaLegacy` Delete media from WABA storage (deprecated alias) **Deprecated.** Use `DELETE /media/{mediaId}` instead. This POST alias is kept for backward compatibility with earlier integrations. New integrations should call `DELETE /media/{mediaId}`: 1msg follows REST conventions for resource deletion going forward (delete a resource with the `DELETE` verb on its resource path). ```yaml http: POST /deleteMedia operationId: deleteMediaLegacy clientGroup: messaging responses: 200, 400, 401, 500 ``` #### `getMmLiteStatus` Get MM Lite availability and status ```yaml http: GET /mmLiteStatus operationId: getMmLiteStatus clientGroup: messaging responses: 200, 401, 500 ``` #### `listMessages` Get messages list ```yaml http: GET /messages operationId: listMessages clientGroup: messaging responses: 200 ``` #### `retrieveMedia` Retrieve uploaded media metadata Get WABA media URL and metadata by mediaId (from uploadMedia). The returned `url` is temporary and typically expires within ~5 minutes. ```yaml http: GET /retrieveMedia operationId: retrieveMedia clientGroup: messaging responses: 200, 400, 401, 500 ``` #### `sendAddressMessage` Send address request message Request shipping address from the user (WhatsApp interactive `address_message`). **India and Singapore only.** Requires: - Business WhatsApp number registered in that country - Recipient phone matching the country (`+91` ↔ `IN`, `+65` ↔ `SG`) Pass `country: "IN"` or `country: "SG"`. Eligibility is validated upstream; mismatches (e.g. Singapore phone with `country: "IN"`) return errors such as `Unsupported Interactive Message type` (HTTP 200 with `sent: false`). Optional action parameters: `values`, `saved_addresses`, `validation_errors`. ```yaml http: POST /sendAddressMessage operationId: sendAddressMessage clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` #### `sendButton` Send Reply Buttons Message ```yaml http: POST /sendButton operationId: sendButton clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` #### `sendCarousel` Send Carousel You can send product cards via Carousel in two ways: Template messages: do not require a 24-hour customer service window between you and the recipient. Use sendTemplate. Free-form messages: can be sent only when a customer service window is open between you and the recipient. Use sendCarousel. The message structure in /sendCarousel is largely similar to sending a template. However, in this case you must explicitly specify all elements that are created in advance when working with templates. This is because the message is sent without using a template. In /sendCarousel, for sending a Catalog Carousel there can be either 1 URL button or one or more quick reply buttons. ```yaml http: POST /sendCarousel operationId: sendCarousel clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` #### `sendContact` Send a Contact ```yaml http: POST /sendContact operationId: sendContact clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` #### `sendCtaUrl` Send CTA URL interactive message Send an interactive message with a single call-to-action URL button. ```yaml http: POST /sendCtaUrl operationId: sendCtaUrl clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` #### `sendFile` Send a File Send a file to an existing chat. (Only if the dialogue has an Open Session). Only one of two parameters is needed to determine the destination - chatId or phone. ```yaml http: POST /sendFile operationId: sendFile clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` #### `sendFlow` Send WhatsApp Flow Message Send Interactive WhatsApp Flow message to an existing chat. (Only if the dialogue has an Open Session). Only one of two parameters is needed to determine the destination - chatId or phone. Use this method to send a published WhatsApp Flow as a service (interactive) message. If the 24-hour window is closed, send a template with a FLOW button via /sendTemplate. ```yaml http: POST /sendFlow operationId: sendFlow clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` #### `sendList` Send List Message ```yaml http: POST /sendList operationId: sendList clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` #### `sendLocation` Send a Location Send a location to an existing chat. (Only if the dialogue has an Open Session). Only one of two parameters is needed to determine the destination - chatId or phone. ```yaml http: POST /sendLocation operationId: sendLocation clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` #### `sendLocationRequest` Send Location Request Message ```yaml http: POST /sendLocationRequest operationId: sendLocationRequest clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` #### `sendMessage` Send a Message Send a message to an existing chat. (Only if the dialogue has an Open Session). The message will be added to the queue for sending and delivered even if the phone is disconnected from the Internet or authorization is not passed. Only one of two parameters is needed to determine the destination - chatId or phone. ```yaml http: POST /sendMessage operationId: sendMessage clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` #### `sendOrderDetails` Send order details (India payments template) Send a WhatsApp **order details** payment / invoice message using a pre-approved **Utility** template that has an `ORDER_DETAILS` button. **India only** (WhatsApp Payments India). Requires: - India WhatsApp Business number - Commerce enabled on the channel (`GET`/`POST /commerce`) - Approved template with an `ORDER_DETAILS` button Use this method when you need structured fields (`order`, `referenceId`, `currency`, `paymentSettings`). The API appends a template button `sub_type: order_details` and sends via the same path as `POST /sendTemplate`. Works **outside the 24-hour session window** (template message). You can also send the same payload yourself with `POST /sendTemplate` by including a button component in `params`: ```json { "type": "button", "sub_type": "order_details", "index": 0, "parameters": [{ "type": "action", "action": { "order_details": { "reference_id": "order-123", "currency": "INR", "order": { "status": "pending", "items": [], "subtotal": { "offset": 100, "value": 50000 } } } } }] } ``` ```yaml http: POST /sendOrderDetails operationId: sendOrderDetails clientGroup: messaging responses: 200, 400, 401, 500 ``` #### `sendPaymentRequest` Send payment request (regional) Send a regional payment request interactive message (beta scaffold). `region` must be IN, SG, or BR. Payload shape follows Meta regional payments docs; verify on stage before production use. Full regional builders are not implemented yet. ```yaml http: POST /sendPaymentRequest operationId: sendPaymentRequest clientGroup: messaging responses: 200, 400, 401, 500 ``` #### `sendProduct` Send a Product ```yaml http: POST /sendProduct operationId: sendProduct clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` #### `sendReaction` Send Reaction ```yaml http: POST /sendReaction operationId: sendReaction clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` #### `sendSticker` Send sticker message Send a WhatsApp sticker by mediaId or link URL. ```yaml http: POST /sendSticker operationId: sendSticker clientGroup: messaging responses: 200, 400, 401, 429, 500 ``` ### profile #### `getMe` Get Profile Info Get WhatsApp Business Account profile information ```yaml http: GET /me operationId: getMe clientGroup: profile responses: 200, 401, 500 ``` #### `updateMe` Update profile info Update WhatsApp Business Account profile fields. At least one of about, description, email, photo, address, vertical, websites is required. Blocked when the channel subscription limit is exceeded. ```yaml http: POST /me operationId: updateMe clientGroup: profile responses: 200, 401, 422, 500 ``` ### templates #### `addTemplate` Create message template ```yaml http: POST /addTemplate operationId: addTemplate clientGroup: templates responses: 200, 401, 500 ``` #### `listTemplates` Get templates list ```yaml http: GET /templates operationId: listTemplates clientGroup: templates responses: 200 ``` #### `removeTemplate` Remove message template ```yaml http: POST /removeTemplate operationId: removeTemplate clientGroup: templates responses: 200, 401, 500 ``` #### `sendTemplate` Send Template Message Send a WhatsApp template message (works outside the 24-hour session window). Supported `params` button `sub_type` values include: `url`, `quick_reply`, `copy_code` / `coupon_code`, `catalog`, `flow`, `limited_time_offer`, and **`order_details`** (WhatsApp Payments **India only** — requires an approved Utility template with an ORDER_DETAILS button). For India order/invoice payments outside 24h, include a button component: ```json { "type": "button", "sub_type": "order_details", "index": 0, "parameters": [{ "type": "action", "action": { "order_details": { "reference_id": "...", "currency": "INR", "order": {} } } }] } ``` Convenience wrapper with structured fields: `POST /sendOrderDetails`. ```yaml http: POST /sendTemplate operationId: sendTemplate clientGroup: templates responses: 200 ``` ### users #### `blockUser` Block WhatsApp user ```yaml http: POST /blockUser operationId: blockUser clientGroup: users responses: 200, 400, 401, 500 ``` #### `listBlockedUsers` List blocked WhatsApp users Returns users currently blocked on this WhatsApp channel (WABA `GET /block_users`). Same channel token auth as `blockUser` / `unblockUser`. ```yaml http: GET /blockedUsers operationId: listBlockedUsers clientGroup: users responses: 200, 401, 500 ``` #### `unblockUser` Unblock WhatsApp user ```yaml http: POST /unblockUser operationId: unblockUser clientGroup: users responses: 200, 400, 401, 500 ``` ### webhooks #### `getWebhook` Get webhook URL Returns the configured client webhook URL for this channel. ```yaml http: GET /webhook operationId: getWebhook clientGroup: webhooks responses: 200, 401, 500 ``` #### `setWebhook` Set webhook URL Configure the client webhook URL for inbound events. WhatsApp **Calling** events (`field=calls`) are forwarded as passthrough payloads with `type: "calls"` and `instanceId` (connect / status / terminate). Call permission replies arrive on the normal messages path (`call_permission_reply`). Details: **Calling** tag. ```yaml http: POST /webhook operationId: setWebhook clientGroup: webhooks responses: 200, 401, 500 ``` ## Cookbook 1. Install the package from the registry above. 2. Set `MSG_API_TOKEN` and `MSG_INSTANCE_ID`. 3. Create the messaging client with `{baseUrl}/{instanceId}`. 4. Call `sendMessage` inside the 24h window, or `sendTemplate` outside it. 5. Use group/profile/flows/templates APIs for advanced workflows. ## FAQ **Where is the package?** See the registry link in the header table. **TypeScript has createClient — does this SDK?** Generated OpenAPI clients use per-API classes (`MessagingApi`, `ProfileApi`, …) instead of a facade. **Can I use this in a browser?** No — server-side only. Never expose tokens. ## Error handling | Code | Meaning | |------|---------| | 400 | Invalid parameters or body | | 401 | Invalid or missing token | | 429 | Rate limit exceeded | | 500 | Internal server error | ## Regeneration and versioning Docs regenerate with `node gen/generate-sdk-docs-langs.js`. Registry versions are immutable. ## License MIT © 1MSG
A persistent (immutable) Hash Array Mapped Trie
Serviced is a small framework for building service objects. Inputs are declared as typed, immutable attributes (backed by ActiveModel), can be validated with the ActiveModel validation DSL, and every call returns an explicit Success or Failure result. Services compose into flows that run with or without a database transaction.
Signoff adds convention-over-configuration approval workflows to ActiveRecord models. Declare states and transitions with a simple DSL, get submit!/approve!/reject! methods, authorization hooks, query scopes and an immutable PostgreSQL JSONB audit trail - no external services required.
CDC Core provides immutable, Ractor-safe Change Data Capture contracts and domain primitives, including source adapters, change events, processors, routing, ordering policies, and pipelines.
Decodes pgoutput-parser protocol messages into immutable Ruby row-change events.
Defines TG::Geometry with immutable Geom parsing and constructor wrappers, expanded geometry predicates and accessors, Rect helpers, Hex/GeoBIN writers, raw extra_json access, read-only borrowed Line/Ring/Polygon and GeometryCollection child wrappers, value Segment wrappers, Registry reload sugar, optional ActiveRecord source helpers, and an immutable geofencing-oriented Index with owned and borrowed geometry ingestion, flat/rtree strategies, deterministic ordered id results, exact rtree allocation accounting, and native-endian packed point batch queries, explicit local point-to-geometry distance/radius queries, and FeatureSource GeoJSON FeatureCollection extraction/build paths over vendored C sources. Ractor support is not claimed.
Pre-v1 Ledger package for Igniter: immutable facts, histories, receipts, replay, changefeed, compaction, and protocol-facing storage surfaces.
A Ruby gem for parsing skill files that use YAML frontmatter and markdown body content. Provides document splitting, YAML parsing, schema validation, and returns immutable Skill objects. Designed for agent/AI systems where skills are defined as structured markdown documents with metadata.