primitive

package module
v0.5.1 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Apr 18, 2026 License: MIT Imports: 16 Imported by: 0

README

github.com/primitivedotdev/sdks/sdk-go

Official Primitive Go SDK for webhook handling and API access.

This package helps you:

  • verify Primitive webhook signatures
  • parse webhook request bodies
  • validate webhook payloads against the canonical JSON schema
  • work with typed email.received events in Go
  • call the Primitive HTTP API from github.com/primitivedotdev/sdks/sdk-go/api

Requirements

  • Go >=1.25

Installation

go get github.com/primitivedotdev/sdks/sdk-go@latest

In Go code, import the module path and use the package as primitive.

Basic Usage

package main

import (
	"log"

	primitive "github.com/primitivedotdev/sdks/sdk-go"
)

func handle(body []byte, headers map[string]string) {
	event, err := primitive.HandleWebhook(primitive.HandleWebhookOptions{
		Body:    body,
		Headers: headers,
		Secret:  "whsec_...",
	})
	if err != nil {
		log.Printf("invalid webhook: %v", err)
		return
	}

	log.Println("Email from:", event.Email.Headers.From)
	log.Println("Subject:", deref(event.Email.Headers.Subject))
}

func deref(value *string) string {
	if value == nil {
		return ""
	}
	return *value
}

Core API

API package

Use the generated api package for outbound calls to the Primitive HTTP API.

package main

import (
	"context"
	"log"

	primitiveapi "github.com/primitivedotdev/sdks/sdk-go/api"
)

func main() {
	client, err := primitiveapi.NewAPIClient("prim_test")
	if err != nil {
		log.Fatal(err)
	}

	res, err := client.GetAccount(context.Background())
	if err != nil {
		log.Fatal(err)
	}

	log.Printf("account response: %#v", res)
}
Main functions
  • HandleWebhookEvent(options)
    • verifies the webhook signature
    • decodes and parses the request body
    • returns a known webhook event or UnknownEvent
  • HandleWebhook(options)
    • verifies the webhook signature
    • decodes and parses the request body
    • validates an email.received payload
    • returns a typed EmailReceivedEvent
  • ParseWebhookEvent(input)
    • parses a JSON payload into a known webhook event or UnknownEvent
    • validates known event types against the canonical schema
    • returns *WebhookValidationError for malformed known events
  • ValidateEmailReceivedEvent(input)
    • validates an email.received payload and returns the typed event
  • SafeValidateEmailReceivedEvent(input)
    • returns a success flag plus data or error
  • VerifyWebhookSignature(options)
    • verifies Primitive-Signature
  • ValidateEmailAuth(auth)
    • computes a verdict from SPF, DKIM, and DMARC results
Helpful exports
  • WebhookVersion
  • PrimitiveSignatureHeader
  • PrimitiveConfirmedHeader
  • PrimitiveWebhookError
  • WebhookVerificationError
  • WebhookPayloadError
  • WebhookValidationError
  • RawEmailDecodeError
Types

The package exports the main webhook types, including:

  • EmailReceivedEvent
  • WebhookEvent
  • UnknownEvent
  • EmailAuth
  • EmailAnalysis
  • ParsedData
  • RawContent
  • WebhookAttachment

Parsing Events

  • ParseWebhookEvent(input) strictly validates known event types such as email.received
  • malformed known events return *WebhookValidationError
  • unknown future event types are returned as UnknownEvent

JSON Schema

The webhook payload contract is defined by the canonical JSON schema in the repository and is embedded in the Go package as generated source.

The SDK uses that schema to drive:

  • the embedded schema artifact
  • runtime validation
  • shared cross-SDK compatibility checks

Error Handling

All SDK-specific runtime errors include a stable error code.

import (
	"errors"
	"log"

	primitive "github.com/primitivedotdev/sdks/sdk-go"
)

if err != nil {
	var webhookErr *primitive.PrimitiveWebhookError
	if errors.As(err, &webhookErr) {
		log.Println(webhookErr.Code(), webhookErr.Message())
	}
}

Development

From sdks/sdk-go:

make -C .. go-generate
go test ./...
go test -run TestSharedCompatibilityFixtures ./...
gofmt -w .

Or from repo root sdks/:

make go-generate
make go-check

Repository Layout

sdks/
  json-schema/
    email-received-event.schema.json
  sdk-go/
    api/
    webhook.go
    validation.go
    schema.go
    schema_generated.go
    types.go
    scripts/
      generate_api_client.py
      generate_schema_module.py

Documentation

Overview

Package primitive provides webhook verification and validation helpers for Primitive.

The package is centered around HandleWebhookEvent and HandleWebhook, which verify the Primitive-Signature header, decode the raw request body, and parse the JSON payload.

HandleWebhookEvent preserves unknown future event types as UnknownEvent values. HandleWebhook is the email.received-specific convenience wrapper.

Import the module path github.com/primitivedotdev/sdks/sdk-go and use the package name primitive in code.

For lower-level use cases, applications can call VerifyWebhookSignature, ParseWebhookEvent, or ValidateEmailReceivedEvent directly.

Unknown future event types are preserved as UnknownEvent values so consumers can continue receiving webhook traffic before a package update ships.

Index

Constants

View Source
const (
	WebhookVersion                 = "2025-12-14"
	PrimitiveSignatureHeader       = "Primitive-Signature"
	LegacySignatureHeader          = "MyMX-Signature"
	PrimitiveConfirmedHeader       = "X-Primitive-Confirmed"
	LegacyConfirmedHeader          = "X-MyMX-Confirmed"
	StandardWebhookIDHeader        = "webhook-id"
	StandardWebhookTimestampHeader = "webhook-timestamp"
	StandardWebhookSignatureHeader = "webhook-signature"
)

Variables

View Source
var EmailReceivedEventJSONSchema map[string]any
View Source
var PayloadErrors = map[string]ErrorDefinition{
	"PAYLOAD_NULL": {
		Message:    "Webhook payload is null",
		Suggestion: "Ensure you're passing the parsed JSON body, not null. Check your framework's body parsing middleware.",
	},
	"PAYLOAD_UNDEFINED": {
		Message:    "Webhook payload is undefined",
		Suggestion: "The payload was not provided. Make sure you're passing the request body to the handler.",
	},
	"PAYLOAD_WRONG_TYPE": {
		Message:    "Webhook payload must be an object",
		Suggestion: "The payload should be a parsed JSON object. Check that you're not passing a string or other primitive.",
	},
	"PAYLOAD_IS_ARRAY": {
		Message:    "Webhook payload is an array, expected object",
		Suggestion: "Primitive webhooks are single event objects, not arrays. Check the payload structure.",
	},
	"PAYLOAD_MISSING_EVENT": {
		Message:    "Webhook payload missing 'event' field",
		Suggestion: "All webhook payloads must have an 'event' field. This may not be a valid Primitive webhook.",
	},
	"PAYLOAD_UNKNOWN_EVENT": {
		Message:    "Unknown webhook event type",
		Suggestion: "This event type is not recognized. You may need to update your SDK or handle unknown events gracefully.",
	},
	"PAYLOAD_EMPTY_BODY": {
		Message:    "Request body is empty",
		Suggestion: "The request body was empty. Ensure the webhook is sending data and your framework is parsing it correctly.",
	},
	"JSON_PARSE_FAILED": {
		Message:    "Failed to parse JSON body",
		Suggestion: "The request body is not valid JSON. Check the raw body content and Content-Type header.",
	},
	"INVALID_ENCODING": {
		Message:    "Invalid body encoding",
		Suggestion: "The request body encoding is not supported. Primitive webhooks use UTF-8 encoded JSON.",
	},
}
View Source
var RawEmailErrors = map[string]ErrorDefinition{
	"NOT_INCLUDED": {
		Message:    "Raw email content not included inline",
		Suggestion: "Use the download URL at event.email.content.download.url to fetch the raw email.",
	},
	"INVALID_BASE64": {
		Message:    "Raw email content is not valid base64",
		Suggestion: "The raw email data is malformed. Fetch the raw email from the download URL or regenerate the webhook payload.",
	},
	"HASH_MISMATCH": {
		Message:    "SHA-256 hash verification failed",
		Suggestion: "The raw email data may be corrupted. Try downloading from the URL instead.",
	},
}
View Source
var VerificationErrors = map[string]ErrorDefinition{
	"INVALID_SIGNATURE_HEADER": {
		Message:    "Missing or malformed Primitive-Signature header",
		Suggestion: "Check that you're reading the correct header (Primitive-Signature) and it's being passed correctly from your web framework.",
	},
	"TIMESTAMP_OUT_OF_RANGE": {
		Message:    "Timestamp is too old (possible replay attack)",
		Suggestion: "This could indicate a replay attack, network delay, or server clock drift. Check your server's time is synced.",
	},
	"SIGNATURE_MISMATCH": {
		Message:    "Signature doesn't match expected value",
		Suggestion: "Verify the webhook secret matches and you're using the raw request body (not re-serialized JSON).",
	},
	"MISSING_SECRET": {
		Message:    "No webhook secret was provided",
		Suggestion: "Pass your webhook secret from the Primitive dashboard. Check that the environment variable is set.",
	},
}

Functions

func ConfirmedHeaders

func ConfirmedHeaders() map[string]string

func DecodeRawEmail

func DecodeRawEmail(event any, verify ...bool) ([]byte, error)

func GetDownloadTimeRemaining

func GetDownloadTimeRemaining(event any, nowMillis ...int64) (int64, error)

func IsDownloadExpired

func IsDownloadExpired(event any, nowMillis ...int64) (bool, error)

func IsEmailReceivedEvent

func IsEmailReceivedEvent(event any) bool

func IsRawIncluded

func IsRawIncluded(event any) (bool, error)

func ParseJSONBody

func ParseJSONBody(rawBody any) (any, error)

func PrepareStandardWebhooksSecret

func PrepareStandardWebhooksSecret(secret any) ([]byte, error)

PrepareStandardWebhooksSecret strips the "whsec_" prefix if present, then base64-decodes the remainder to produce the raw HMAC key bytes.

func VerifyRawEmailDownload

func VerifyRawEmailDownload(downloaded []byte, event any) ([]byte, error)

func VerifyStandardWebhooksSignature

func VerifyStandardWebhooksSignature(options StandardWebhooksVerifyOptions) (bool, error)

VerifyStandardWebhooksSignature verifies a Standard Webhooks signature.

func VerifyWebhookSignature

func VerifyWebhookSignature(options VerifyOptions) (bool, error)

Types

type AuthConfidence

type AuthConfidence string
const (
	AuthConfidenceHigh   AuthConfidence = "high"
	AuthConfidenceMedium AuthConfidence = "medium"
	AuthConfidenceLow    AuthConfidence = "low"
)

type AuthVerdict

type AuthVerdict string
const (
	AuthVerdictLegit      AuthVerdict = "legit"
	AuthVerdictSuspicious AuthVerdict = "suspicious"
	AuthVerdictUnknown    AuthVerdict = "unknown"
)

type DKIMSignature

type DKIMSignature struct {
	Domain   string     `json:"domain"`
	Selector *string    `json:"selector,omitempty"`
	Result   DkimResult `json:"result"`
	Aligned  bool       `json:"aligned"`
	KeyBits  *int64     `json:"keyBits,omitempty"`
	Algo     *string    `json:"algo,omitempty"`
}

type Delivery

type Delivery struct {
	EndpointID  string `json:"endpoint_id"`
	Attempt     int64  `json:"attempt"`
	AttemptedAt string `json:"attempted_at"`
}

type DkimResult

type DkimResult string
const (
	DkimResultPass      DkimResult = "pass"
	DkimResultFail      DkimResult = "fail"
	DkimResultTemperror DkimResult = "temperror"
	DkimResultPermerror DkimResult = "permerror"
)

type DmarcPolicy

type DmarcPolicy string
const (
	DmarcPolicyReject     DmarcPolicy = "reject"
	DmarcPolicyQuarantine DmarcPolicy = "quarantine"
	DmarcPolicyNone       DmarcPolicy = "none"
)

type DmarcResult

type DmarcResult string
const (
	DmarcResultPass      DmarcResult = "pass"
	DmarcResultFail      DmarcResult = "fail"
	DmarcResultNone      DmarcResult = "none"
	DmarcResultTemperror DmarcResult = "temperror"
	DmarcResultPermerror DmarcResult = "permerror"
)

type DownloadInfo

type DownloadInfo struct {
	URL       string `json:"url"`
	ExpiresAt string `json:"expires_at"`
}

type Email

type Email struct {
	ID         string        `json:"id"`
	ReceivedAt string        `json:"received_at"`
	SMTP       SMTPEnvelope  `json:"smtp"`
	Headers    EmailHeaders  `json:"headers"`
	Content    EmailContent  `json:"content"`
	Parsed     ParsedData    `json:"parsed"`
	Analysis   EmailAnalysis `json:"analysis"`
	Auth       EmailAuth     `json:"auth"`
}

type EmailAddress

type EmailAddress struct {
	Address string  `json:"address"`
	Name    *string `json:"name"`
}

type EmailAnalysis

type EmailAnalysis struct {
	// Spamassassin holds SpamAssassin analysis results.
	// Optional. Present when the email was processed by a SpamAssassin-equipped
	// pipeline (always present in Primitive's managed service).
	Spamassassin *SpamAssassinAnalysis `json:"spamassassin,omitempty"`

	// Forward holds forward detection and analysis results.
	// Optional. Present when the email was processed by a forward-detection
	// pipeline (always present in Primitive's managed service).
	Forward *ForwardAnalysis `json:"forward,omitempty"`
}

EmailAnalysis contains email analysis and classification results.

All fields are optional (pointer types). Which fields are present depends on the analysis pipeline processing the email. Primitive's managed service populates all fields. Self-hosted or third-party deployments may include some, all, or none of these fields depending on their pipeline configuration.

A nil field means that particular analysis was not performed, not that analysis produced no results.

type EmailAuth

type EmailAuth struct {
	SPF              SpfResult       `json:"spf"`
	DMARC            DmarcResult     `json:"dmarc"`
	DMARCPolicy      *DmarcPolicy    `json:"dmarcPolicy"`
	DMARCFromDomain  *string         `json:"dmarcFromDomain"`
	DMARCSpfAligned  *bool           `json:"dmarcSpfAligned,omitempty"`
	DMARCDkimAligned *bool           `json:"dmarcDkimAligned,omitempty"`
	DMARCSpfStrict   *bool           `json:"dmarcSpfStrict"`
	DMARCDkimStrict  *bool           `json:"dmarcDkimStrict"`
	DKIMSignatures   []DKIMSignature `json:"dkimSignatures"`
}

type EmailContent

type EmailContent struct {
	Raw      RawContent   `json:"raw"`
	Download DownloadInfo `json:"download"`
}

type EmailHeaders

type EmailHeaders struct {
	MessageID *string `json:"message_id"`
	Subject   *string `json:"subject"`
	From      string  `json:"from"`
	To        string  `json:"to"`
	Date      *string `json:"date"`
}

type EmailReceivedEvent

type EmailReceivedEvent struct {
	ID       string   `json:"id"`
	Event    string   `json:"event"`
	Version  string   `json:"version"`
	Delivery Delivery `json:"delivery"`
	Email    Email    `json:"email"`
}

func HandleWebhook

func HandleWebhook(options HandleWebhookOptions) (*EmailReceivedEvent, error)

func ValidateEmailReceivedEvent

func ValidateEmailReceivedEvent(input any) (*EmailReceivedEvent, error)

func (EmailReceivedEvent) GetEvent

func (e EmailReceivedEvent) GetEvent() string

type ErrorDefinition

type ErrorDefinition struct {
	Message    string
	Suggestion string
}

type EventType

type EventType string
const EventTypeEmailReceived EventType = "email.received"

type ForwardAnalysis

type ForwardAnalysis struct {
	Detected            bool            `json:"detected"`
	Results             []ForwardResult `json:"results"`
	AttachmentsFound    int64           `json:"attachments_found"`
	AttachmentsAnalyzed int64           `json:"attachments_analyzed"`
	AttachmentsLimit    *int64          `json:"attachments_limit"`
}

type ForwardOriginalSender

type ForwardOriginalSender struct {
	Email  string `json:"email"`
	Domain string `json:"domain"`
}

type ForwardResult

type ForwardResult struct {
	Type               string                 `json:"type"`
	AttachmentTarPath  *string                `json:"attachment_tar_path,omitempty"`
	AttachmentFilename *string                `json:"attachment_filename,omitempty"`
	Analyzed           *bool                  `json:"analyzed,omitempty"`
	OriginalSender     *ForwardOriginalSender `json:"original_sender"`
	Verification       *ForwardVerification   `json:"verification"`
	Summary            string                 `json:"summary"`
}

func (ForwardResult) MarshalJSON

func (r ForwardResult) MarshalJSON() ([]byte, error)

type ForwardVerdict

type ForwardVerdict string
const (
	ForwardVerdictLegit   ForwardVerdict = "legit"
	ForwardVerdictUnknown ForwardVerdict = "unknown"
)

type ForwardVerification

type ForwardVerification struct {
	Verdict      ForwardVerdict `json:"verdict"`
	Confidence   AuthConfidence `json:"confidence"`
	DKIMVerified bool           `json:"dkim_verified"`
	DKIMDomain   *string        `json:"dkim_domain"`
	DMARCPolicy  *DmarcPolicy   `json:"dmarc_policy"`
}

type HandleWebhookOptions

type HandleWebhookOptions struct {
	Body             any
	Headers          any
	Secret           any
	ToleranceSeconds *int64
}

type ParsedData

type ParsedData struct {
	Status                 ParsedStatus        `json:"status"`
	Error                  *ParsedError        `json:"error"`
	BodyText               *string             `json:"body_text"`
	BodyHTML               *string             `json:"body_html"`
	ReplyTo                []EmailAddress      `json:"reply_to"`
	CC                     []EmailAddress      `json:"cc"`
	BCC                    []EmailAddress      `json:"bcc"`
	InReplyTo              []string            `json:"in_reply_to"`
	References             []string            `json:"references"`
	Attachments            []WebhookAttachment `json:"attachments"`
	AttachmentsDownloadURL *string             `json:"attachments_download_url"`
}

type ParsedError

type ParsedError struct {
	Code      string `json:"code"`
	Message   string `json:"message"`
	Retryable bool   `json:"retryable"`
}

type ParsedStatus

type ParsedStatus string
const (
	ParsedStatusComplete ParsedStatus = "complete"
	ParsedStatusFailed   ParsedStatus = "failed"
)

type PrimitiveWebhookError

type PrimitiveWebhookError struct {
	NameValue       string
	CodeValue       string
	MessageValue    string
	SuggestionValue string
	Cause           error
}

func (*PrimitiveWebhookError) As

func (e *PrimitiveWebhookError) As(target any) bool

func (*PrimitiveWebhookError) Code

func (e *PrimitiveWebhookError) Code() string

func (*PrimitiveWebhookError) Error

func (e *PrimitiveWebhookError) Error() string

func (*PrimitiveWebhookError) Message

func (e *PrimitiveWebhookError) Message() string

func (*PrimitiveWebhookError) Name

func (e *PrimitiveWebhookError) Name() string

func (*PrimitiveWebhookError) Suggestion

func (e *PrimitiveWebhookError) Suggestion() string

func (*PrimitiveWebhookError) ToMap

func (e *PrimitiveWebhookError) ToMap() map[string]any

func (*PrimitiveWebhookError) Unwrap

func (e *PrimitiveWebhookError) Unwrap() error

type RawContent

type RawContent struct {
	Included       bool    `json:"included"`
	Encoding       *string `json:"encoding,omitempty"`
	ReasonCode     *string `json:"reason_code,omitempty"`
	MaxInlineBytes int64   `json:"max_inline_bytes"`
	SizeBytes      int64   `json:"size_bytes"`
	SHA256         string  `json:"sha256"`
	Data           *string `json:"data,omitempty"`
}

type RawEmailDecodeError

type RawEmailDecodeError struct{ PrimitiveWebhookError }

func NewRawEmailDecodeError

func NewRawEmailDecodeError(code string, message string) *RawEmailDecodeError

type SMTPEnvelope

type SMTPEnvelope struct {
	Helo     *string  `json:"helo"`
	MailFrom string   `json:"mail_from"`
	RcptTo   []string `json:"rcpt_to"`
}

type SignResult

type SignResult struct {
	Header    string `json:"header"`
	Timestamp int64  `json:"timestamp"`
	V1        string `json:"v1"`
}

func SignWebhookPayload

func SignWebhookPayload(rawBody any, secret any, timestamps ...int64) (SignResult, error)

type SpamAssassinAnalysis

type SpamAssassinAnalysis struct {
	Score float64 `json:"score"`
}

type SpfResult

type SpfResult string
const (
	SpfResultPass      SpfResult = "pass"
	SpfResultFail      SpfResult = "fail"
	SpfResultSoftfail  SpfResult = "softfail"
	SpfResultNeutral   SpfResult = "neutral"
	SpfResultNone      SpfResult = "none"
	SpfResultTemperror SpfResult = "temperror"
	SpfResultPermerror SpfResult = "permerror"
)

type StandardWebhooksSignResult

type StandardWebhooksSignResult struct {
	Signature string `json:"signature"`
	MsgID     string `json:"msg_id"`
	Timestamp int64  `json:"timestamp"`
}

func SignStandardWebhooksPayload

func SignStandardWebhooksPayload(rawBody any, secret any, msgID string, timestamps ...int64) (StandardWebhooksSignResult, error)

SignStandardWebhooksPayload signs a payload using the Standard Webhooks format.

type StandardWebhooksVerifyOptions

type StandardWebhooksVerifyOptions struct {
	RawBody          any
	MsgID            string
	Timestamp        string
	SignatureHeader  string
	Secret           any
	ToleranceSeconds *int64
	NowSeconds       *int64
}

type UnknownEvent

type UnknownEvent struct {
	Event   string         `json:"event"`
	ID      *string        `json:"id,omitempty"`
	Version *string        `json:"version,omitempty"`
	Payload map[string]any `json:"-"`
}

func (UnknownEvent) GetEvent

func (e UnknownEvent) GetEvent() string

func (UnknownEvent) MarshalJSON

func (e UnknownEvent) MarshalJSON() ([]byte, error)

func (*UnknownEvent) UnmarshalJSON

func (e *UnknownEvent) UnmarshalJSON(data []byte) error

type ValidateEmailAuthResult

type ValidateEmailAuthResult struct {
	Verdict    AuthVerdict    `json:"verdict"`
	Confidence AuthConfidence `json:"confidence"`
	Reasons    []string       `json:"reasons"`
}

func ValidateEmailAuth

func ValidateEmailAuth(input any) (ValidateEmailAuthResult, error)

type ValidationIssue

type ValidationIssue struct {
	Path      string `json:"path"`
	Message   string `json:"message"`
	Validator string `json:"validator"`
}

type ValidationResult

type ValidationResult[T any] struct {
	Success bool
	Data    T
	Error   *WebhookValidationError
}

func SafeValidateEmailReceivedEvent

func SafeValidateEmailReceivedEvent(input any) ValidationResult[*EmailReceivedEvent]

type VerifyOptions

type VerifyOptions struct {
	RawBody          any
	SignatureHeader  string
	Secret           any
	ToleranceSeconds *int64
	NowSeconds       *int64
}

type WebhookAttachment

type WebhookAttachment struct {
	Filename    *string `json:"filename"`
	ContentType string  `json:"content_type"`
	SizeBytes   int64   `json:"size_bytes"`
	SHA256      string  `json:"sha256"`
	PartIndex   int64   `json:"part_index"`
	TarPath     string  `json:"tar_path"`
}

type WebhookEvent

type WebhookEvent interface {
	GetEvent() string
}

func HandleWebhookEvent

func HandleWebhookEvent(options HandleWebhookOptions) (WebhookEvent, error)

func ParseWebhookEvent

func ParseWebhookEvent(input any) (WebhookEvent, error)

type WebhookPayloadError

type WebhookPayloadError struct{ PrimitiveWebhookError }

func NewWebhookPayloadError

func NewWebhookPayloadError(code string, message string, suggestion string, cause error) *WebhookPayloadError

type WebhookValidationError

type WebhookValidationError struct {
	PrimitiveWebhookError
	Field                string
	ValidationErrors     []ValidationIssue
	AdditionalErrorCount int
}

func NewWebhookValidationError

func NewWebhookValidationError(field string, message string, suggestion string, validationErrors []ValidationIssue) *WebhookValidationError

func (*WebhookValidationError) ToMap

func (e *WebhookValidationError) ToMap() map[string]any

type WebhookVerificationError

type WebhookVerificationError struct{ PrimitiveWebhookError }

func NewWebhookVerificationError

func NewWebhookVerificationError(code string, message string, suggestion string) *WebhookVerificationError

Directories

Path Synopsis
Package api provides a generated client for the Primitive HTTP API.
Package api provides a generated client for the Primitive HTTP API.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL