Schemi: riferimento API, tipi e campi obbligatori

OpenAPI YAML OpenAPI JSON problemi YAML Panoramica dell’API

Indice schema

AccessLevel — obbligatori: none
leggi (Solo lettura) < proponi < gestisci. Proponi legge, contribuisce (contenuti multimediali, note, commenti, assistenza, feedback, screenshot, bozze di annunci) e trasforma le modifiche a playlist e schermo in revisioni (docs/reviews.md).
AccessLimitedBy — obbligatori: none
Perché effective_access è inferiore all’accesso delle credenziali. project - il progetto richiede revisione per le modifiche dell’agente. person - la persona responsabile dell’agente è un membro che non può approvare revisioni.
AdslotPageWrite — obbligatori: id, type, adslot_id
Slot pubblicitario a pagina intera. Al massimo 16 pagine adslot, e almeno una pagina ordinaria senza visibilità, sono controlli server e non sono espressi qui.
AdvertisingAvailability — obbligatori: estimated_plays, booked_plays, available_plays, screens, observed_from, observed_to, flight_start, flight_end
Una stima: le occorrenze di slot prodotte dagli schermi mirati nella finestra osservata, proiettate sul periodo, meno le riproduzioni di cui hanno ancora bisogno gli altri obiettivi diretti sugli stessi schermi.
AdvertisingAvailabilityQuery — obbligatori: flight_start, flight_end
AdvertisingCampaign — obbligatori: id, revision, name, state, pause_reasons, price_change_pending, daily_cap_mcr, lifetime_cap_mcr, reserved_mcr, spent_mcr, flight_start, flight_end, networks, created_at, updated_at
AdvertisingCampaignDraft — obbligatori: name, daily_cap_mcr, lifetime_cap_mcr, flight_start, flight_end, networks
AdvertisingCampaignList — obbligatori: campaigns
AdvertisingCampaignNetwork — obbligatori: seller_project_id, membership_id, admission_generation, screen_ids, slot_ids, creative_ids, network_cap_mcr, network_reserved_mcr, network_spent_mcr, accepted_pricing_generation, price_change_pending, barrier_generation, enabled
AdvertisingCampaignNetworkDraft — obbligatori: seller_project_id, screen_ids, slot_ids, creative_ids
AdvertisingCategory — obbligatori: none
La categoria dell’inserzionista. Due annunci della stessa categoria non vanno mai in onda nella stessa pausa pubblicitaria su uno schermo; un annuncio senza categoria non viene mai separato.
AdvertisingCreative — obbligatori: id, revision, media_id, media_revision, sha256, kind, content_type, duration_ms, width, height, bytes, state, created_at
AdvertisingCreativeCreate — obbligatori: media_id
AdvertisingCreativeList — obbligatori: creatives
AdvertisingCreativeReview — obbligatori: id, seller_project_id, creative_revision, state, created_at
AdvertisingDaypart — obbligatori: start, end
AdvertisingDeliveryReport — obbligatori: gross_mcr, fee_mcr, net_mcr, completed, interrupted, unbillable, rows, coverage
AdvertisingDeliveryRow — obbligatori: screen_id, slot_id, reservation_id, gross_mcr, fee_mcr, net_mcr, completed_at
AdvertisingDirectCampaign — obbligatori: id, revision, name, advertiser, state, flight_start, flight_end, reserved_plays, delivered_plays, media_ids, image_duration_ms, screen_ids, slot_ids, venue_types, cities, tags, dayparts, overbooked, pace, created_at, updated_at
AdvertisingDirectCampaignDraft — obbligatori: name, advertiser, flight_start, flight_end, media_ids
Una campagna diretta: l’accordo del venditore con un inserzionista esterno sul proprio inventario pubblicitario. Non sposta denaro.
AdvertisingDirectCampaignList — obbligatori: direct_campaigns
AdvertisingDirectPace — obbligatori: status, expected_plays
Consegna rispetto all’obiettivo, che matura in modo uniforme sul periodo.
AdvertisingDirectPrice — obbligatori: model, amount, currency
Il prezzo dell’accordo registrato dal venditore. screenRIG non lo addebita mai; valorizza il report.
AdvertisingDirectReport — obbligatori: campaign_id, name, advertiser, from, to, delivered_plays, reserved_plays, pace, plays, played_ms, not_played, rows
AdvertisingDirectReportRow — obbligatori: day, screen_id, slot_id, media_id, plays, played_ms
AdvertisingDirectValue — obbligatori: model, amount, currency
Il prezzo registrato applicato alle riproduzioni consegnate: per mille riproduzioni per cpm, l’intera tariffa per flat.
AdvertisingFillStats — obbligatori: from, to, occurrences, direct, marketplace, vast, unfilled, fill_rate, unfilled_reasons, days
Offerta di spazi pubblicitari del venditore per tutte le ore UTC che si sovrappongono alla finestra richiesta: occorrenze richieste, riempimenti per origine e occorrenze vuote con il motivo della prima richiesta. La richiesta copre al massimo 35 giorni; i limiti effettivi possono coprire 35 giorni più un’ora.
AdvertisingFillStatsDay — obbligatori: day, occurrences, direct, marketplace, vast, unfilled, fill_rate
AdvertisingInventory — obbligatori: screen_id, revision, ads_enabled, audience_tags, rate_override_mcr_per_15s, rate_revision, created_at, updated_at
AdvertisingInventoryList — obbligatori: inventory
AdvertisingInventoryWrite — obbligatori: ads_enabled
AdvertisingJoinedInventory — obbligatori: inventory, slots
AdvertisingJoinedNetwork — obbligatori: seller_project_id, membership_id, policy, admission_generation, scope, price_change_pending, default_rate_mcr_per_15s
AdvertisingJoinedNetworkList — obbligatori: networks
AdvertisingMembership — obbligatori: id, seller_project_id, admission_generation, policy_revision, policy, scope, state, revision, created_at, updated_at
AdvertisingMembershipList — obbligatori: memberships
AdvertisingMembershipScope — obbligatori: policy, screen_ids, slot_ids
AdvertisingNetwork — obbligatori: id, revision, enabled, rate_revision, pricing_generation, seller_fee_bps, seller_fee_revision, created_at, updated_at
AdvertisingNetworkCreate — obbligatori: name
AdvertisingQuote — obbligatori: id, campaign_id, campaign_revision, revision, state, expires_at, items, pricing_generations, created_at
AdvertisingQuoteAccept — obbligatori: quote_id
AdvertisingQuoteItem — obbligatori: seller_project_id, screen_id, slot_id, creative_id, duration_ms, rate_mcr_per_15s, play_price_mcr, pricing_generation, fee_bps, fee_revision
AdvertisingRate — obbligatori: rate_mcr_per_15s
AdvertisingReportCoverage — obbligatori: mode, outcomes_complete
Copertura dei conteggi degli esiti di riproduzione. I totali monetari provengono sempre da saldi immutabili. Quando outcomes_complete è falso, i conteggi sono limiti inferiori osservati e la storia mancante non è disponibile, non zero.
AdvertisingReview — obbligatori: id, creative_id, creative_revision, state, created_at
AdvertisingReviewDetail — obbligatori: review, creative
AdvertisingReviewList — obbligatori: reviews
AdvertisingReviewRejection — obbligatori: reason
AdvertisingScope — obbligatori: screen_ids, slot_ids
AdvertisingSellerCampaign — obbligatori: id, buyer_project_id, name, state, flight_start, flight_end, screen_ids, slot_ids, creative_ids, review_state, enabled, price_change_pending, updated_at
Una campagna inviata da un acquirente, proiettata solo sulla rete del venditore chiamante.
AdvertisingSellerCampaignDelivery — obbligatori: completed, reserved_mcr, gross_mcr, fee_mcr, net_mcr
Riproduzioni e importi consolidati complessivi sulla rete del venditore chiamante, più il suo importo attualmente trattenuto.
AdvertisingSellerCampaignDetail — obbligatori: campaign, delivery
AdvertisingSellerCampaignList — obbligatori: campaigns
AdvertisingSlot — obbligatori: id, revision, name, enabled, accepted_media, max_image_duration_ms, max_video_duration_ms, muted, rate_override_mcr_per_15s, rate_revision, created_at, updated_at
AdvertisingSlotList — obbligatori: slots
AdvertisingSlotWrite — obbligatori: name, accepted_media, max_image_duration_ms, max_video_duration_ms
AdvertisingSpendReport — obbligatori: campaign_id, spent_mcr, reserved_mcr, completed, unbillable, pending, coverage
Agent — obbligatori: id, name, agent_type, capabilities, state, authenticated_requests, metered_credits, created_at
AgentCapability — obbligatori: none
Una capacità di credenziale agente. Le capacità sono fissate quando la credenziale è emessa; per cambiarle, collega un nuovo agente e scollega il vecchio. L’ordine canonico è quello di questo enum; le liste di capacità non contengono mai duplicati.
AgentConnection — obbligatori: connection_id, name, agent_type, status, capabilities, expires_at, created_at
AgentDisconnectRequest — obbligatori: none
AgentInput — obbligatori: none
AgentList — obbligatori: items
AgentScreenScopeUpdate — obbligatori: screen_scope
AgentSelfStatus — obbligatori: agent, connection_ready
Alert — obbligatori: id, screen_id, condition, state, since, muted, attention
Una condizione di uno schermo finché dura. Chi legge tratta una condizione sconosciuta come una condizione che non sa nominare.
AlertAcknowledge — obbligatori: none
AlertActor — obbligatori: kind, id
AlertList — obbligatori: items, next_cursor, counts
AlertMute — obbligatori: id, screen_ids, tags, until, created_at
AlertMuteList — obbligatori: items
AlertMuteWrite — obbligatorio: until
Almeno un ID schermo o un tag.
AppStoreNotificationAcknowledgement — obbligatori: acknowledged
AppStoreNotificationRequest — obbligatori: signedPayload
AppStoreOffer — obbligatori: account_token, products, education_eligible, education_eligibility_source, can_purchase, current_plan_id, subscription
AppStoreProduct — obbligatori: product_id, plan_id
AppStoreSubscription — obbligatori: organization_id, plan_id, product_id, original_transaction_id, environment, expires_at, auto_renews, status
L’abbonamento App Store di un’organizzazione.
AppStoreTransactionRequest — obbligatori: signed_transaction
Application — obbligatori: id, name, revision, created_at, updated_at
ApplicationEventContext — obbligatori: primitive_id, code
ApplicationEventReport — obbligatori: severity, code, context
ApplicationList — obbligatori: items
ApplicationPlacement — obbligatori: playlist_id, playlist_name, page_id, primitive_id, release_id, release, controller, rect, canvas, screen_count
Una primitiva applicazione in una pagina di una playlist.
ApplicationRename — obbligatori: name
ApplicationUploadCommit — obbligatori: sha256, compressed_bytes
Nomina di nuovo l’archivio dichiarato; un commit che nomina altri byte viene rifiutato con invalid_request.
ApplicationUploadDeclaration — obbligatori: sha256, compressed_bytes, expanded_bytes, file_count
Dichiara un tar.gz prodotto dalla CLI, con i metadati che un caricamento in streaming invia come intestazioni.
ApplicationUploadSession — obbligatori: id, application_id, release_id, operation, upload_url, method, headers, expires_at
ApplicationUsage — obbligatori: placements, screens
ArchivedProjectDevice — obbligatori: screen_id, label, host
AuditActor — obbligatori: kind
AuditActorKind — obbligatori: none
AuditClient — obbligatori: kind
AuditEntry — obbligatori: id, scope, at, actor, source, action, resource, changes
AuditFieldChange — obbligatori: path, before, after
AuditHead — obbligatori: scope, seq, hash, floor_seq, floor_hash, unsealed, format
AuditList — obbligatori: items, next_cursor
AuditProblem — obbligatori: seq, code, detail
AuditResource — obbligatori: type
AuditRevision — obbligatori: type
AuditSource — obbligatori: none
La superficie da cui è arrivata una modifica: una sessione della dashboard, l’API HTTP, la CLI screenrig, una chiamata a uno strumento MCP, un membro dello staff con permesso di scrittura, una chiamata firmata di un dispositivo, un webhook in ingresso o il server stesso (un worker che applica una modifica approvata).
AuditVerifyResult — obbligatori: ok, scope, checked, head, problems
AutoTopUpDisabledSettings — obbligatori: enabled
La disattivazione conserva gli importi salvati e la spesa mensile. I campi importo facoltativi vengono ignorati, comprese le bozze non completate.
AutoTopUpEnabledSettings — obbligatori: enabled, threshold_cents, amount_cents, monthly_limit_cents
AutoTopUpSettings — obbligatori: none
AutoTopUpView — obbligatori: enabled, threshold_cents, amount_cents, monthly_limit_cents, paused, this_month_cents
BIBrowse — obbligatori: items, next_cursor
Grafana: dashboards (uid, title, folder, tags), or with dashboard set that dashboard's panels (id, title, type) and the dashboard itself. Power BI: workspaces (id, name), or with workspace set that workspace's reports (id, name, embed_url) and the workspace itself. Tableau: views (path as Workbook/View, name).
BICheck — obbligatori: name, ok
BIConnection — obbligatori: id, project_id, kind, name, config, embed_origin, secret, last_test, revision, created_at, updated_at
L’accesso di un progetto a un sistema BI. Ogni connessione appartiene a un solo progetto.
BIConnectionConfig — obbligatori: none
BIConnectionList — obbligatori: items, next_cursor
BIConnectionPatch — obbligatori: none
BIConnectionWrite — obbligatori: name, kind, config
BISecret — obbligatori: set, hint
Come appare un segreto memorizzato. Il segreto in sé non viene mai restituito.
BITarget — obbligatori: none
Cosa mostra una vista. Grafana con una connessione: dashboard_uid (e facoltativamente un pannello). Power BI con una connessione: workspace_id e report_id, con pages o rotate_all_pages. Tableau con una connessione: view (Workbook/View), con rotate_sheets. Web con una connessione: url. Senza una connessione: solo public_url (e rotate_sheets per Tableau).
BITestReport — obbligatori: at, ok, checks
BIView — obbligatori: id, project_id, kind, name, target, refresh_s, rotate_s, fit, revision, status, embed_url, created_at, updated_at
BIViewError — obbligatori: at, code, detail
BIViewList — obbligatori: items, next_cursor
BIViewPatch — obbligatori: none
BIViewStatus — obbligatori: last_ok_at, last_error
Com’è andata l’ultima volta la vista sullo schermo. Cambia solo quando cambia l’esito.
BIViewTest — obbligatori: at, ok, checks
BIViewWrite — obbligatori: name
Imposta connection_id con esattamente uno tra url e target (per Tableau, url può accompagnare un target che contiene solo rotate_sheets; una vista web accetta url e nessun target), oppure kind (grafana, powerbi o tableau) con il solo target.public_url.
BIWebCookie — obbligatori: name, value, domain
Un cookie di un set di cookie esportato da un browser connesso.
BIWebSession — obbligatori: state, cookies, cookies_updated_at, last_login_at, login_failures, retry_at
I cookie e l’accesso di una connessione web. state: idle (ancora niente; la prima acquisizione effettua l’accesso), active, login_needed (la pagina ha mostrato la sua pagina di accesso; la prossima acquisizione effettua l’accesso), paused (un accesso non è riuscito; il prossimo attende fino a retry_at), stopped (cinque accessi rifiutati di fila; cambia le credenziali) oppure expired (una connessione solo con cookie i cui cookie hanno smesso di funzionare; dalle un nuovo set).
BIWebStep — obbligatori: action
Un passaggio di un accesso con script. goto: url (https, pubblico). fill: selector e value. click e wait_for: selector. press: value, un nome di tasto come Enter o Tab, e facoltativamente selector per dare prima il focus. wait_ms: ms.
Un valore può contenere {{username}}, {{password}} e {{otp}}, che il renderer compila dall’accesso; non inserire alcuna password né codice in un valore, solo il segnaposto.
BillingBalance — obbligatori: wallet_revision, remaining_mcr, reserved_mcr, available_mcr, sources, withdrawal
BillingPayer — obbligatori: kind, id
BillingPaymentMethod — obbligatori: brand, last4, exp_month, exp_year
BillingPayoutStatus — obbligatori: rails_available, unavailable_reason
BillingPlanSubscription — obbligatori: subscription_id, plan, status, entitlement, cancel_at_period_end
BillingPortalSession — obbligatori: url
BillingSourceBucket — obbligatori: remaining_mcr, reserved_mcr
BillingSources — obbligatori: nonredeemable, purchased, ad_earned
BillingStatement — obbligatori: entries, next_cursor
BillingStatementEntry — obbligatori: sequence, journal_id, kind, amount_mcr, amount_credits, amount_usd, occurred_at
BillingUsageAllowance — obbligatorio: storage_bytes, api_events, storage_mcr_per_gb_month
Ciò che un pagante riceve gratuitamente, come stringhe decimali canoniche. La larghezza di banda non viene mai addebitata, quindi non ha una quota.
BillingUsageAmounts — obbligatorio: bandwidth_bytes, storage_mcr, api_events
BillingWithdrawal — obbligatori: eligible_earned_mcr, amount_usd_cents, threshold_exclusive_usd_cents, allowed, blockers, rails_available
BrowserLinkClaim — obbligatori: session_id, status, screen
BrowserLinkClaimRequest — obbligatori: code
BrowserLinkClaimScreen — obbligatori: id, public_id, state, public_url
BrowserLinkEvent — obbligatori: session_id, status, event_id, expires_at
BrowserLinkSession — obbligatori: session_id, code, display_code, status, expires_at
BrowserLinkStatus — obbligatori: session_id, code, display_code, status, continuation_path, expires_at
BrowserProvisioningCompletion — obbligatori: screen, public_url
BrowserProvisioningExchange — obbligatori: provisioning_token, exchange_id
CLIEnrollment — obbligatori: project, agent, connection_ready, token, issuance_id, issuance_expires_at, invitation
CLIEnrollmentOAuth — obbligatori: project, agent, connection_ready, issuance_id, issuance_expires_at, invitation, access_token, token_type, expires_in, refresh_token, refresh_expires_at, scope
Iscrizione nel formato credenziali oauth. Il grant dell’iscrizione (client screenrig-cli, Manage sul nuovo progetto con tutte le capacità, accesso identità Manage) ha emesso la sua prima coppia di token; un retry esatto prima di issuance_expires_at restituisce la stessa coppia, retry successivi restituiscono credential_issuance_expired.
CLIEnrollmentRequest — obbligatori: client_id
Campaign — obbligatori: id, name, playlist_id, audience, priority, paused, reserved, revision, created_at, updated_at
Una campagna di contenuto: ogni schermo in audience mostra playlist_id finché from, until e windows valgono nel fuso orario dello schermo. Se from, until e windows sono assenti, vale sempre.
CampaignAudience — obbligatori: none
Quali schermi una campagna prende di mira: esattamente uno tra all (ogni regola corrisponde), any (almeno una corrisponde), tag (lo schermo ha il tag), screen_id (quello schermo) o folder (gli schermi in quella cartella schermi e in ogni cartella al suo interno, GET /api/screen-folders; la cartella deve esistere).
Le regole si annidano al massimo su 3 livelli e un’audience ha al massimo 500 regole. {"all": []} è ogni schermo del progetto; altrove all e any elencano almeno una regola.
CampaignList — obbligatori: items
CampaignPatch — obbligatori: none
CampaignPreviewRequest — obbligatori: body
CampaignPromote — obbligatori: revision
CampaignReach — obbligatori: published, current, at, empty_groups
Quanti schermi attivi corrispondono al pubblico; uno schermo in associazione non viene contato.
Conta le corrispondenze del pubblico, non dove la campagna viene riprodotta: uno schermo attivo senza una playlist predefinita corrisponde e non riproduce nulla. published è il conteggio al momento dell'ultima pubblicazione della campagna (creata, o aggiornata con un pubblico, playlist_id o paused diversi); current è il conteggio più recente.
Una modifica ai tag, alla cartella o allo stato di uno schermo attivo, o lo spostamento di una cartella, ricalcola le campagne il cui pubblico nomina ciò che è cambiato circa 15 secondi dopo la fine delle modifiche e aggiunge campaign.reach_changed (published, previous, current; republished true da una pubblicazione) e, per ogni tag o cartella del pubblico che inizia o smette di corrispondere a schermi, campaign.group_changed (kind, value, matched); una pubblicazione che toglie dal pubblico un tag o una cartella vuoti aggiunge campaign.group_changed con removed true e matched 0.
Assente su una campagna non pubblicata né ricalcolata da quando è stata introdotta la copertura.
CampaignRevision — obbligatori: revision, created_at, change, current, campaign
Una revisione memorizzata di una campagna: la campagna com’era dopo una scrittura. change dice che cosa l’ha prodotta: created, edited (un aggiornamento o un’importazione di programmazione), restored o promoted (una copia di una revisione precedente, indicata da restored_from), oppure baseline (la revisione che la campagna aveva quando è iniziata la sua cronologia, prima di qualsiasi scrittura registrata).
Un valore che questo lettore non conosce viene letto come edited.
CampaignRevisionList — obbligatori: items
CampaignScreens — obbligatori: campaign_id, counts, items
CampaignStatus — obbligatori: campaign_id, screen_id, status
Lo stato di una campagna su uno schermo.
Su uno schermo il cui Player risolve e riceve il proprio stack (schedule.stack), una campagna valida in base all’orario occupa la posizione assegnata dallo stack: una campagna a fascia o principale viene riprodotta nella sua regione e un blocco display sui suoi display; una campagna assente dallo stack è pending o blocked (playlist_unavailable). playing: lo schermo la mostra. pending: dovrebbe essere mostrata e il cambio avviene entro un minuto. waiting: attualmente fuori da from, until o windows (next_start indica l’inizio se avviene entro otto giorni). ended: until è passato. outranked: è in vigore, ma prevale un takeover dello schermo (reason takeover) o un’altra campagna (reason campaign, by). conditional: è valida in base all’orario e viene riprodotta finché è soddisfatta anche la condizione osservata solo dal Player (reason interaction: qualcuno sta usando lo schermo; data: la sua condizione sui dati). paused. blocked: non può essere mostrata qui (reason no_default_playlist, no_timezone o playlist_unavailable: la playlist manca, non è approvata o non è adatta allo schermo; region_not_laid_out: non è disposta su alcun display di questo schermo (la sua fascia non entra in nessun display di destinazione oppure il blocco display non indica alcuna uscita dello schermo) ed è esclusa dal suo stack; oppure stack_only: il Player dello schermo non risolve il proprio stack e solo un Player che lo fa rispetta una regione, un blocco display, un’interazione o una condizione sui dati). not_in_audience.
CampaignWrite — obbligatori: name, playlist_id, audience
CanvasBackground — obbligatori: none
Solido canonico maiuscolo #RRGGBBAA, o un gradiente lineare dall’alto al basso.
CanvasColor — obbligatori: none
sRGB RRGGBBAA maiuscolo canonico.
CapPull — obbligatori: none
Fonti CAP lette dalla piattaforma per il trigger, con dove sono gli schermi target e quali alert contano: i parametri di un posizionamento scheda cap-alert (docs/feeds.md "CAP alerts"). Ogni URL sorgente è recuperato una volta al minuto per ogni trigger e posizionamento che lo nomina.
Senza fonti, si leggono i feed pubblici della piattaforma che coprono la posizione (NWS, Canada NAAD e MeteoAlarm per una posizione con codici area). L’allerta corrispondente più grave prende il controllo degli schermi target esattamente come farebbe un messaggio push; quando le fonti non ne mostrano (una cancellazione o una scadenza), un allerta pull termina.
Una sorgente obsoleta o guasta non termina mai un avviso. location è obbligatorio a meno che non siano fornite sorgenti.
Capabilities — obbligatori: api_version, protocol_version, application_compressed_bytes, application_expanded_bytes, application_package_bytes, application_file_count, application_file_bytes, application_path_depth, application_path_bytes, media_image_bytes, media_audio_bytes, media_video_bytes, playlist_max_pages, playlist_max_items_per_page, playlist_max_media_per_selector, transition_max_duration_ms, screens_per_project, project_content_bytes, founding_period_ends_at, features
CardCatalogue — obbligatori: cards
CardCreate — obbligatori: type, params
CardDataEntry — obbligatori: key, document, bytes, sha256, revision, created_at, updated_at
CardDataList — obbligatori: items, next_cursor
CardDataSummary — obbligatori: key, bytes, sha256, revision, created_at, updated_at
CardDataWrite — obbligatori: document
CardDetails — obbligatori: id, major, version, params_schema, data_schema, feed, tier, layouts, example
CardFile — obbligatori: src, sha256
CardInstance — obbligatori: id, project_id, type, major, params, created_at, updated_at, revision
CardKVWebhook — obbligatori: id, card_id, description, mapping, enabled, signing, url, created_at, updated_at
Un webhook in ingresso che scrive il documento dati di una scheda.
CardKVWebhookCreate — obbligatori: none
CardKVWebhookList — obbligatori: items
CardKVWebhookRotate — obbligatori: none
CardKVWebhookUpdate — obbligatori: none
CardKVWebhookWithSecrets — obbligatori: none
CardKVWebhookWriteResult — obbligatori: status
CardRequirements — obbligatori: cardml, features
CardSummary — obbligatori: id, title, short, category, tags, tier, layouts, majors
Comments — obbligatori: comments
CommentsWrite — obbligatori: comments
Connection — obbligatori: id, project_id, provider, mode, name, status, last_error, config, secret, last_test, revision, created_at, updated_at
L’accesso riutilizzabile di un progetto a Microsoft o a Google. Le origini, le connessioni Power BI e gli account di sincronizzazione dei media SharePoint ne indicano una in config.connection_id invece di portare credenziali proprie.
ConnectionCheck — obbligatori: name, ok, detail
ConnectionConfig — obbligatori: none
Ciò che una connessione indica oltre al suo segreto; sono presenti solo i membri che il suo provider e la sua modalità usano. Un segreto, una chiave o un token di aggiornamento non è mai qui.
ConnectionConfigWrite — obbligatori: none
Microsoft, modalità own_app: entrambi i membri. Non accettato per una connessione Google né per la modalità screenrig_app.
ConnectionConsent — obbligatori: none
Una connessione restituita con il suo link di consenso monouso, che porta solo una scrittura che ne crea uno: la creazione di una connessione in modalità screenrig_app e POST /api/connections/{id}/connect. La persona che dà il consenso apre consent_url prima di consent_expires_at. È il link di un solo consenso: invialo solo a quella persona. Una lettura della connessione non lo porta mai.
ConnectionError — obbligatori: code, message, at
Perché una connessione non funziona. Il messaggio è una frase fissa più, per Microsoft, il codice AADSTS; non ripete mai un testo inviato da un chiamante.
ConnectionList — obbligatori: items, next_cursor
ConnectionPatch — obbligatori: none
ConnectionSecret — obbligatori: set, hint
Come una risposta mostra il segreto, la chiave o il token di aggiornamento di una connessione. Il valore non viene mai restituito.
ConnectionTest — obbligatori: at, ok, checks
ConnectionWrite — obbligatori: provider, mode, name
CreatedProject — obbligatori: project, organization
CreditPurchase — obbligatori: id, status, amount_cents, credits, credited
DashboardAgentAction — obbligatori: project_id
DashboardApplicationPreviewLaunch — obbligatori: release_id, launch_url, expires_at
DashboardApplicationSummary — obbligatori: count
DashboardBalance — obbligatori: credit_remaining, credit_included, credit_reset
DashboardBoot — obbligatori: none
Una richiesta per la shell del dashboard. Ogni membro è il corpo con cui la rotta indicata risponde per questa stessa sessione, ed è assente quando quella rotta non risponderebbe 2xx per essa. advertising_network è null quando il progetto non ha una rete.
DashboardDisplayName — obbligatori: none
Nome visualizzabile stampabile e rifilato, massimo 80 byte UTF-8. Rifiuta controlli, testo simile a URL, @, www., :// e dati di accesso. Mai autorizzazione.
DashboardEmail — obbligatori: email, email_verified, email_revision
La vista email dell’utente corrente. L’indirizzo verificato resta valido mentre un cambiamento è in sospeso, e il candidato in sospeso è visibile solo al suo proprietario.
DashboardEmailVerificationAccepted — obbligatori: status
DashboardHealthSummary — obbligatori: display_disconnected, hot, crashing, stale
Schermi attivi con report di salute, conteggiati per condizione; uno schermo può contare in più condizioni. display_disconnected, hot e crashing contano solo schermi online con report recente (non obsoleto); stale conta schermi online con report più vecchio di 35 minuti e nessun altro.
DashboardMe — obbligatori: user_id, display_name, email, password, passkeys, created_at
DashboardMediaSummary — obbligatori: count, bytes
Contatori dei media pronti per il progetto della sessione. bytes conta solo i byte dei media memorizzati; non è il totale used_bytes del progetto, che comprende anche gli alberi delle release e le voci chiave/valore. image_bytes, video_bytes e audio_bytes ripartiscono bytes per primitiva e sommano sempre a bytes finché image, video e audio sono le sole primitive; se mai venisse memorizzata un’altra primitiva, la somma dei tre è inferiore a bytes.
DashboardMember — obbligatori: user_id, display_name, joined_at, passkeys, password, owner, external
DashboardMemberList — obbligatori: items, viewer_user_id, viewer_is_owner
DashboardPasskey — obbligatori: id, name, credential_id, provider, created_at, last_used_at
DashboardPasskeyAssertion — obbligatori: ceremony_id, request_options
DashboardPasskeyAssertionComplete — obbligatori: ceremony_id, credential
DashboardPasskeyComplete — obbligatori: ceremony_id, credential
DashboardPasskeyList — obbligatori: rp_id, user_handle, items
DashboardPasskeyPatch — obbligatori: name
DashboardPasskeyProof — obbligatori: type, ceremony_id, credential
DashboardPasskeyRegistration — obbligatori: ceremony_id, creation_options
DashboardPasswordLogin — obbligatori: email, password
DashboardPasswordProof — obbligatori: type, password
DashboardPasswordSet — obbligatori: password, proof
DashboardPendingEmail — obbligatori: email, expires_at
DashboardProject — obbligatori: status, created_at, email, screen_count, screen_limit, used_bytes, reserved_bytes, content_limit_bytes, event_retention_days, name
Stato, indirizzo di contatto, limiti applicati, utilizzo, conservazione e stato pubblico del credito totale per un progetto. L’identificatore interno del piano rimane non pubblicato.
DashboardProjectList — obbligatori: items
DashboardProjectListItem — obbligatori: id, name, last_used_at
DashboardProjectReference — obbligatori: id, name
DashboardProjectSwitch — obbligatori: project_id
DashboardProof — obbligatori: none
DashboardProofRequest — obbligatori: proof
DashboardReauthentication — obbligatori: ceremony_id, options
DashboardReauthenticationRequest — obbligatori: kind
DashboardSSOProof — obbligatori: type
Prova tramite un single sign-on recente. È valida se la sessione corrente ha effettuato l’accesso tramite il provider di identità dell’organizzazione al massimo 10 minuti fa, e non comporta alcuna cerimonia né alcun segreto. In caso contrario la rotta risponde reauthentication_required e la persona accede di nuovo tramite il proprio provider (POST /api/session/sso-starts, intent reauth).
DashboardScreenSummary — obbligatori: total, online, pairing_pending, active, archived
Contatori schermo per il progetto della sessione. total è pairing_pending più active ed esclude gli archiviati, corrispondendo a project screen_count. online deriva dagli stream di eventi runtime live paired esattamente come Screen.online; non è un booleano memorizzato né un heartbeat del player.
DashboardSession — obbligatori: user_id, display_name, email, project, auth_method, authenticated_at, expires_at, dev_auth, staff, shadow, passkey_enrollment_required, email_verification_required
Sessione persona. Gli identificatori sono descrittivi; il cookie di sessione stabilisce l’autorità. Una persona senza progetti ha project: null.
DashboardSessionOrganization — obbligatori: id, name, managed
L’organizzazione di appartenenza della persona.
DashboardSessionSSO — obbligatori: organization_id, provider_name, linked
Il contesto single sign-on della persona. Presente ogni volta che l’indirizzo verificato della persona appartiene a un dominio la cui organizzazione ha una connessione con un provider di identità; linked è false finché la persona non accede tramite essa o non la collega. Una sessione SSO dura 24 ore dall’accesso e non viene prolungata dall’uso.
DashboardStaffWriteMode — obbligatori: request_id, project_id, expires_at
DashboardSummary — obbligatori: screens, media, applications
DeletedProject — obbligatori: id, screens, paired_screens_active, paired_screens_archived, paired_screens_completed_pending, agents, media, applications, playlists, memberships
DemoRequestInput — obbligatori: email, country, screen_range, organization, budget, timezone, source, flow_id
DemoResult — obbligatori: route, booking, review_requested, video_url, email, country, timezone, flow_id, source
DemoSlots — obbligatori: slots, timezone
DemoSource — obbligatori: none
DeviceSessionRequest — obbligatori: none
Mint browser associato a cookie. Il corpo è opzionale. Membri sconosciuti sono ignorati (docs/player-compatibility.md §1.1).
DisplayWindow — obbligatori: days
DocsPage — obbligatori: url, title, markdown, truncated, sections, corpus_commit
DocsSearchResponse — obbligatori: results, corpus_commit
DocsSearchResult — obbligatori: url, title, section, snippet, score
EducationEligibilitySource — obbligatori: none
Chi ha deciso education_eligible. staff è una decisione dello staff, in un senso o nell’altro, ed è definitiva. school_email è la decisione automatica basata sull’indirizzo email K-12 verificato di un amministratore (un dominio scolastico come k12.ca.us o sch.uk; mai un dominio educativo generico come .edu o .ac.uk). La stringa vuota significa che nessuno ha deciso.
EmailVerifyRequest — obbligatori: token
EmailVerifyResult — obbligatori: purpose, status
EmptyPaymentRequest — obbligatori: none
EnrollmentInvitation — obbligatori: id, status, expires_at
Event — obbligatori: cursor, type, severity, message, at
EventActor — obbligatori: user_id, display_name
Utente della dashboard che ha causato questa mutazione. Facoltativo e assente in ogni evento prodotto da un agente, CLI, lettore o worker, quindi il campo distingue una mutazione della dashboard piuttosto che etichettare tutto il traffico. È solo attribuzione descrittiva e mai autorizzazione. display_name è il nome scelto dall’utente alla registrazione e non è verificato.
EventAgent — obbligatori: agent_id, name, agent_type
Attribuzione sicura del principale agente presente solo quando l’evento è stato causato direttamente da un agente autenticato. Non è mai autorizzazione.
EventCommand — obbligatori: name, method
La richiesta agente che ha causato questo evento. Facoltativa e assente in ogni evento prodotto da un utente dashboard, un player o un worker. È solo un’attribuzione descrittiva e mai un’autorizzazione. Ogni campo è scritto dal server dalla route corrispondente o dal registro problemi.
Un oggetto comando non può contenere un vettore di argomenti, un corpo di richiesta, un’intestazione o qualsiasi testo scelto dal chiamante, e non esiste appositamente un campo per questo. name e method appaiono in ogni evento che una richiesta agente ha impegnato.
I campi risultato appaiono SOLO su un evento agent.command, che è il record per una richiesta che non ha impegnato eventi di dominio: un evento di dominio impegnato è la prova che la richiesta è riuscita.
EventList — obbligatori: items, next_cursor
FeedDocument — obbligatori: schema, fetchedAt, attribution
FeedPending — obbligatori: key, state, retry_after_seconds
FeedbackContext — obbligatori: none
Busta diagnostica chiusa. Ogni membro è uno scalare opzionale vincolato, l’annidamento è strutturalmente impossibile, e un membro sconosciuto è rifiutato con invalid_request. La forma esiste affinché un client non possa persistere valori argomento, credenziali o dati ambiente liberi attraverso di essa.
FeedbackList — obbligatori: items
FeedbackReplyWrite — obbligatori: text
FeedbackResponse — obbligatori: id, text, status, created_at
Una risposta immutabile di staff o agente. Un autore assente identifica una risposta dello staff. Testo semplice (scappalo per ogni contesto di visualizzazione); testo a forma di credenziale è sostituito con [redacted] prima di essere memorizzato.
FeedbackStatus — obbligatori: none
Dove si trova lo stato di una segnalazione. waiting_on_user chiede informazioni all’agente che ha inviato; una risposta dell’agente la riapre o chiude. Una segnalazione “pianificata” mantiene il suo stato.
FeedbackSubmission — obbligatori: id, kind, title, body, created_at
Una submission a livello di progetto. I suoi campi propri (id, kind, title, body, context, created_at) non cambiano mai dopo la scrittura. status è aperto finché lo staff risponde e poi è lo stato della risposta più recente; le risposte agente riaprono i report in attesa di input o chiusi, mentre un report "planned" mantiene il suo stato.
Le risposte sono repliche di staff e agenti, le più vecchie per prime e al massimo 20, mai modificate o rimosse. Ogni replica aggiunge anche un evento feedback.responded allo stream eventi del progetto (resource.id è l’id della submission; i dettagli contengono response_id, status, fixed_in e author per le repliche agent, mai il testo).
L’ID invio non è mai un’autorizzazione: lo legge solo il progetto proprietario.
FeedbackWrite — obbligatori: title, body
FleetLink — obbligatori: id, label, enabled, tags, screens_created, revision, created_at, updated_at
Un URL Player che trasforma ogni dispositivo che lo apre nel proprio schermo in questo progetto.
FleetLinkList — obbligatori: items
FleetLinkPatch — obbligatori: none
FleetLinkWrite — obbligatori: label
GroupBinding — obbligatori: binding_id, group_id, group_name, role, created_at
GroupBindingCreate — obbligatori: group_id, role
GroupBindingGroup — obbligatori: id, display_name, member_count
GroupBindingList — obbligatori: bindings, groups
HLSStreamSource — obbligatori: protocol, url
HealthResponse — obbligatori: status
HealthTrend — obbligatori: items, next_cursor
HealthTrendHour — obbligatori: hour, screens_reporting, hot, display_disconnected, crashing
HostContext — obbligatori: platform
La shell e l’hardware su cui gira un lettore, come riportato dal lettore. Un HINT che nomina un dispositivo; mai una credenziale, mai un’autorizzazione. Solo la chiave Ed25519 autorizza.
Archiviato per schermo, sostituito da ogni sessione mint che ne contiene uno, eliminato con lo schermo, mai scritto nei log operativi, mai riprodotto in risposte a problemi e mai restituito a progetti diversi dal proprietario. Sola lettura nell’API progetto; ScreenPatch non può scriverlo.
HostDevice — obbligatori: none
Identificatori hardware opzionali. duid e serial sono gli unici due consultati dall’hint di recupero; una lettura fallita sul player omette il campo.
IceServer — obbligatori: urls
Un RTCIceServer. Gli URL della porta 53 vengono rimossi perché i browser li bloccano e nulla viene inviato in modo incrementale.
IdentityProvider — obbligatori: connection_id, kind, preset, name, jit, service_provider, ready_to_require, policy, revision, created_at, updated_at
La connessione single sign-on dell’organizzazione. Non contiene alcun segreto.
IdentityProviderCertificate — obbligatori: sha256, subject, not_after
IdentityProviderOIDC — obbligatori: issuer, client_id, client_secret_set, scopes
IdentityProviderOIDCWrite — obbligatori: client_id
IdentityProviderSAML — obbligatori: idp_entity_id, idp_sso_url, certificates
IdentityProviderSAMLWrite — obbligatori: none
IdentityProviderServiceProvider — obbligatori: oidc_redirect_uri, saml_entity_id, saml_acs_url, saml_metadata_url
I valori da inserire nel provider di identità, derivati dall’origine del dashboard e dall’id della connessione.
IdentityProviderTest — obbligatori: at, ok, subject_present
L’esito dell’ultimo accesso di prova tramite la connessione.
IdentityProviderWrite — obbligatori: kind, preset, name, proof
Invitation — obbligatori: id, kind, delivery, status, project_id, created_at, expires_at
InvitationAcceptRequest — obbligatori: token, mode
Nuove credenziali sono richieste per create_login e reset. Il link create_login richiede il cookie di iscrizione verificato e usa il suo nome visualizzato e email.
L’e-mail create_login richiede display_name. signed_in deve accedere entro dieci minuti oppure fornire una prova invitation_accept legata all’id dell’invito. buyer si applica solo a ad_buyer; i nuovi progetti buyer partono da zero crediti.
InvitationAccepted — obbligatori: kind, project_id, next
InvitationAdvertising — obbligatori: screen_ids, slot_ids, policy
Ambito di proprietà del venditore: almeno uno schermo o slot. Accettati solo schermi, solo slot o entrambi.
InvitationBuyer — obbligatori: none
InvitationCreate — obbligatori: kind
La consegna tramite e-mail richiede indirizzi e-mail. La consegna tramite link è solo project_member e non include e-mail né pubblicità. ad_buyer richiede la pubblicità. Al massimo 50 inviti in sospeso per membri e acquirenti per organizzazione; un invito e-mail in sospeso dello stesso tipo e indirizzo viene riutilizzato.
InvitationCreated — obbligatori: invitations
InvitationCredential — obbligatori: none
InvitationEmailVerificationAccepted — obbligatori: status, expires_at
InvitationEmailVerificationRequest — obbligatori: token, display_name, email
InvitationInspect — obbligatori: id, kind, delivery, project, expires_at, person, modes, methods
Ispezione non consumante. person è null per i link. Non riporta mai lo stato di verifica dell’iscrizione, tranne per il fatto che un reset dell’accesso, il cui link è andato solo all’indirizzo, indica se completarlo sostituisce un account non verificato (replaces_unverified_account). Le modalità email sono create_login o signed_in; i link offrono entrambe, e i reset offrono reset.
InvitationInspectRequest — obbligatori: token
InvitationIssued — obbligatori: id, kind, delivery, status, project_id, created_at, expires_at
InvitationKind — obbligatori: none
InvitationList — obbligatori: items, next_cursor
InvitationPasskeyOptionsRequest — obbligatori: token, mode
InvitationPasswordCredential — obbligatori: type, password
InvitationSignup — obbligatori: email, display_name, verified, expires_at
InvitationStatus — obbligatori: none
KVEntry — obbligatori: application_id, key, value_base64, content_type, bytes, sha256, revision
KVList — obbligatori: items, next_cursor
KVSummary — obbligatori: application_id, key, content_type, bytes, sha256, revision
KVWebhook — obbligatori: id, application_id, key, description, url, created_at
Un webhook key/value in ingresso. Il suo segreto è restituito solo da create e rotate-secret.
KVWebhookCreate — obbligatori: key
KVWebhookDelivery — obbligatori: at, outcome, status, bytes, request_id
KVWebhookDeliveryList — obbligatori: items
KVWebhookList — obbligatori: items
KVWebhookWithSecret — obbligatori: none
KVWebhookWriteResult — obbligatori: key, revision, bytes, sha256, content_type, updated_at
KVWrite — obbligatori: value_base64
LevelDate — obbligatori: date
Una data civile specifica, l’intero giorno o tra start e end come in una finestra. Inizia tra from e until e non è una data di eccezione.
LevelInteraction — obbligatori: none
Il livello è in vigore mentre qualcuno sta usando lo schermo: da un tocco, un clic o un tasto fino a quando trascorrono idle_s secondi senza input. Uso tipico: una pagina interattiva sopra un ciclo di attrazione. idle_s viene memorizzato e restituito (60 se omesso).
LevelMonthly — obbligatori: none
Un’occorrenza mensile nel fuso orario dello schermo: day (da 1 a 31; un mese senza quel giorno la salta), oppure nth (da 1 a 4, -1 l’ultimo) e weekday. start e end come in una finestra; la data in cui l’occorrenza inizia le appartiene.
LinearGradientBackground — obbligatori: type, stops
Gradiente lineare dall’alto verso il basso. Non c’è campo angolo. stops ha da 2 a 8 voci, strettamente crescenti in [0, 1], la prima a=0, l’ultima a=1.
LinearGradientStop — obbligatori: at, color
Una fermata su uno sfondo lineare dall’alto verso il basso. at=0 è il bordo superiore, at=1 è il bordo inferiore.
LiveFrames — obbligatori: live_id, state
Avanzamento dell’adattatore di frame di una sessione live. Schema aperto.
LiveSession — obbligatori: state, screen_id, viewer_url
Sessione live di uno schermo. Schema aperto.
LiveStartRequest — obbligatori: none
LiveViewer — obbligatori: viewer_id, live_id, offer, ice_servers, expires_at
Offerta del relay per uno spettatore. Schema aperto.
LiveViewerAnswer — obbligatori: answer
ManifestActivatedContext — obbligatori: manifest_revision
ManifestActivatedReport — obbligatori: severity, code, context
ManifestUpgradeContext — obbligatori: manifest_revision, state
ManifestUpgradePlaylist — obbligatori: id, name, revision
L’identità della playlist dietro una revisione desiderata emessa o in coda: desired_playlist usa la concessione desiderata esatta o l’obiettivo di contenuto condiviso in sola lettura per l’assegnazione effettiva corrente prima dell’emissione della concessione. active_playlist usa sempre la concessione storica esatta riconosciuta, mai un’assegnazione o modifica di contenuto più recente. id più revisione sono la versione della playlist che un operatore legge come Target v42 / Playing v41; name è il nome visualizzato della playlist, nullo quando la playlist non esiste più o non può essere risolta.
Una concessione storica attiva mancante è null, mai una revisione fabbricata. Un obiettivo desiderato in coda non concede accesso ai contenuti.
ManifestUpgradeReport — obbligatori: severity, code, context
Uno snapshot ciclo di vita manifest-upgrade latest-wins per lo schermo della sessione.
Il server memorizza uno slot per schermo e ne deriva il modello di lettura progetto Screen.manifest_upgrade; un report obsoleto, superato o pre-attivazione post-attivazione è accettato senza cambiamento (202), mai rifiutato come conflitto, e nessun report promuove mai un grant. severity è solo envelope: la gravità evento derivata dal progetto proviene dallo stato.
McrString — obbligatori: none
Importo esatto in millicrediti come stringa decimale canonica. 1 credito è 1000 mcr.
Media — obbligatori: id, filename, primitive, content_type, operation_id, sha256, bytes, revision, state, created_at, updated_at
MediaAvailability — obbligatori: none
Quando i selettori dinamici possono scegliere il media, nel fuso orario di ogni schermo: dentro [from, until) e in un’occorrenza di windows, monthly o dates (se nessuno dei tre: ogni giorno) la cui data non è in except. La grammatica dei livelli della programmazione senza data e interaction.
MediaAvailabilityPatch — obbligatori: availability
MediaCommit — obbligatori: content_type, bytes, sha256
Dichiara solo ciò che il server può verificare nuovamente byte per byte rispetto all’oggetto memorizzato. L’identità del codec non è dichiarata qui: il server la ricava dal contenitore durante la verifica asincrona, quindi un client non può affermare un codec che influenzi il comportamento del player.
MediaFolder — obbligatori: id, name, parent_id, revision, created_at, updated_at
Una cartella della libreria media. Un selettore playlist per:cartella riproduce direttamente i file pronti all’interno, non quelli delle sottocartelle.
MediaFolderCreate — obbligatori: name
MediaFolderList — obbligatori: items
MediaFolderPatch — obbligatori: none
MediaGenerationReference — obbligatori: none
Esattamente uno tra media_id o b64. URL HTTP sono rifiutati.
MediaGenerationRequest — obbligatori: prompt
Richiede un’immagine fissa. Il prompt è byte cliente e non viene mai restituito, registrato o pubblicato su SSE progetto. aspect_ratio predefinito 16:9. quality è low, medium o high e predefinito medium. tag è memorizzato sull’oggetto media pronto come tag di upload. Riferimenti opzionali sono base64 inline o media_id progetto; URL HTTP sono rifiutati.
La dimensione totale di tutti i riferimenti di una richiesta, sia inline che media_id, non deve superare 25165824 byte (24 MiB); una richiesta che supera questo limite viene rifiutata.
Su Standard, la rimanenza che non copre il doppio del costo fornitore dell’immagine fissa, arrotondato ai crediti interi, dopo il livello minimo introduttivo (meno 1.000.000 crediti fino al 2027-01-01, poi zero) restituisce payment_required, tranne che per sviluppo. Gli altri piani non vengono mai rifiutati per il loro saldo.
MediaGenerationUsage — obbligatori: quality, credits, usd
Addebito cliente per un’immagine memorizzata, lo usage nel result di una Operation media.generate in stato succeeded. quality è la qualità richiesta e cambia l’immagine, non un prezzo fisso. I crediti sono il doppio del costo venditore di quell’immagine, arrotondati per eccesso a crediti ScreenRig interi. usd è l’equivalente in dollari di quei crediti.
Mai nome venditore, costo venditore o conteggio token.
MediaList — obbligatori: items
MediaMove — obbligatori: folder_id
Almeno un id tra media_ids e folder_ids, massimo 1000 in totale.
MediaMoveResult — obbligatori: media, folders
MediaReplace — obbligatori: upload_id
MediaRestore — obbligatori: none
MediaRestorePending — obbligatori: status, review, warnings
MediaRestored — obbligatori: media, warnings
MediaSelectorTagFilter — obbligatori: none
MediaSelectorWeights — obbligatori: none
Quote di un selettore ponderato, indicizzate per ID media o tag:NAME.
Il peso di un elemento è la sua chiave ID media, se presente; altrimenti la prima chiave tag:NAME, in ordine alfabetico, tra i tag che porta, con quel peso diviso in parti uguali tra gli elementi della selezione che la portano, così la quota di uno sponsor resta la stessa qualunque sia il numero dei suoi contenuti; altrimenti l’elemento conta come un gruppo a sé con peso 1.
Ogni ciclo completo riproduce ogni elemento esattamente secondo la sua quota.
MediaSingleTagPatch — obbligatori: tag
MediaSync — obbligatori: id, project_id, account_id, provider, name, folder_id, every_s, state, source, next_run_at, revision, created_at, updated_at
Una cartella di origine tenuta allineata a una cartella media.
MediaSyncAccount — obbligatori: id, project_id, kind, name, config, secret, state, revision, created_at, updated_at
L’accesso con cui le sincronizzazioni leggono: le credenziali dell’app Microsoft Entra propria del progetto (microsoft365), la connessione di una persona a Canva (canva) o a Dropbox (dropbox), oppure un account di servizio Google con cui sono condivise le cartelle (google_drive). Il segreto client, i token e la chiave sono sigillati e non vengono mai restituiti.
MediaSyncAccountConfig — obbligatori: none
MediaSyncAccountConnect — obbligatori: none
Un account restituito con il suo link di consenso monouso: ciò che restituiscono la creazione di un account Canva o Dropbox e media sync account connect. La persona titolare dell’account Canva o Dropbox apre authorize_url, dopo aver effettuato l’accesso a Canva o a Dropbox, prima di authorize_expires_at. È il link di un solo consenso: invialo solo a quella persona. Le letture dell’account non lo portano mai.
MediaSyncAccountList — obbligatori: items, next_cursor
MediaSyncAccountPatch — obbligatori: none
MediaSyncAccountWrite — obbligatori: kind, name
MediaSyncCheck — obbligatori: name, ok, detail
MediaSyncDesign — obbligatori: id, title
Un design di Canva che la persona collegata può vedere.
MediaSyncDesignList — obbligatori: items, continuation
MediaSyncList — obbligatori: items, next_cursor
MediaSyncPatch — obbligatori: none
MediaSyncRun — obbligatori: at, status, added, updated, removed, pending_delete, skipped_total
Il riepilogo dell’ultima esecuzione di una sincronizzazione.
MediaSyncRunError — obbligatori: code, detail
MediaSyncSecret — obbligatori: set, hint
Come una risposta mostra il segreto client di un account, i token di un account Canva o Dropbox (impostati quando l’account è collegato, senza hint) o la chiave dell’account di servizio propria di un account Google Drive (impostata quando l’account ne ha una; hint riporta gli ultimi quattro caratteri del suo private_key_id). Il valore non viene mai restituito.
MediaSyncSkipped — obbligatori: name, reason
MediaSyncSource — obbligatori: web_url
L’origine che una sincronizzazione legge, risolta alla creazione della sincronizzazione. Una cartella SharePoint ha drive_id e item_id; una cartella Dropbox item_id e path; una cartella Google Drive item_id, drive_id quando si trova in un Drive condiviso, e shared_by; un design Canva ha design_id e i membri che lo seguono.
MediaSyncTest — obbligatori: at, ok, checks
MediaSyncWrite — obbligatori: provider, account_id
MediaTagPatch — obbligatori: none
MediaTagsPatch — obbligatori: tags
MediaUploadDeclaration — obbligatori: filename, content_type, bytes, sha256
Dichiara un solo caricamento. Il massimo di byte è un limite di trasporto indipendente dal piano, non una dimensione raggiungibile. Un tipo di contenuto immagine è ulteriormente limitato a 20971520 byte, 20 MiB, e una dichiarazione immagine più grande viene rifiutata con invalid_request prima che venga trasferito alcun byte.
Quel limite di immagine è un gate solo per byte: declaration non decodifica mai l’immagine per applicarlo, e si applica a GIF animate e WebP animate esattamente come a un’immagine statica. Il piano predefinito non ha limite di archiviazione prodotto.
Un limite di archiviazione personalizzato, quando presente, viene controllato per primo e una dichiarazione che non può contenere viene rifiutata con quota_exceeded prima del trasferimento di qualsiasi byte.
Un progetto Standard senza credito residuo viene rifiutato in declare e commit con payment_required quando i byte archiviati dal suo pagante, con questo caricamento, superano 1000000000 byte (1 GB, l’archiviazione gratuita di Standard); la banda non viene mai addebitata.
Una dichiarazione audio/mpeg (MP3) è limitata a 178257920 byte, 170 MiB, e una più grande è rifiutata allo stesso modo; leggi media_audio_bytes per precontrollarla.
Una dichiarazione video/mp4 o video/webm è limitata dal piano del progetto, 500000000 byte, 500 MB, su Standard e 1000000000 byte, 1 GB, su ogni altro piano, e una più grande è rifiutata allo stesso modo, indicando il limite applicabile; leggi media_video_bytes da GET /api/project/capabilities per precontrollarla.
Un cambio di piano riguarda solo le dichiarazioni successive: i video archiviati continuano a essere riprodotti. Leggi media_image_bytes dal documento capabilities per precontrollare il limite immagine, e project_content_bytes lì, o content_limit_bytes sul progetto, per conoscere qualsiasi limite di archiviazione personalizzato. Un tag opzionale è memorizzato sull’oggetto media pronto e non viene ridefinito al commit.
Un source_filename opzionale registra il nome file originale del chiamante quando il client ha transcodificato i byte prima dell’upload; il nome file dell’oggetto pronto viene quindi derivato da esso così fonti distinte non collidono mai (photo.png caricato come photo.webp è memorizzato come photo.png.webp, photo.jpg come photo.jpg.webp, e una fonte photo.webp resta photo.webp).
MediaUploadSession — obbligatori: id, operation, upload_url, method, headers, expires_at
MediaUploadSource — obbligatori: filename, content_type, sha256, bytes
Identità originale dell’upload verificata quando si acquisisce l’orientamento EXIF normalizzato. Sola lettura; usala per riconoscere i tentativi di ripetizione. Il digest, la dimensione e il tipo dei media pronti descrivono i byte di consegna normalizzati.
MediaUsage — obbligatori: playlists, screens
MediaUsagePlaylist — obbligatori: id, name, uses, screen_count
MediaUse — obbligatori: kind, where
Un modo in cui una playlist contiene o raggiunge il file multimediale; una playlist che lo fa su più pagine conta come un solo uso.
MediaVersion — obbligatori: number, current, filename, content_type, sha256, bytes, source, created_at
MediaVersionActor — obbligatori: kind
MediaVersionPage — obbligatori: items, next_cursor
MediaWarning — obbligatori: code, detail, playlists
MediaWarningPlaylist — obbligatori: id, name
MemberActivity — obbligatori: id, project_id, user_id, display_name, at, kind, action, outcome, status, source
MemberActivityClient — obbligatori: kind
Il client come lo nomina il log delle richieste edge, analizzato da User-Agent e Sec-CH-UA-Platform.
MemberActivityKind — obbligatori: none
sign_in e sign_in_failed contengono auth_method; credential_changed è una passkey aggiunta, rinominata o rimossa, una password impostata o una modifica email richiesta o verificata; reauthenticated è una prova controllata (azione reauthentication.<proof kind>); mutation è ogni altra modifica nel dashboard.
MemberActivityList — obbligatori: items, next_cursor, recorded_since
MemberActivityOutcome — obbligatori: none
ok sotto lo stato 400, rifiutato per risposta 4xx, fallito per risposta 5xx.
MemberActivityResource — obbligatori: type
MemberApproverUpdate — obbligatori: can_approve
MemberScreenScopeUpdate — obbligatori: screen_scope
MemberUploadScopeUpdate — obbligatori: upload_scope
NativeIdentityChallenge — obbligatori: nonce, expires_at, aud, op, request_hash
Confronta op e request_hash restituiti con i valori calcolati localmente prima di firmare. Ogni nonce scade in 120 secondi e può essere consumato una volta sola.
NativeIdentityChallengeRequest — obbligatori: kid, op, request_hash
Fornisci l’operazione e il suo request_hash per ogni challenge. Una chiave sconosciuta richiede anche public_key e op=pairing.start. Creare una challenge non iscrive la chiave.
NativeIdentityProof — obbligatori: kid, public_key, signature
Header protetto JWS compatto è esattamente {"alg":"EdDSA"}. Le claims sono kid, nonce, aud=screenrig-runtime, op, iat/exp interi, jti non vuoto e request_hash.
Le prove contestuali durano al massimo 120 secondi e scadono non oltre la loro sfida emessa. request_hash è SHA-256 esadecimale minuscolo di stringhe UTF-8 unite da un NUL, senza NUL finale, iniziando con screenrig.native.identity.request.v1 e op.
Aggiungi Idempotency-Key per pairing.start e session.mint; aggiungi la credenziale di associazione srp_ esatta poi completion_nonce per pairing.complete; non aggiungere nulla per identity.reset. Ogni prova deve includere request_hash. Un risultato di operazione memorizzato nella cache richiede comunque una prova emessa fresca o la prova esatta accettata mentre la sua ricevuta a breve termine rimane valida.
Membri JWS/JWK duplicati o sconosciuti, base64url non canonico e chiavi non in ordine primo sono rifiutati. Membri sconosciuti nel corpo della richiesta sono ignorati.
NativeIdentitySessionRequest — obbligatori: kid, public_key, signature
NativeIdentityProof con op=session.mint più l’indicazione host opzionale. Un host presente SOSTITUISCE l’host memorizzato sullo schermo, perché firmware e versioni shell cambiano nel tempo. L’indicazione non influisce mai sull’autorizzazione; solo la prova firmata lo fa.
Membri sconosciuti sono ignorati, e host e riproduzione sono letti con tolleranza (docs/player-compatibility.md §1.1).
NativePairingComplete — obbligatori: completion_nonce, public_key, signature
NativePairingCompletion — obbligatori: screen, public_url
NativePairingFleetLink — obbligatori: status
Cosa ha fatto il link flotta presentato per questa sessione di associazione. claimed e recovered significano che lo schermo è già scelto, e il Player completa l’associazione senza mostrare il codice. Qualsiasi altro stato lascia il codice sul vetro per una richiesta ordinaria.
NativePairingRecovery — obbligatori: offered
Presente solo quando il duid host o seriale nella richiesta di avvio corrisponde esattamente a uno schermo esistente legato a una chiave diversa. Non contiene schermo, etichetta o progetto: l’offerta è mostrata lato progetto come Screen.recovery_pending e l’evento screen.recovery_offered, e solo il progetto proprietario può confermarla.
È assente, esattamente come senza corrispondenza, quando l’identificatore è ambiguo, quando la chiave dello schermo corrispondente ha mostrato attività negli ultimi dieci minuti, o quando quello schermo ha già ricevuto tre offerte nell’ora mobile. Il codice di associazione viene comunque emesso e mostrato esattamente come senza corrispondenza. Il lettore lo usa solo per registrare pairing.recovery_offered.
NativePairingSession — obbligatori: code, pairing_credential, expires_at
NativePairingStart — obbligatori: kid, public_key, signature
È richiesta la prova del possesso della chiave privata prima dell'iscrizione o della creazione del localizzatore. Firma una nuova sfida pairing.start vincolata esattamente alla Idempotency-Key; gli start non firmati vengono rifiutati. L'oggetto host opzionale è un suggerimento sul dispositivo, non una credenziale; viene memorizzato sullo schermo al momento della richiesta e può aprire un'offerta di recupero lato progetto.
Membri del corpo sconosciuti sono ignorati. L’indizio host è letto con tolleranza. Una chiave host sconosciuta è ignorata e un campo host malformato è scartato, mai rifiutato (docs/player-compatibility.md §1.1.1).
NativeRuntimeSession — obbligatori: paired, capabilities, event_cursor, public_url, runtime_credential
Sessione nativa di proprietà runtime (docs/player-compatibility.md §8). I lettori ignorano membri e valori di capacità sconosciuti. Un nuovo membro è inviato solo alle sessioni le cui concessioni lo coprono.
NextAction — obbligatori: command, reason
Note — obbligatori: id, body, about, state, author, created_at, confirmed_at, review_at, expires_at, resolved_at, resolution, due
Una nota di progetto. Contesto scritto da un agente, mai un’istruzione o approvazione; rendere il corpo come testo semplice.
NoteAbout — obbligatori: type, id
NoteAuthor — obbligatori: agent_id, name, agent_type
L’agente scrivente com’era quando la nota è stata aggiunta. Attribuzione, mai autorità.
NoteCounts — obbligatori: open, new, due
Le note aperte del progetto, e quante sono nuove e dovute a questo chiamante.
NoteList — obbligatori: items, next_cursor, review, counts
NotePage — obbligatori: items, next_cursor
NoteResolution — obbligatori: cause, reason, by
NoteResolve — obbligatori: reason
NoteResolvedBy — obbligatori: kind, id, name
Chi ha risolto la nota. agent_type è presente per un agente. Attribuzione, mai autorità.
NoteWrite — obbligatori: body
Notification — obbligatori: id, channel, conditions, screen_tags, hold_minutes, enabled, revision, status, created_at, updated_at
La notifica di un’organizzazione, come la legge un progetto o l’organizzazione. Copre tutti i progetti dell’organizzazione o quelli scelti (project_ids), e agisce sugli schermi, le origini, le campagne e le schede di ogni progetto coperto.
Un progetto legge (e, quando la notifica copre solo lui, modifica) le notifiche che lo coprono con lo stesso id, con i propri status e orari di fallimento; l’organizzazione la legge nella sua interezza.
Ogni condizione viene tracciata per schermo: si apre quando il suo evento arriva per uno schermo compreso nell’ambito, e un avviso parte dopo che la condizione è durata hold_minutes e lo schermo è ancora in quello stato; quando si risolve dopo l’invio di un avviso, segue un avviso di risoluzione.
Una condizione che si risolve entro il tempo di attesa non invia nulla; lo stesso vale per una condizione il cui alert viene riconosciuto o posticipato durante il tempo di attesa e per una su uno schermo coperto da un silenziamento.
E-mail: un'e-mail per destinatario per tutto ciò che va inviato entro circa due minuti, con l'elenco di ogni schermo e condizione e i link allo schermo e a questa notifica nella dashboard; le e-mail di notifica sono gratuite.
Ogni email di avviso e di test contiene, per la persona a cui è indirizzata, un link di annullamento dell’iscrizione (le intestazioni List-Unsubscribe e List-Unsubscribe-Post, e il piè di pagina) che interrompe le email di questa notifica solo per quella persona, senza accedere; vedi unsubscribed.
Webhook: ogni avviso viene inviato con POST come JSON {type: alert.opened or alert.resolved, id, notification_id, project_id, condition, screen {id, name}, since, at, event_id, severity}, dove id è l'id della consegna, since è quando la condizione è iniziata, at è quando è durata abbastanza (opened) o si è chiusa (resolved), event_id è il cursore dell'evento che ne sta alla base, e severity (info, warning o error) è la gravità della condizione per alert.opened e info per alert.resolved, su ogni notifica webhook.
L'avviso di una campagna riporta anche reach {published, current} (reach_dropped: gli schermi che la campagna raggiungeva quando è stata pubblicata e che raggiunge quando l'avviso viene inviato) oppure audience_group {kind: tag or folder, value: the tag or the folder id} (group_empty); email e chat dicono lo stesso a parole.
Una notifica che imposta min_severity o severity lo dice anche nel testo di email, Slack, Telegram e Teams.
Teams e PagerDuty mostrano sempre la gravità effettiva. alert.resolved per screen_offline porta anche likely_cause, la causa dell'interruzione terminata (ScreenOutage.likely_cause) oppure null se sconosciuta; attende fino a due minuti dopo il ritorno dello schermo il primo report di salute per deciderla, e anche un'e-mail la nomina.
Un riavvio viene stabilito subito; una causa di rete o di piattaforma richiede un report di salute ricevuto dopo il ritorno dello schermo, che un Player può inviare fino a 15 minuti dopo, quindi un avviso partito prima contiene null e la causa compare in ScreenOutage.likely_cause e screen.outage_classified.
L’e-mail e i canali di chat comunicano tre o più schermi che entrano nella stessa condizione entro cinque minuti e condividono una rete, una posizione, un modello, una versione del Player o un tag come un unico avviso con un unico ripristino (NotificationDeliveryGroup); gli avvisi degli altri schermi vengono saltati come grouped.
Un webhook continua a inviare un avviso per schermo. Gli event_types vengono inviati con POST come lo stesso oggetto JSON restituito da GET /api/events.
Ogni POST include ScreenRig-Webhook-Id (l'id della notifica), ScreenRig-Event-Id (l'id della consegna per un avviso, il cursore dell'evento per un evento; stabile tra i tentativi, usalo per deduplicare), User-Agent e ScreenRig-Signature t=<unix seconds>,v1=<hex HMAC-SHA256 over "<t>.<raw body>" keyed with the secret string>.
Una risposta 2xx entro 10 secondi ha successo; qualsiasi altro esito viene ritentato con backoff esponenziale (da 30 secondi, raddoppiando fino a un'ora, con jitter) per 24 ore e poi contrassegnato come fallito; anche gli invii e-mail non riusciti vengono ritentati allo stesso modo.
Gli avvisi sugli schermi e gli eventi screen.* sono gratuiti; gli altri eventi sono conteggiati come un evento listen-stream. status è failing finché nulla ha avuto successo da failing_since; dopo 72 ore di errori continui la notifica viene disattivata (disabled_reason delivery_failures) e viene aggiunto notification.disabled.
NotificationActiveHours — obbligatori: timezone, windows
Quando partono gli avvisi aperti: le finestre (screenrig.schedule/v1), lette in timezone. Un avviso in scadenza mentre sono chiuse attende la successiva apertura (outside hold, il valore predefinito) e parte allora se la sua condizione persiste, quindi una condizione che rientra prima non invia nulla, oppure viene saltato (outside drop; last_error outside_hours).
Un avviso di risoluzione per un avviso aperto che è stato inviato parte sempre, dentro gli orari o no, e un test li ignora. crashing viene trattenuto o scartato come qualsiasi altra condizione. Gli orari giudicano un avviso quando parte la prima volta; uno fallito viene ritentato con la cadenza consueta a prescindere dagli orari.
Aggiungere, modificare o rimuovere gli orari fa rigiudicare subito gli avvisi trattenuti per i vecchi.
NotificationCondition — obbligatori: none
Un cambiamento di stato importante di uno schermo. screen_offline: il Player ha perso la connessione (screen.offline, scritto 60 secondi dopo che la sua presenza viene meno); si risolve con screen.online. display_disconnected: il Player segnala il proprio display come scollegato (screen.health_changed change display_disconnected); si risolve con display_reconnected. running_hot: il dispositivo segnala una temperatura pari o superiore alla soglia di surriscaldamento (temperature_high); si risolve con temperature_normal. on_battery: il dispositivo ha una batteria e il suo ultimo report di salute indica come fonte della batteria none, cioè scollegato (screen.health_changed change on_battery); si risolve quando un report indica qualsiasi altra fonte (plugged_in).
L’avviso dice che lo schermo funziona a batteria e non nomina alcuna causa. storage_full: lo spazio di archiviazione del Player non può contenere i suoi contenuti (screen.storage_shortfall); si risolve con screen.storage_shortfall_cleared. content_stuck: l’aggiornamento dei contenuti dello schermo è in nuovo tentativo, fallito, bloccato o parziale (screen.manifest_upgrade); si risolve quando uno stato successivo non è nessuno di questi. not_playing: il Player mostra uno stato di livello error al posto dei suoi contenuti (screen.status_changed con level error, diverso da storage_full); si risolve quando il suo stato non è più un errore. loop_stalled: il Player non segnala nulla di anomalo e i suoi contenuti sono aggiornati, ma nessun avvio di media è arrivato al backend da più tempo di quanto il ciclo dello schermo consenta (screen.glass_changed con il verdetto di riproduzione stalled; Screen.glass dice quando giudica e cosa lascia da parte); si risolve quando arriva un avvio di media o lo schermo smette di essere giudicato, per esempio quando va offline. glass_blank e glass_frozen: il backend ha letto gli screenshot dello schermo lungo una serie che copre il suo ciclo e tutti erano di un unico tono uniforme (glass_blank) o la stessa immagine (glass_frozen) (screen.glass_changed con il verdetto di immagine blank o frozen; Screen.glass dice quando giudica e cosa lascia da parte); si risolve quando due screenshot di fila mostrano un’immagine in movimento o lo schermo smette di essere giudicato.
Uno schermo che smette di essere giudicato chiude l’alert, ma le notifiche e-mail e chat non inviano per esso alcun avviso di ripristino, poiché non si è visto nulla ripristinarsi (la riga di risoluzione viene saltata come no_longer_judged); un avvio di media o due buoni screenshot ne inviano uno. crashing: il lettore è andato in crash o ha riavviato più volte il renderer (screen.health_changed change crash_spike o renderer_restart_spike); inviato subito, mai in attesa né risolto. source_failed e source_stale riguardano una sorgente di dati, non uno schermo: il membro screen dell’avviso contiene l’id e il nome della sorgente, il link è la pagina della sorgente e screen_tags non corrisponde mai a una sorgente, quindi una notifica limitata ai tag non le controlla. source_failed: l’aggiornamento della sorgente non è riuscito (source.status_changed con state error); si risolve al successivo aggiornamento riuscito (state ok). source_stale: l’ultimo aggiornamento riuscito della sorgente è più vecchio del suo stale_after_seconds, il momento in cui i dati delle sue card scadono e le pagine che ne dipendono ripiegano su un’alternativa (source.stale); si risolve al successivo aggiornamento riuscito.
Nessuno dei due è un alert di schermo. reach_dropped e group_empty riguardano una campagna (un livello condiviso dello stack di programmazione), non uno schermo: il membro screen dell'avviso riporta l'id e il nome della campagna, il link è il calendario della campagna nella dashboard, e una campagna appartiene al progetto, quindi screen_tags e audience non la limitano mai. reach_dropped: un ricalcolo ha trovato che la campagna raggiunge meno schermi di quando è stata pubblicata l'ultima volta, perché gli schermi hanno lasciato uno dei suoi tag o delle sue cartelle, oppure sono stati archiviati o eliminati (campaign.reach_changed con current inferiore a published); reach_drop stabilisce quanto deve essere ampio un calo per essere notificato; si chiude quando raggiunge di nuovo altrettanti schermi.
Una pubblicazione che imposta una nuova baseline, o l'eliminazione della campagna, la chiude anch'essa: chiude un incidente del pager e un alert del webhook ma non invia alcuna email o avviso di chat di ripristino (no_longer_judged). group_empty: un tag o una cartella del pubblico della campagna non corrisponde ad alcuno schermo (campaign.group_changed con matched 0); un avviso per ogni tag o cartella (audience_group); si chiude quando corrisponde di nuovo a uno schermo, o quando una pubblicazione lo rimuove dal pubblico (removed true), il che chiude un incidente del pager e un alert del webhook ma non invia alcuna email o avviso di chat di ripristino (no_longer_judged).
Le voci di programmazione di uno schermo puntano a playlist, non a schermi, quindi solo le campagne hanno una copertura.
Nessuno dei due è un alert di schermo. card_data_stale riguarda una scheda, non uno schermo: il membro screen dell’avviso riporta l’ID della scheda e il suo nome (il tipo della scheda, come in «scheda meteo»), il link è l’editor di pagine della dashboard su una pagina che colloca la scheda (la pagina della notifica stessa quando nessuna lo fa), e since è il momento in cui i suoi dati sono scaduti.
Si apre quando il documento di dati di una scheda, che un agente, un job o una persona ha scritto con una scadenza (ttl_seconds o expires_at, come in card data put --ttl), raggiunge quella scadenza senza un’altra scrittura che lo rinnovi mentre uno schermo mostra la scheda (card.data_expired), così la scheda è vuota su quello schermo; si chiude quando arriva una scrittura sui dati della scheda (card.data_renewed).
I documenti di un’origine dati non vengono annunciati: scadono secondo il periodo di scadenza dell’origine, che source_stale copre. Una scheda che nessuno schermo mostra non invia nulla, e nemmeno una rinnovata, eliminata o tolta da tutti gli schermi prima che l’avviso sia dovuto.
Eliminare i dati di una scheda chiude l’avviso senza un avviso di ripristino, come una pubblicazione chiude un calo di copertura (no_longer_judged). Dimensiona ttl_seconds sulla pianificazione di chi scrive, così un job fermo viene notato. Come un’origine dati, una scheda non ha tag di schermo: una notifica limitata a screen_tags non controlla le schede, e non è un alert di schermo.
I client trattano un valore sconosciuto come assente.
NotificationConditions — obbligatori: none
NotificationDelivery — obbligatori: id, notification_id, event_id, event_type, state, attempts, created_at
NotificationDeliveryAttempt — obbligatori: attempt, at, status, error, duration_ms
NotificationDeliveryAttemptList — obbligatori: items
NotificationDeliveryGroup — obbligatori: id, attribute, value, count
Un gruppo di schermi rappresentato da un solo avviso. Quando almeno tre schermi di un progetto entrano nella stessa condizione a meno di cinque minuti l’uno dall’altro e condividono un valore, una notifica via e-mail, Slack, Teams, PagerDuty o Telegram invia un solo avviso per tutti invece di uno per schermo.
Uno schermo che entra nella condizione più tardi con un valore di cui è fatto il gruppo aperto si unisce a esso senza un nuovo avviso, e un solo avviso indica il gruppo quando si ripristina il suo ultimo schermo. Una notifica webhook continua a inviare un avviso per schermo.
NotificationDeliveryList — obbligatori: items, next_cursor
NotificationDestination — obbligatori: none
Solo Slack, Teams, PagerDuty e Telegram; obbligatorio per essi. La credenziale nella forma in cui il servizio la emette: slack, l’URL del webhook in entrata (hooks.slack.com); teams, l’URL del webhook Workflows (logic.azure.com o powerplatform.com; gli URL dei connettori Office 365 sono dismessi); pagerduty, la chiave di instradamento Events API v2 di 32 caratteri; telegram, il token del bot.
Un’altra forma dà notification_destination_rejected. Viene sigillato, non viene mai restituito e in lettura compare solo come destination_hint.
NotificationEventTypes — obbligatori: none
Solo webhook. Eventi di progetto inviati inoltre con POST man mano che si verificano, esattamente come li invia un webhook: tipi esatti come screen.online, oppure prefissi che terminano con .* come screen.*. notification.test non viene mai distribuito.
NotificationList — obbligatori: items
NotificationPatch — obbligatori: none
NotificationProjectIDs — obbligatori: none
Progetti live dell’organizzazione, ciascuno nominato una sola volta. Un elenco vuoto non ne copre nessuno.
NotificationReachDrop — obbligatori: none
Il calo più piccolo della copertura di una campagna per cui viene inviato un avviso reach_dropped: screens è il minor numero di schermi persi (default 1) e percent, se impostato, la quota più piccola degli schermi che la campagna raggiungeva quando è stata pubblicata; un calo deve soddisfare entrambi.
Un calo più piccolo non mette in coda alcun avviso, e un avviso in coda il cui calo si è ridotto al di sotto della soglia alla scadenza viene saltato (condition_cleared). Solo con la condizione reach_dropped; su una notifica senza di essa, invalid_request.
NotificationRecipients — obbligatori: none
Solo e-mail. owner (chi possiede il progetto nel momento in cui viene inviato un avviso) oppure lo user_id di una persona che è membro del progetto; uno user_id che non appartiene a un membro restituisce invalid_request. A ciascuno viene inviata un'e-mail al suo indirizzo verificato. Chi nel frattempo ha lasciato il progetto o non ha un indirizzo verificato viene saltato.
NotificationSeverity — obbligatori: none
La gravità di un avviso, dalla meno grave. Un avviso aperto ha la gravità della sua condizione: error per screen_offline e warning per ogni altra condizione, salvo diversa indicazione della severity della notifica. Un avviso risolto e un test sono info.
NotificationSeverityOverrides — obbligatori: none
Da condizione a gravità per questa notifica, ad esempio {"not_playing": "error"}. Conta per min_severity ed è la gravità che Teams e PagerDuty mostrano per la condizione. Una condizione non elencata mantiene il valore predefinito. In una patch un oggetto vuoto, come null, azzera ogni override.
NotificationTelegramChat — obbligatori: none
Solo Telegram; obbligatorio per esso. La chat in cui pubblicare: il suo id numerico (negativo per un gruppo o canale) oppure @channelname. Non è una credenziale.
NotificationUnsubscription — obbligatori: user_id, at
NotificationWrite — obbligatori: channel
email invia ai destinatari, webhook fa POST firmato a url, e slack, teams, pagerduty e telegram pubblicano un messaggio per interruzione e per schermo in una chat o in un pager con il destination in sola scrittura (telegram richiede anche telegram_chat_id), poi un ripristino; PagerDuty apre un incidente e lo risolve. Richiedono almeno una condizione e non accettano event_types.
OAuthAuthorization — obbligatori: id, client_name, client_registered, redirect_host, access, capabilities, created_at, expires_at
OAuthAuthorizationRedirect — obbligatori: redirect_uri
OAuthError — obbligatori: error
OAuthTokenResponse — obbligatori: access_token, token_type, expires_in
OnboardingSiteCTA — obbligatori: label, path, href, at
Il link di iscrizione o di accesso su cui la persona ha fatto clic sul sito web.
OnboardingSiteVisit — obbligatori: path, at
OnboardingStepName — obbligatori: none
Un passaggio dei flussi di ingresso, in ordine di visualizzazione. email_verified, email_gate_reached e i traguardi dell’account (agent_connected, screen_paired, playlist_with_content, activated) sono scritti o uniti dal server e non sono nomi che un client invia.
OnboardingStepRequest — obbligatori: journey_id, step
OnboardingValue — obbligatori: none
Ciò che la persona ha inserito in un passaggio: l’indirizzo digitato (email_submitted, reset_requested), il nome (signup_name_entered), sì o no (signup_marketing_choice), le opzioni scelte o il testo del follow-up (question_answered, question_follow_up), un indirizzo o un nome inserito in un invito. Mai una password, un codice o un token. Un valore vuoto è trattato come assente.
Operation — obbligatori: id, kind, state, created_at, updated_at
OperationAccepted — obbligatori: id, release_id, operation_id
OrganizationAdminInvitation — obbligatori: id, kind, delivery, status, recipient_email, organization_id, created_at, expires_at
OrganizationAdminInvitationCreate — obbligatori: emails
OrganizationAdminInvitationCreated — obbligatori: invitations
OrganizationAdminInvitationList — obbligatori: items, next_cursor
OrganizationAdmins — obbligatori: admins, candidates, revision
OrganizationAdminsUpdate — obbligatori: admin_user_ids
OrganizationBillingUsage — obbligatorio: org_id, period, pool, allowance, stored_bytes, screens, projects, next_cursor
OrganizationDomainChallenge — obbligatori: organization_id, challenge_id, domain, name, value, expires_at
OrganizationDomainInput — obbligatori: domain
OrganizationDomainProof — obbligatori: challenge_id
OrganizationDomainRemoved — obbligatori: status
OrganizationGuestPolicy — obbligatori: mode, domains
La policy per gli ospiti dell’organizzazione in vigore. Gli ospiti sono persone la cui organizzazione di appartenenza è un’altra, o che non ne hanno; una policy non rimuove mai chi è già membro.
OrganizationGuestPolicyDomain — obbligatori: none
Un nome DNS in minuscolo con almeno due etichette, come compare dopo la @ di un indirizzo email verificato (i nomi internazionalizzati nella loro forma xn--).
OrganizationGuestPolicyMode — obbligatori: none
allow ammette ogni ospite. domains ammette un ospite il cui indirizzo email verificato è su uno dei domini elencati (corrispondenza esatta). none non ammette alcun ospite. I membri dell’organizzazione non sono mai ospiti.
OrganizationGuestPolicyResult — obbligatori: mode, domains, outside_policy
La policy per gli ospiti ora in vigore, con il numero di persone che lascia fuori.
OrganizationGuestPolicyUpdate — obbligatori: mode
OrganizationLibraryUpdate — obbligatori: project_id
OrganizationList — obbligatori: organizations, new_organization_allowed
OrganizationMemberInvitation — obbligatori: id, kind, delivery, status, recipient_email, organization_id, created_at, expires_at
OrganizationMemberInvitationCreate — obbligatori: emails
OrganizationMemberInvitationCreated — obbligatori: invitations
OrganizationMemberInvitationList — obbligatori: items, next_cursor
OrganizationNotificationList — obbligatori: items
OrganizationNotificationPatch — obbligatori: none
Un NotificationPatch e project_ids.
OrganizationNotificationWrite — obbligatori: channel
Un NotificationWrite e i progetti coperti dalla notifica. Un project_ids assente o null copre ogni progetto dell’organizzazione, compresi quelli aggiunti in seguito; un elenco copre esattamente quei progetti, ciascuno un progetto live dell’organizzazione.
OrganizationPayments — obbligatori: organization_id, available, local_simulation, purchases
OrganizationPeople — obbligatori: projects, people, truncated
OrganizationPeopleMembership — obbligatori: project_id, role, can_approve
OrganizationPeoplePerson — obbligatori: user_id, display_name, email, admin, member, managed, outside_guest_policy, projects
OrganizationPeopleProject — obbligatori: project_id, name
OrganizationPerson — obbligatori: user_id, display_name, email
OrganizationPersonal — obbligatori: none
L’organizzazione è solo l’involucro del suo unico progetto: esattamente un progetto attivo, nessun dominio verificato, nessun piano organizzativo ora o programmato, e nessun amministratore oltre al proprietario di quel progetto. Il dashboard nasconde il livello organizzazione per questo.
OrganizationProject — obbligatori: id, name, organization_id, status, screen_count
OrganizationProjectAccess — obbligatori: project_id, joined
OrganizationProjectAccessChange — obbligatori: project_id, user_id, access
OrganizationProjectAccessRequest — obbligatori: changes
OrganizationProjectAccessResult — obbligatori: changes
OrganizationProjectOwner — obbligatori: project_id, owner_user_id
OrganizationProjectOwnerUpdate — obbligatori: user_id
OrganizationProjectPage — obbligatori: projects, next_cursor
OrganizationRename — obbligatori: name
OrganizationSummary — obbligatori: id, name, personal
OrganizationView — obbligatori: id, name, personal, revision, admin, home, project_count, plan_id, free, plan_required, education_eligible, education_eligibility_source
PageDataCondition — obbligatori: key
Un predicato card-data, valutato prima del tempo civile. Dati mancanti o scaduti non corrispondono mai. La pagina rispetta anche i suoi normali limiti temporali. Richiede la capacità host page.conditions; host più vecchi ricevono la pagina disabilitata.
PageFailure — obbligatori: page_id, code, at
Ultimo report playback.page_failed accettato per questo schermo. Assente finché un lettore non ne segnala uno. Metadati di salute progetto in sola lettura; non modifica la revisione schermo o l’autorità del manifesto.
PageVisibility — obbligatori: enabled
Programmazione opzionale di visibilità pagina. È un fratello di advance e non fa mai parte di screenrig.canvas/v1; descrive l’orchestrazione della riproduzione, non la geometria. Il server convalida e trasporta queste regole come dati. Il player le valuta rispetto al fuso orario dello schermo pubblicato alla radice del manifest.
Una pagina è idonea quando enabled è true, now è dentro [from, until), e windows è assente o almeno una finestra corrisponde. Ogni playlist deve mantenere almeno una pagina senza campo visibility, quindi esiste sempre contenuto idoneo. I vettori di conformità per le regole di valutazione sono la famiglia screenrig.schedule/v1 in packages/schedule-contract.
PageVisibilityWindow — obbligatori: days
Una finestra civile ricorrente. Omettere start e end seleziona l’intera giornata. Quando end è minore o uguale a start la finestra attraversa la mezzanotte e il giorno di start la possiede, quindi ven 22:00 a 02:00 arriva al mattino di sabato.
PairScreen — obbligatori: code
PairingClaim — obbligatori: screen, public_url
PairingClaimedEvent — obbligatori: type, completion_nonce
PairingComplete — obbligatori: completion_nonce
PairingCompletion — obbligatori: screen, public_url
PairingSession — obbligatori: code, expires_at
PasskeyAdditionProof — obbligatori: authorization_ceremony_id, authorization_credential
PlaybackAggregate — obbligatori: screen_id, media_id, filename, day, play_count, last_page_id, last_manifest_revision, first_started_at, last_started_at
PlaybackAggregateCsv — obbligatori: none
CSV RFC 4180, record CRLF, UTF-8, con riga di intestazione screen_id,media_id,filename,primitive,day,play_count,last_page_id,last_manifest_revision,first_started_at,last_started_at. Gli orari sono in UTC RFC 3339. Una cella che inizia con =, +, -, @, tab o ritorno a capo è preceduta da un apostrofo singolo per evitare che i fogli di calcolo la valutino.
Content-Disposition nomina playback-aggregates.csv. Un flusso che fallisce dopo l’intestazione viene interrotto alla connessione.
PlaybackAggregateList — obbligatori: items
PlaybackApplicationStartedContext — obbligatori: manifest_revision, page_id, primitive_id, release_id
PlaybackApplicationStartedReport — obbligatori: severity, code, context
Un inizio visibile di un primitivo applicazione su una pagina: l’applicazione è diventata visibile sul vetro, riportata una volta per apparizione pagina dal controller Player — il contenuto dell’app non riporta mai la propria visibilità, e un download pacchetto non è mai un inizio.
Lo schermo mittente è autenticato; identità di pagina, primitiva, release e manifesto sono osservazioni riportate senza contenuto o controlli di appartenenza a grant. Memorizza un record di riproduzione duraturo per ogni play (GET /api/playback/plays). Timestamp di manutenzione release/applicazione di proprietà progetto seguono tramite una proiezione batch recuperabile.
I riconoscimenti ordinari di riproduzione omettono intestazioni opzionali di saldo crediti. Non esiste una riga aggregata giornaliera per gli avvii dell’app; i record di riproduzione sono la prova.
PlaybackCompleteness — obbligatori: day_from, day_to, measured_plays, missing_plays, completeness, days, gaps, truncated
Quante delle riproduzioni effettuate dagli schermi sono arrivate al backend, nei giorni UTC da day_from a day_to inclusi. measured_plays e missing_plays sono le somme di days, e completeness è il rapporto tra measured_plays e la loro somma, null quando entrambi sono 0. days elenca, dal più vecchio, solo i giorni con una riproduzione misurata o mancante. gaps elenca i buchi nella numerazione delle riproduzioni, dal più recente.
Le riproduzioni senza numero (Player meno recenti, avvii memorizzati prima dei numeri di riproduzione) non rientrano in nessuno di questi valori.
PlaybackCompletenessDay — obbligatori: day, measured_plays, missing_plays, completeness
La numerazione delle riproduzioni di un giorno di ricezione UTC.
PlaybackCompletenessShare — obbligatori: none
Le riproduzioni arrivate rispetto alla somma di riproduzioni arrivate e riproduzioni mancanti, da 0 a 1. null se non esistono né le une né le altre, come per i Player meno recenti che non numerano le riproduzioni.
PlaybackGap — obbligatori: screen_id, day, from, to, missing_plays
Una sequenza di numeri di riproduzione saltati da un Player: altrettante riproduzioni sono state effettuate ma non sono mai arrivate.
PlaybackGrant — obbligatori: none
La stretta di mano di riproduzione concessa dal backend: l’intersezione tra PlaybackHandshake del mint e ciò che questo backend supporta, firmata nella sessione. Ometta dalla sessione quando nulla si interseca, quindi una sessione creata senza stretta di mano resta invariata. Un lettore usa /screen/manifest solo quando manifest_versions contiene 3.
PlaybackHandshake — obbligatori: none
Handshake di riproduzione opzionale che un Player dichiara al mint. È un suggerimento che seleziona il comportamento, mai l’autorizzazione: membri sconosciuti e voci di tipo errato sono ignorati, e un valore non oggetto non negozia nulla. La risposta mint riecheggia l’intersezione supportata come PlaybackGrant. adslot-v1 è concesso solo a sessioni associate.
PlaybackMediaStartedContext — obbligatori: media_id, manifest_revision, page_id, primitive
PlaybackMediaStartedReport — obbligatori: severity, code, context
Un inizio visibile di un primitivo immagine o video su una pagina. I Player inviano questo una volta per apparizione pagina del media, per immagini esattamente come per video; i loop all’interno di una stessa apparizione non sono riavvii. Lo schermo mittente è autenticato; identità media, pagina, primitivo e manifest sono osservazioni senza controlli di contenuto o appartenenza a grant.
Il successo conferma l’inserimento grezzo durevole; i conteggi giornalieri seguono tramite una proiezione batch recuperabile. Le conferme di riproduzione ordinarie omettono gli header opzionali del saldo crediti.
PlaybackPageFailedContext — obbligatori: page_id, code
PlaybackPageFailedReport — obbligatori: severity, code, context
Segnala che una pagina non è riuscita a diventare pronta. All’accettazione il server sostituisce Screen.last_page_failure e aggiunge un evento playback.page_failed duraturo solo per il progetto nella stessa transazione. Non modifica la revisione dello schermo né l’autorità del manifesto.
PlaybackPlay — obbligatori: screen_id, page_id, media_id, primitive, received_at
Un inizio duraturo segnalato dal Player di un’immagine, video o applicazione.
La sessione autentica schermo e progetto; identità di item, pagina, manifesto, primitiva e release sono osservazioni riportate e non autorizzano l’accesso ai contenuti. playlist_id e playlist_revision sono metadati opzionali arricchiti asincronamente da un manifesto schermo corrispondente; i metadati mancanti restano assenti.
L’applicazione avvia carry release_id con media_id e primitive vuoti. primitive_id e started_at sono presenti solo quando il Player li segnala; started_at è limitato a [received_at - 24h, received_at + 5m].
Una pagina JSON riporta anche i nomi dello schermo, del media, della playlist e dell’applicazione come testo da visualizzare, letto quando la pagina viene servita; l’esportazione CSV e i report xlsx e pdf omettono questi nomi.
PlaybackPlayCsv — obbligatori: none
CSV RFC 4180, record CRLF, UTF-8, con riga di intestazione screen_id,playlist_id,page_id,primitive_id,media_id,primitive,started_at,received_at,manifest_revision,playlist_revision in quest’ordine fisso; un valore assente è una cella vuota. Gli orari sono in UTC RFC 3339. Una cella che inizia con =, +, -, @, tab o ritorno a capo è preceduta da un apostrofo singolo.
Content-Disposition nomina playback-plays.csv. Un’esportazione completa termina dopo l’ultimo record CRLF senza trailer; un flusso che fallisce dopo l’intestazione viene interrotto alla connessione (il client vede un errore di trasporto, mai una fine pulita), quindi riprova dall’ultimo received_at.
PlaybackPlayList — obbligatori: items, next_cursor
PlaybackTotals — obbligatori: by, day_from, day_to, truncated
Totali di riproduzione su giorni UTC inclusivi da day_from a day_to. Esattamente uno tra days (by=day), screens (by=screen), media (by=media) o screen_days (by=screen_day, raggruppati per schermo in ordine di classifica, giorni in ordine crescente) è presente, quello nominato dalla richiesta. truncated è true quando una classifica può escludere chi è sotto il migliore di una fetta o di un negozio.
PlaybackTotalsDay — obbligatori: day, play_count, first_started_at, last_started_at
PlaybackTotalsMedia — obbligatori: media_id, play_count, first_started_at, last_started_at
PlaybackTotalsScreen — obbligatori: screen_id, play_count, first_started_at, last_started_at
PlaybackTotalsScreenDay — obbligatori: screen_id, day, play_count
PlaybackVideoStartedContext — obbligatori: media_id, manifest_revision, page_id
PlaybackVideoStartedReport — obbligatori: severity, code, context
Segnala un avvio video visibile. Usa la stessa aggregazione giornaliera di playback.media_started con video primitivi. Invia un report per ogni avvio; inviare entrambi i tipi di evento conta l’avvio due volte. Usa playback.media_started per segnalare sia immagini che video.
PlayerBrowserIdentity — obbligatori: kind, version, pwa
Motore browser e modalità di installazione per Player browser, incluse shell native. Un suggerimento browser opzionale malformato viene ignorato senza rifiutare la richiesta.
PlayerCardsIdentity — obbligatori: none
La libreria di carte integrata che il Player porta (docs/player-compatibility.md §3.1): la versione CalVer della libreria e il semver di ogni carta, il cui major indica quali posizionamenti di carte lo schermo rende. Memorizzata sullo schermo con il resto del player. Voci malformate vengono scartate una a una; non è mai un 400.
PlayerIdentity — obbligatori: kind
Autoidentificazione del lettore, inviata solo sulle tre rotte mint (docs/player-compatibility.md §3.1). È un suggerimento e mai un’autorizzazione, e non è coperta dalla prova nativa. Viene letta con tolleranza: i membri sconosciuti sono ignorati, un membro opzionale non valido viene scartato da solo, e un lettore che non è un oggetto o non ha un tipo valido non dichiara nulla.
Non è mai un 400. Un mint associato lo memorizza sullo schermo per l’istogramma della flotta operatore.
PlayerPublicKey — obbligatori: kty, crv, x
PlayerShellIdentity — obbligatori: kind
La shell sotto cui gira un lettore web. I suoi token compat sono registrati, mai concessi. Un tipo non valido scarta la shell.
Playlist — obbligatori: id, name, revision, pages
PlaylistAdvance — obbligatori: none
PlaylistAdvanceWrite — obbligatori: none
PlaylistApplicationAdvance — obbligatori: mode, max_ms
PlaylistApplicationPrimitive — obbligatori: id, primitive, release_id, rect, layer, content_fit
PlaylistApplicationPrimitiveWrite — obbligatori: id, primitive, release_id, layer, content_fit
PlaylistApproval — obbligatori: state, review_id
Presente mentre è in sospeso una revisione di questa playlist. La playlist stessa è la versione live (approvata).
PlaylistAudio — obbligatori: tracks, loop, volume
Colonna sonora della playlist archiviata con valori predefiniti compilati.
PlaylistAudioCue — obbligatori: track
Suggerimento opzionale di colonna sonora su una pagina ordinaria. Quando la pagina diventa corrente, il Player passa alla traccia nominata dall’inizio a meno che non stia già suonando; restart true la riavvia anche allora. La sequenza continua da quella traccia.
I lettori possono ignorare un suggerimento. track deve nominare un ID traccia nell’audio della playlist; un cue senza audio playlist è invalid_request. Non consentito sulle pagine adslot. Una pagina con modalità avanzata audio_end termina quando la traccia in coda finisce; richiede questo cue.
PlaylistAudioEndAdvance — obbligatori: mode, max_ms
PlaylistAudioEndAdvanceWrite — obbligatori: mode
La pagina termina quando la traccia della colonna sonora che il suo audio_cue nomina termina. La pagina deve avere un audio_cue e la playlist una colonna sonora audio (docs/playlist-audio.md).
PlaylistAudioTrack — obbligatori: id, media_id
PlaylistAudioWrite — obbligatori: tracks
Colonna sonora opzionale della playlist: contenuti audio ordinati pronti (MP3) che suonano continuamente mentre le pagine cambiano (docs/playlist-audio.md). I cambi pagina non la fermano né la riavviano. PUT sostituisce l’intera playlist, quindi omettere audio rimuove la colonna sonora.
PlaylistCanvas — obbligatori: width, height, background
PlaylistCardPrimitive — obbligatori: id, primitive, card, major, params, rect, layer, content_fit, controller
PlaylistCardPrimitiveWrite — obbligatori: id, primitive, card, layout, content_fit
Una scheda integrata che il Player disegna nativamente (orologio, meteo, menu board, ticker, KPI tiles e il resto del catalogo schede venduto, screenrig.cards.contract/v1). layout la posiziona: full (tutta la tela), free (il proprio rettangolo e livello), center (900 x 420), wide (tela con margine 30 a sinistra e destra e 80 sopra e sotto), header (tutto il bordo superiore, alto 80), footer (tutto il bordo inferiore, alto 80), corner (270 quadrato), chip (240 x 70) o strip (tutto il bordo, alto 120), in unità design 1080p scalate da min(larghezza tela, altezza tela) / 1080. corner e chip prendono un angolo di ancoraggio (alto-sinistra, alto-destra, basso-sinistra, basso-destra) e strip un bordo di ancoraggio (alto, basso, sinistra, destra); gli altri layout nessuno.
Tranne che per free, il server deriva rect e layer dalla tela o dai display del frame cover: ometterli o inviare esattamente ciò che deriva.
Una pagina contiene al massimo una card full, center o wide, una card corner o chip per ogni angolo, e una strip per ogni bordo (una card con presenza può condividere un bordo con una strip normale); un header occupa lo slot strip normale del bordo superiore e un footer quello del bordo inferiore, quindi una pagina contiene al massimo uno di ciascuno, senza strip normale su quel bordo, e una card con presenza può comunque condividerlo.
Un angolo o scheggia su un bordo che tiene una striscia si sposta oltre di 120, e oltre un’intestazione o piè di pagina di 80.
Su una playlist con formato, displays è il frame da cui deriva il layout (full è il frame, corner l’angolo del frame; free rifiuta displays), la scala della card è il min(larghezza, altezza) della tile / 1080 = 1 anziché derivata dal frame, e due card competono per uno slot, o si spostano oltre le strisce l’una dell’altra, solo quando i loro frame condividono un display (no displays è ogni display).
Il tier di una card determina i suoi layout (GET /api/card-types): core accetta tutti e nove, fullscreen accetta full. params contiene le proprietà statiche del posizionamento (tema, posizione, titoli, definizioni delle colonne) e cambia solo con una nuova pubblicazione.
Una stringa in params può contenere {screen.name}, {screen.timezone} e {screen.field.NAME}, e un parametro location può essere la stringa {screen.location}; il backend li espande per ogni schermo, così una playlist mostra a ogni schermo i propri valori. data indica un documento dati della card (GET/PUT /api/card-data/{key}) che contiene le proprietà dinamiche della card (sezioni del menu, voci del ticker, riquadri KPI); gli agenti lo modificano senza una nuova pubblicazione. {screen.field.NAME} in una chiave data legge un documento per schermo, ad esempio menu-{screen.field.store_number}.
Con dati, i parametri non possono avere proprietà dinamiche; senza dati, i parametri contengono tutta la configurazione. Ogni stringa in params che inizia con media: è un riferimento a contenuti multimediali, media:<id>, che nomina un’immagine pronta in questo progetto che la scheda disegna (spotlight people[].photo, product-grid products[].photo); una scheda non prende mai un URL immagine.
La pubblicazione rifiuta una scheda sconosciuta o parametri maggiori e non validi (card_invalid), un layout, un'ancora, un rettangolo o un livello che la scheda non può contenere (card_layout_invalid), schede che rivendicano un solo posto nella pagina (card_layout_conflict), un riferimento media che non nomina alcuna immagine pronta del progetto (card_media_invalid) e una chiave vincolata il cui documento memorizzato la scheda rifiuta (card_data_invalid).
Gli schermi che mostrano il posizionamento ricevono i suoi contenuti multimediali, e una scrittura live approva i contenuti in sospeso che nomina, come con un selettore by:id. Una scheda con un feed di terze parti (meteo) lo legge dalla chiave che il server ricava dai suoi parametri statici.
PlaylistCreateRequest — obbligatori: none
Le pagine di una playlist, un modello da cui crearla, o il modello iniziale integrato.
PlaylistDisplays — obbligatori: none
Solo playlist con un formato. I display coperti da una primitiva: numeri di display crescenti e univoci, basati su 1, entro 1..format.displays, che riempiono un rettangolo delle tile della parete, come [2], [1, 2] o, su una griglia di 4 colonne, [2, 3, 6, 7]. In una riga o in una colonna sono contigui.
Il server ricava rect come il riquadro di delimitazione di queste tile; rect è omesso o esattamente il valore ricavato. Memorizzato e restituito alla lettura.
PlaylistDurationAdvance — obbligatori: mode, after_ms
PlaylistExpandRequest — obbligatori: none
PlaylistExpanded — obbligatori: pages
PlaylistFormat — obbligatori: none
Per che cosa è stata creata una playlist: un video wall (PlaylistWallFormat) o una regione (PlaylistRegionFormat), mai entrambi. Una playlist senza formato è una playlist ordinaria che si lega a qualsiasi schermo come pagina.
PlaylistFromTemplate — obbligatori: playlist_id
Crea una playlist da un modello: le sue pagine attuali con i valori compilati, validate da tutte le regole delle playlist. Un valore multimediale deve essere un elemento pronto del tipo giusto, un valore indirizzo un indirizzo http o https.
PlaylistFromTemplateWrite — obbligatori: name, from_template
Crea una playlist da un modello. Invia solo name e from_template.
PlaylistIframePrimitive — obbligatori: id, primitive, src, title, rect, layer, content_fit, controller
PlaylistIframePrimitiveWrite — obbligatori: id, primitive, src, title, layer, content_fit
PlaylistImagePrimitive — obbligatori: id, primitive, selector, resolved_media, rect, layer, content_fit, controller
PlaylistImagePrimitiveWrite — obbligatori: id, primitive, selector, layer, content_fit
PlaylistInstance — obbligatori: id, name, revision, template_revision, outdated
PlaylistInstanceList — obbligatori: items
PlaylistIntrinsicSize — obbligatori: width, height
PlaylistList — obbligatori: items
PlaylistMediaEndAdvance — obbligatori: mode, max_ms
PlaylistMediaEndAdvanceWrite — obbligatori: mode
PlaylistMediaSelector — obbligatori: none
PlaylistMediaSelectorByAll — obbligatori: by
PlaylistMediaSelectorByFolder — obbligatori: by, folder_id
I file pronti della cartella multimediale primitiva direttamente all’interno di una cartella media (GET /api/media-folders), non quelli delle sue sottocartelle, ordinati e scanditi come da:all. Come un tag, la cartella viene letta di nuovo a ogni risoluzione del selettore, quindi spostare file dentro o fuori cambia ciò che gli schermi in riproduzione mostrano dal loro prossimo ciclo.
Scrivere una playlist richiede che la cartella esista nel progetto; può essere vuota. Una cartella che non contiene alcun file pronto del primitivo, o che viene eliminata successivamente, non corrisponde a nulla. I lettori la ricevono come by:all; il server risolve la cartella.
PlaylistMediaSelectorByID — obbligatori: by, media_id
PlaylistMediaSelectorByIDs — obbligatori: by, media_ids
PlaylistMediaSelectorByTag — obbligatori: by
PlaylistPage — obbligatori: id, canvas, transition, advance, primitives
PlaylistPageAdd — obbligatori: page
PlaylistPageStructure — obbligatori: id
Una pagina persistente, e le due impostazioni pagina che una persona modifica. advance sostituisce l’advance della pagina quando presente e lo mantiene se omesso; una pagina slot pubblicitario non ne ha. visibility sostituisce la visibilità della pagina quando è un oggetto, la rimuove se null e la mantiene se omessa.
Un oggetto visibilità che imposta solo enabled true è un no-op e viene rifiutato: invia null per rimuovere le regole.
PlaylistPageV2 — obbligatori: none
PlaylistPageWrite — obbligatori: id, canvas, transition, advance, primitives
PlaylistPageWriteV2 — obbligatori: none
PlaylistPatch — obbligatori: none
I campi omessi sono preservati. Nome, pagine, audio e formato forniti sostituiscono quei valori di primo livello; audio o formato null li rimuove. Le pagine fornite sono controllate rispetto al formato memorizzato quando il formato è omesso, e un formato fornito rispetto alle pagine memorizzate quando le pagine sono omesse. Identità, revisione, commenti e timestamp non possono essere impostati qui.
I commenti hanno endpoint dedicati.
PlaylistPrimitive — obbligatori: none
PlaylistPrimitiveLocked — obbligatori: none
Una primitiva bloccata è contenuto fisso del marchio di un modello (logo, sfondo, layout, tema): solo il proprietario del progetto o un membro che può approvare la aggiunge, la rimuove, la sposta o la modifica, o ne toglie il blocco, e una playlist creata dal modello la mantiene bloccata. Se omessa, non è bloccata. Una primitiva bloccata non può leggere un campo.
Una modifica di chiunque altro è primitive_locked (403), oppure una revisione con Propose.
PlaylistPrimitiveWrite — obbligatori: none
PlaylistRect — obbligatori: x, y, width, height
PlaylistRegionFormat — obbligatori: region, orientation
Una fascia disegnata sopra la pagina lungo un bordo di un display: un header in alto, un footer in basso, un side sul bordo destro a tutta altezza. orientation è l'orientamento del display per cui è fatta, come lo vede lo spettatore dopo la rotazione.
Ogni pagina ha la stessa canvas (width e height); un header o un footer è più largo che alto e un side più alto che largo, con il lato lungo almeno il doppio di quello corto, altrimenti 400 invalid_request a pages[i].canvas.
La playlist contiene solo primitivi immagine e card (una pagina video, stream, iframe, application o ad slot viene rifiutata) e non ha colonna sonora (l'audio viene rifiutato); un primitivo non nomina alcun display.
Una playlist di regione non è mai il predefinito di uno schermo, il predefinito di una cartella né un takeover: viene riprodotta come voce di programmazione o come campagna con covers impostato sulla sua regione (covers main e full la rifiutano), e covers header, footer o side richiede una playlist di regione di quella regione.
La voce o la campagna viene rifiutata con 409 playlist_format_mismatch quando la fascia non è disposta su nessuno dei display di destinazione: una fascia è disposta su un display del suo orientamento, valutato sulla superficie riportata dal Player dopo la rotazione (la rotazione della parete dello schermo quando non ne ha riportata una), e solo se non coprirebbe più di metà del display (la sua altezza per un header o un footer, la sua larghezza per un side).
Una campagna viene rifiutata solo quando non è disposta su nessuno degli schermi del suo pubblico; su uno schermo di un pubblico misto in cui non lo è, la campagna esce dallo stack di quello schermo e la sua spiegazione riporta region_not_laid_out.
Un cambio di formato che sposta una playlist dentro o fuori da una regione, o verso un'altra regione, viene rifiutato con 409 resource_conflict finché la usano una programmazione di uno schermo, un takeover o un predefinito, il predefinito di una cartella o una campagna.
PlaylistResolvedMedia — obbligatori: media_id, intrinsic_size
PlaylistRevision — obbligatori: revision, created_at, change, name, page_count, current
One stored revision of a playlist. change says what made it: created (the first revision), edited (a replace, patch, structure change or applied review), promoted (a copy of an earlier revision, named by restored_from), or baseline (the revision the playlist held when its history began, before any write recorded one).
Un valore che questo lettore non conosce viene letto come edited.
PlaylistRevisionAuthor — obbligatori: type, name
Chi ha creato la revisione, come lo nomina il registro eventi del progetto; assente quando la scrittura non ha nominato nessuno (una baseline o un lavoro di sistema).
PlaylistRevisionDetail — obbligatori: revision, playlist
PlaylistRevisionList — obbligatori: items
PlaylistStarterWrite — obbligatori: starter
Aggiunge il modello integrato Avviso urgente (un titolo e un messaggio). Invia solo starter e, facoltativamente, name.
PlaylistStinger — obbligatori: none
Una carta stinger solo transizione (major 1). Tutti i membri sono opzionali; i valori predefiniti restano nel posizionamento di runtime sintetico. hang_ms predefinito è 1000 e al massimo il 60% della transizione duration_ms (verificato dal server). logo indica un’immagine pronta in questo progetto, usando il percorso di concessione media della carta.
PlaylistStreamPrimitive — obbligatori: id, primitive, sources, fallback_media_id, rect, layer, content_fit, muted, controller, resolved_media
PlaylistStreamPrimitiveWrite — obbligatori: id, primitive, sources, fallback_media_id, layer, content_fit
PlaylistStructurePatch — obbligatori: none
La struttura di una playlist e niente che una pagina mostra (patchPlaylistStructure). I membri omessi si mantengono. Un nome fornito sostituisce il nome. Le pagine fornite sono il nuovo ordine completo delle pagine della playlist: una pagina memorizzata omessa viene rimossa.
Contenuto pagina (tela, transizione, audio_cue, primitivi, commenti) e colonna sonora non possono essere inviati e sono sempre quelli memorizzati.
PlaylistTemplateField — obbligatori: name, label, type
Un valore che assume un modello. Le pagine lo leggono come {field.NAME}: nei params di una scheda (campi testo e indirizzo), come media_id del selettore di un'immagine o di un video (campo multimediale) o come src completo di un iframe (campo indirizzo).
PlaylistTemplateFields — obbligatori: none
Dichiarare dei campi rende la playlist un modello. Ogni segnaposto letto da una pagina deve indicare un campo dichiarato del tipo giusto e ogni campo deve essere letto; una playlist senza campi non legge segnaposto. Un modello non viene mai mostrato su uno schermo (playlist_is_template). Un PUT senza fields li mantiene; null o un array vuoto li rimuove.
PlaylistTransition — obbligatori: type, duration_ms
Transizione pagina. type e duration_ms sono entrambi obbligatori; OpenAPI non li imposta di default. Gli esempi di authoring swipe usano duration_ms 600; quel valore non è un default dello schema.
PlaylistV2 — obbligatori: id, name, revision, pages
PlaylistV2List — obbligatori: items
PlaylistValuesChange — obbligatori: values
PlaylistVideoPrimitive — obbligatori: id, primitive, selector, resolved_media, muted, loop, rect, layer, content_fit, controller
PlaylistVideoPrimitiveWrite — obbligatori: id, primitive, selector, layer, content_fit
PlaylistWallFormat — obbligatori: displays, arrangement, orientation
Il video wall per cui è creata una playlist: da 2 a 12 display, tile di 1920 x 1080 (orizzontale) o 1080 x 1920 (verticale), disposti in una riga, una colonna o una griglia. Una riga ha i display come colonne e una riga, una colonna ha una colonna e i display come righe, una griglia ha columns colonne e displays / columns righe.
Il display n si trova nella colonna (n - 1) mod columns e nella riga floor((n - 1) / columns): da sinistra a destra, poi dall’alto in basso.
La tela di c colonne e r righe di tile di larghezza w e altezza h è (c * w, r * h), per esempio 5760 x 1080 per 3 display orizzontali in fila, 1080 x 3840 per 2 display verticali in colonna e 7680 x 3240 per 12 display orizzontali in una griglia di 4 colonne.
La larghezza e altezza della tela di ogni pagina ordinaria devono corrispondere esattamente, altrimenti 400 invalid_request su pages[i].canvas. La scala della scheda in tale playlist è min(larghezza, altezza) della tessera / 1080 = 1.
Una playlist con un formato può legarsi solo a uno schermo la cui parete ha la stessa forma (displays = numero di uscite, disposizione, colonne, portrait se e solo se rotazione è 90 o 270), altrimenti 409 playlist_format_mismatch: assegnazione, assegnazione flotta, voci programmazione e takeover. Una playlist senza formato si lega a qualsiasi schermo.
PlaylistWarning — obbligatori: code, message, page_id, primitive_id
Qualcosa su cui l'autore di una scrittura riuscita dovrebbe intervenire. La scrittura ha memorizzato ciò che portava; un'avvertenza non la fa mai fallire. Una scrittura di playlist risponde con avvertenze sulla playlist; una scrittura su uno schermo (updateScreen, le route fields, location e playlist della dashboard) sullo schermo; un'assegnazione di flotta sulla pagina dei risultati.
Due codici. iframe_framing_refused: una pagina https pubblica indicata da una primitiva iframe (il suo src o il suo fallback_src) invia X-Frame-Options (DENY, SAMEORIGIN o l'obsoleto ALLOW-FROM) o un elenco frame-ancestors di Content-Security-Policy che non ammette l'origine dell'app web Player.
Il Player web e i Player macOS, Samsung Tizen, LG webOS e BrightSign inquadrano la pagina e non possono mostrarla; i Player Android, Linux e Windows aprono una pagina iframe intera e non sono interessati.
Il backend legge gli header di risposta dopo la conferma della scrittura, per un massimo di 8 pagine distinte per scrittura; una pagina non raggiungibile in tempo o che risponde con un errore non viene segnalata. Ogni pagina compare una volta, indicando la prima primitiva che la usa, e aggiunge un evento playlist.iframe_framing_refused (avviso) al registro del progetto.
Un src con token dello schermo non è una pagina singola e non viene letto. screen_fact_missing: uno schermo raggiunto dalla scrittura non ha un valore che il src di un iframe o i parametri di un'applicazione leggono tramite un token dello schermo ({screen.field.NAME}, {screen.location.…}, {screen.timezone}), oppure i valori che ha compongono qualcosa che il manifest rifiuta (un indirizzo di oltre 2048 caratteri, un segmento di percorso . o .., parametri di avvio oltre 4096 caratteri nell'URL di avvio), quindi la primitiva viene omessa dal manifest di quello schermo (diagnostica del manifest screen_fact_missing o screen_fact_invalid) finché lo schermo non ha il valore.
Un'avvertenza per scrittura nomina la prima primitiva di questo tipo, i token che nessuno schermo elencato ha potuto compilare (al massimo 64), i primi 20 schermi interessati e quanti sono.
Una scrittura di playlist (sostituzione, patch, modifica della struttura, promozione o revisione applicata) raggiunge gli schermi che mostrano la playlist; una scrittura su uno schermo raggiunge quello schermo, per la playlist che mostra e quella appena assegnata; un'assegnazione di flotta raggiunge gli schermi della sua pagina; approvare una modifica dello schermo raggiunge gli schermi che nomina.
PlaylistWrite — obbligatori: name, pages
PlaylistWriteV2 — obbligatori: name, pages
PrimitiveEnter — obbligatori: type
Oggetto enter opzionale. La scrittura della playlist e il manifest di runtime usano questo oggetto così com’è; non c’è rinomina snake_case interna. Assente significa pittura a riposo, opacità piena. Lo stagger intero opzionale da 0 a 8 ritarda l’avvio di stagger*120 ms dopo il ritardo condiviso di 500 ms. Assente o 0 è l’avvio odierno. La durata è una costante nominata in screenrig.canvas/v1.
PrimitiveMotion — obbligatori: none
Movimento oggetto persistente opzionale. La scrittura della playlist e il manifest di runtime usano questo oggetto così com’è; non c’è rinomina snake_case interna. Assente significa che il primitivo resta a riposo dopo enter.
Copiato senza interpolazione. spin e drift si applicano solo a immagine e video; app e iframe con spin o drift sono rifiutati dal server (motion_not_allowed_for_primitive). path si applica a immagine, video, app e iframe. Questa restrizione non è codificata come OpenAPI if/then.
PrimitiveMotionDrift — obbligatori: type, zoom, direction, speed
Scala lenta continua attorno al centro di clipRect combinata con una lenta traslazione. Solo immagine e video; il server rifiuta drift su app e iframe. Ping-pong; mai salti.
PrimitiveMotionPath — obbligatori: type, points, rate
Traslazione lungo una polilinea di waypoint in unità tela dopo il rettangolo authoring. loop predefinito a loop se omesso. Valido su immagine, video, applicazione e iframe.
PrimitiveMotionPoint — obbligatori: x, y
PrimitiveMotionSpin — obbligatori: type, direction, speed
Rotazione continua attorno al centro di clipRect. Solo immagine e video; il server rifiuta spin su app e iframe.
Problem — obbligatori: errors, instance, request_id
Il documento problema a cui risponde ogni route tranne quelle di runtime, contenuto e probe rivolte al Player (RuntimeProblem). L’errore stesso è errors[0]: il suo status, codice, tipo, titolo, dettaglio e suggerimento. Solo i membri del documento restano al livello superiore. Ramifica su errors[0].code, mai su dettaglio o suggerimento, che sono prosa.
Un campo richiesta imputato aggiunge errors[0].field; ogni altro campo imputato è una voce propria con il dettaglio di quel campo.
ProblemError — obbligatori: status, code, type, title, detail, hint
Un errore di un documento problema. I membri oltre questi descrivono ulteriormente questo errore (per esempio dipendenze da not_ready).
ProblemField — obbligatori: field, code, detail
Project — obbligatori: id, revision, status, email, used_bytes, reserved_bytes, screen_count, content_limit_bytes, screen_limit, credit_remaining, created_at, updated_at, name
ProjectBillingUsage — obbligatorio: period, usage, stored_bytes, allowance
ProjectCapabilities — obbligatori: project_id, plan_id, features, feature_revision, capabilities, media_video_bytes, plan_features, limits
ProjectContext — obbligatori: project, organization
ProjectContextList — obbligatori: projects
ProjectCreate — obbligatori: name
ProjectDeleteConfirmation — obbligatori: name, revision
ProjectDeletionPreview — obbligatori: project, organization, devices, allowed
ProjectFeatures — obbligatori: advertiser, screens
ProjectMove — obbligatori: organization_id
ProjectMoveDestinations — obbligatori: organizations
ProjectName — obbligatori: none
Nome progetto stampabile e rifilato. Rifiuta controlli, testo simile a URL, @, www. e ://.
ProjectOwnerTransfer — obbligatori: user_id
ProjectPatch — obbligatori: name
ProjectPlanFeature — obbligatori: id, enabled, required_plan
ProjectPlanFeatures — obbligatori: featuresets, features
Le funzioni del piano che il progetto possiede. Le decidono il piano e i featureset del progetto; il credito non ne sblocca mai nessuna. Una funzionalità che il progetto non ha viene rifiutata con feature_not_in_plan (402), il cui required_plan indica il piano venduto in generale più basso che la include.
ProjectPlanLimits — obbligatori: screens, members, video_bytes, event_retention_days
I limiti del progetto come li stabiliscono il suo piano e i suoi featureset, le cifre che l’ammissione applica. Zero significa nessun tetto del piano.
ProjectUptime — obbligatori: items
ProvisionScreen — obbligatori: none
RTSPStreamSource — obbligatori: protocol, url
ReadyResponse — obbligatori: status, degraded
ReleaseLaunch — obbligatori: launch_url, expires_at
Report — obbligatori: kind, title, generated_at, columns, rows, truncated
Un report come tabella: columns dice cos'è ogni membro di una riga. Le righe portano più membri di quanti ne mostrino le colonne (id, parent_id e depth per la struttura delle cartelle). Le colonne di percentuale vanno da 0 a 100.
ReportCatalog — obbligatori: items, formats
ReportColumn — obbligatori: key, label, type
ReportKindInfo — obbligatori: kind, title, description, params
ReportParam — obbligatori: name, description
ReportSchedule — obbligatori: cadence
ReportSubscription — obbligatori: id, name, kind, filters, schedule, format, enabled, recipients, revision, created_at, updated_at
ReportSubscriptionList — obbligatori: items
ReportSubscriptionPatch — obbligatori: none
ReportSubscriptionRecipient — obbligatori: user_id
ReportSubscriptionWrite — obbligatori: name, kind, schedule, format, recipients
Reseller — obbligatori: id, name, spread_bps, spread_effective_at, customer_count, review_state, customer_limit
ResellerCustomer — obbligatori: organization_id, name, plan_id, delegated_at, project_count, screen_count, stored_bytes, annual_list_cents, annual_wholesale_cents
ResellerCustomerPage — obbligatori: items, next_cursor
ResellerCustomerProject — obbligatori: id, name, status, screen_count, member
ResellerCustomerProjectPage — obbligatori: projects, next_cursor
ResellerEnrollment — obbligatori: organization_id
ResellerList — obbligatori: items
ResellerStatement — obbligatori: reseller_id, name, period, spread_bps, lines, usage_list_mcr, usage_wholesale_mcr, plan_annual_list_cents, plan_annual_wholesale_cents
ResellerStatementLine — obbligatori: organization_id, name, plan_id, delegated_from, project_count, screen_count, stored_bytes, api_events, usage_list_mcr, usage_wholesale_mcr, plan_annual_list_cents, plan_annual_wholesale_cents
ResellerSummary — obbligatori: id, name
Review — obbligatori: id, kind, state, subject, proposer, url, created_at, updated_at, impact
ReviewAdCreative — obbligatori: creative_id, creative_revision, content_path
ReviewApproveRequest — obbligatori: none
ReviewBlocker — obbligatori: id, state, subject
ReviewChangesRequest — obbligatori: note
ReviewDecider — obbligatori: none
ReviewDecisionResult — obbligatori: review
ReviewDependentResult — obbligatori: id, state
ReviewImpact — obbligatori: screens
ReviewList — obbligatori: items, next_cursor, pending_count
ReviewLocation — obbligatori: project_id, project_name
ReviewMediaChange — obbligatori: media_id, filename, before, after
La modifica in sospeso di un elemento multimediale che una revisione selector_refresh chiede.
ReviewMediaFields — obbligatori: tags, folder_id
ReviewMediaFile — obbligatori: sha256, bytes, content_type
ReviewMediaPlaylist — obbligatori: id, name, screens, media_added, media_removed
ReviewMediaReplace — obbligatori: media_id, filename, source, version, before, after, aspect_changed, playlists
La sostituzione del file di un elemento multimediale su cui verte una revisione media_replace. Il media mantiene il suo file fino all’approvazione.
ReviewPageEdit — obbligatori: op, page_id
ReviewPending — obbligatori: status, review
Una scrittura di tipo revisione con accesso Proponi, o una scrittura che raggiunge uno schermo protetto a qualsiasi livello di accesso. La modifica non è sullo schermo finché una persona non approva la revisione; una protetta viene decisa da un secondo approvatore (docs/screen-scope.md).
ReviewPerson — obbligatori: user_id, name
ReviewPlaylistChange — obbligatori: operation, base_revision, proposed, diff
ReviewPlaylistDiff — obbligatori: name_changed, pages_added, pages_removed, pages_changed, soundtrack_changed, media_added, media_removed
ReviewPolicy — obbligatori: agent_changes_require_review, review_policy_revision
ReviewPolicyUpdate — obbligatori: agent_changes_require_review
ReviewPreview — obbligatori: live, proposed
Playlist attive e proposte nella forma memorizzata restituita da GET /api/playlists/{id} (pagine con resolved_media).
ReviewProposer — obbligatori: kind
ReviewProtectedCampaign — obbligatori: none
Un campaign_create, campaign_update o campaign_delete.
ReviewProtectedChange — obbligatori: subkind
L’input memorizzato di una revisione protected_change, applicato tramite il servizio proprietario quando un secondo approvatore approva. È presente esattamente uno tra campaign, folder e move, come indica subkind. L’approvazione viene riapplicata a base_revision; una campagna o una cartella che nel frattempo è cambiata rende la revisione obsoleta (review_stale).
ReviewProtectedFolder — obbligatori: none
Un folder_create, folder_update, folder_delete o folder_unprotect.
ReviewProtectedMove — obbligatori: folder_id, screen_ids, folder_ids
Uno screens_move, il corpo di POST /api/screens/move.
ReviewRejectRequest — obbligatori: reason
ReviewScreenChange — obbligatori: action, screens, request, playlist_ids
ReviewSubject — obbligatori: type, id, name
ReviewSummary — obbligatori: id, kind, state, url, subject, impact
RuntimeAdslotCandidate — obbligatori: page_id, occurrence_id, check_sequence, earliest_start_at
RuntimeAdslotEvent — obbligatori: event_id, decision_id, occurrence_id, kind, client_sequence
RuntimeAdslotEventBatch — obbligatori: events
RuntimeAdslotEventResponse — obbligatori: results
RuntimeAdslotEventResult — obbligatori: event_id, state
RuntimeAdslotMedia — obbligatori: kind, duration_ms, content_type, bytes, sha256, content_path, fit
RuntimeAdslotPage — obbligatori: id, type, adslot_id
Slot pubblicitario a pagina intera, inviato solo a una sessione associata con adslot-v1. Un Player che incontra un tipo di pagina sconosciuto scarta quella pagina.
RuntimeAdslotResolveRequest — obbligatori: manifest_revision, candidates
RuntimeAdslotResolveResponse — obbligatori: server_time, results
RuntimeAdslotResult — obbligatori: occurrence_id, check_sequence, state
RuntimeAdvance — obbligatori: mode
RuntimeApplicationPackage — obbligatori: version, url, bytes, sha256, entrypoint, contentType
Pacchetto normalizzato immutabile costruito solo dall’albero applicativo validato indipendentemente. I lettori nativi verificano byte e SHA-256 prima di conservare atomica questa release per il ripristino offline dell’ultimo stato noto valido. L’URL è un riferimento di trasporto vincolato all’autorizzazione, non un URL pubblico o duraturo dell’oggetto.
RuntimeApplicationPrimitive — obbligatori: id, primitive, applicationId, releaseId, launchUrl, origin, protocol, grantId, package, rect, layer, contentFit
RuntimeAudio — obbligatori: loop, volume, tracks
Colonna sonora della playlist (docs/playlist-audio.md). Emette solo quando la playlist ne ha una e almeno una traccia è proiettata. Il lettore riproduce le tracce in ordine, indipendentemente dal sequenziatore di pagina; i cambi pagina, le transizioni e la visibilità non mettono mai in pausa o riavviano la riproduzione.
L’identità della traccia è id più mediaId più sha256, mai src, quindi un aggiornamento del manifesto che mantiene la traccia in riproduzione non la riavvia. Il guadagno effettivo è volume per volume del lettore. Una traccia difettosa viene scartata da sola (invalid_audio_track).
RuntimeAudioCue — obbligatori: track, restart
Suggerimento di colonna sonora emesso su una pagina che ha generato audio_cue. Quando la pagina diventa corrente: se una traccia diversa sta suonando, o nessuna, passa alla traccia dall'inizio; se la traccia sta suonando, riavviala solo se restart è true. La sequenza continua dalla traccia. Un suggerimento può essere ignorato. Un cue che non nomina alcuna traccia del manifesto viene scartato (invalid_audio_cue).
RuntimeAudioTrack — obbligatori: id, mediaId, src, sha256, bytes, contentType, durationMs, grantId
RuntimeCanvas — obbligatori: width, height, viewportFit, background
RuntimeCardPrimitive — obbligatori: id, primitive, card, major, params, rect, layer, contentFit
Una scheda integrata. Per un Player che dichiara capacità CardML, il backend seleziona la revisione pubblicata più recente compatibile all’interno del major bloccato, considerando revisioni trattenute e tutte le funzionalità richieste; quando nessuna è idonea omette la scheda con diagnostica card_unavailable e rimuove pagine vuote.
Il lettore unisce i valori predefiniti della scheda, poi i parametri, poi, quando presenti, le proprietà dinamiche del documento a GET /screen/card-data/{data} (solo le chiavi che la scheda indica come dinamiche).
Una scheda con dati resta nascosta fino all’arrivo del suo primo documento e poi sfuma in trasparenza; screen.card_data_changed per la chiave la recupera di nuovo in loco. feed, quando presente, è recuperato dalla stessa rotta e passato alla scheda come suo feed. Un Player che non ha la scheda o il suo major non disegna nulla per essa.
Una stringa in params o nel documento dati che inizia con media: è un riferimento a contenuti multimediali, media:<id>, che il Player risolve in byte che possiede prima che la scheda li disegni, e lascia vuoto quando non può; non passa mai un URL da params o dati a una scheda. media elenca i nomi dei parametri delle immagini pronte, con i descrittori che un primitivo immagine resolvedMedia porta, così il Player li scarica e verifica all’arrivo del manifesto; un riferimento a media scomparso dopo la pubblicazione è assente e la scheda disegna il fallback.
I contenuti multimediali indicati da un documento dati provengono da /media/{media_id} quando il documento arriva (ETag è lo sha256). I contenuti multimediali delle card non bloccano mai una pagina. Il backend ha già espanso per questo schermo i token {screen.name}, {screen.timezone}, {screen.field.NAME} e {screen.location} di un posizionamento, quindi params e data contengono i suoi valori.
RuntimeChrome — obbligatori: schema_version, banner
Chrome di proprietà runtime (docs/player-compatibility.md §8). I lettori leggono i membri che conoscono e ignorano gli altri; una forma banner che un lettore non capisce non mostra banner.
RuntimeCodecs — obbligatori: none
Elenco codec RFC 6381 derivato dal server per questa esatta versione, mai dichiarato dal client. È un fratello di contentType; un Player può formare una query di capacità come contentType seguito da codecs="VALORE". Un video il cui codec non può essere derivato è rifiutato al caricamento. La proprietà è opzionale. Un valore assente non significa che il codec non sia supportato.
Un valore presente contiene attualmente una voce video-track; la grammatica consente voci separate da virgola.
RuntimeCommandResultWrite — obbligatori: state
Il corpo di POST /screen/commands/{command_id}/result. I membri sconosciuti vengono ignorati (docs/player-compatibility.md §1.1).
RuntimeConditionReport — obbligatori: severity, code, context
RuntimeDisplay — obbligatori: none
Il controllo del display dello schermo, valutato sul dispositivo (docs/player-compatibility.md §6.5): la programmazione di alimentazione e l’override, l’impostazione di oscuramento per inattività e la modalità di luminosità. Omesso quando lo schermo non ne ha; in tal caso il display resta acceso alla luminosità dell’operatore. I membri sconosciuti sono ignorati.
RuntimeHealthWrite — obbligatori: none
Il corpo PUT /screen/health. Ogni membro è opzionale; invia ciò che la piattaforma può misurare. Membri sconosciuti sono ignorati e valori fuori intervallo scartati (non rifiutati). Gli interi sono numeri JSON interi.
RuntimeHostHint — obbligatori: platform
L’indicazione opzionale del dispositivo nativo all’avvio dell’associazione, al completamento dell’associazione e alla creazione della sessione di identità. Nomina un dispositivo e non è mai autorizzazione.
Viene letto con tolleranza (docs/player-compatibility.md §1.1.1): membri sconosciuti sono ignorati, un campo o voce capabilities malformati sono scartati, si mantengono al massimo 32 capabilities, e un valore che non è un oggetto o una piattaforma fuori dal pattern scarta l’intero hint. Nessuno di questi rifiuta la richiesta.
Un Player invia ancora solo i valori piattaforma registrati e i membri sotto, perché un backend pre-contratto rifiuta altro.
RuntimeHostHintDevice — obbligatori: none
Identificatori hardware opzionali nell’host nativo hint. Un campo malformato viene scartato.
RuntimeIframeCookie — obbligatori: name, value, domain, path, secure, httpOnly, sameSite
Un cookie di una scheda condivisa nel formato dell’API dei cookie del browser. Il valore è segreto.
RuntimeIframePrimitive — obbligatori: id, primitive, src, title, rect, layer, contentFit
RuntimeImagePrimitive — obbligatori: id, primitive, selector, resolvedMedia, grantId, rect, layer, contentFit
RuntimeImageResolvedMedia — obbligatori: mediaId, src, intrinsicSize, sha256, bytes, contentType
RuntimeIntrinsicSize — obbligatori: width, height
RuntimeKVEntry — obbligatori: application_id, key, value_base64, content_type, bytes, sha256, revision
RuntimeKVList — obbligatori: items
RuntimeKVSummary — obbligatori: application_id, key, content_type, bytes, sha256, revision
RuntimeKVWrite — obbligatori: value_base64
RuntimeKiosk — obbligatorio: lock
Il blocco kiosk (docs/player-compatibility.md §6.5). Emesso a ogni sessione finché kiosk.lock dello schermo è attivo e omesso altrimenti. Un Player che può bloccarsi da solo sullo schermo lo fa finché lock è true e rilascia il blocco quando il membro è assente o lock è false; uno che non può lo ignora. I membri sconosciuti sono ignorati.
RuntimeLiveHeartbeat — obbligatori: connection
Il report del Player stesso. Schema aperto.
RuntimeLiveHeartbeatAnswer — obbligatori: lease_until, max_until
RuntimeLiveJoin — obbligatori: live_id, ice_servers, lease_until, max_until, heartbeat_ms, video
A cosa pubblica un Player e entro quali limiti. Schema aperto.
RuntimeLiveJoinRequest — obbligatori: none
Vuoto. Il corpo può essere omesso.
RuntimeLiveOffer — obbligatori: sdp
Una descrizione di sessione senza il suo tipo, come l’offerta del Player e la risposta del relay.
RuntimeLiveStopped — obbligatori: reason
RuntimeManifest — obbligatori: schemaVersion, manifestRevision, grantId, contentGeneration, screenId, screenLabel, playlistRevision, generatedAt, pages
Manifest runtime immutabile che usa il canvas screenrig.canvas/v1 deterministico, rettangolo, adattamento e contratto ordine sorgente. Sono permesse proprietà aggiuntive lato lettura così un lettore su questo contratto ignora chiavi sconosciute (regola di compatibilità 2). Gli schemi di scrittura restano chiusi.
Le pagine sono pagine tela ordinarie e, per una sessione associata con adslot-v1 concessa, pagine adslot a tutta pagina; un manifesto senza pagina adslot è contenuto house.
RuntimeManifestDiagnostic — obbligatori: level, code, detail
Una omissione di proiezione runtime fail-safe. I Player e la CLI possono mostrarle; non sono mai autorizzazioni.
RuntimeMediaSelector — obbligatori: none
RuntimeMediaSelectorByAll — obbligatori: by, oneAtATime
RuntimeMediaSelectorByID — obbligatori: by, mediaId, oneAtATime
RuntimeMediaSelectorByIDs — obbligatori: by, mediaIds, oneAtATime
RuntimeMediaSelectorByTag — obbligatori: by, oneAtATime
RuntimeObservationSurfaceWrite — obbligatori: id, width, height, pixel_ratio, presentation
RuntimeObservationWrite — obbligatori: observed_at, surfaces
Il corpo PUT /screen/observation. Membri sconosciuti sono ignorati (docs/player-compatibility.md §1.1). Il valore memorizzato è ScreenObservation del progetto.
RuntimeOrigins — obbligatori: content
La delivered origin allowlist (docs/player-compatibility.md §2.3). Presente solo su risposta mint per Player con origini granted origins-v1.
Il lettore unisce i contenuti con le origini di contenuto compilate e ignora voci non valide. release_suffix sostituisce il suffisso di release compilato solo se è un suffisso DNS valido di almeno due etichette; è assente quando l’origine runtime serve le release direttamente (sviluppo locale).
Il set delivered non cambia mai l’origine della credenziale, e il backend non mette mai un URL su un’origine che questa sessione mint non ha consegnato. Un Player memorizza l’oggetto validato last-known-good, così una sessione successiva senza origini mantiene valido quel LKG.
RuntimePage — obbligatori: contractVersion, id, canvas, transition, advance, primitives
RuntimePairingScreen — obbligatori: id, public_id, label, state, revision, manifest_revision, content_access_generation, created_at, updated_at
Riepilogo schermo di proprietà runtime nelle associazioni e completamenti di provisioning browser. Il suo set di membri è congelato: i campi progetto Schermo non appaiono mai qui (docs/player-compatibility.md §8). lo stato rimane tra i tre valori seguenti.
RuntimePrimitive — obbligatori: none
RuntimeProblem — obbligatori: type, title, status, detail, instance, code, request_id, errors
Il documento problema delle route rivolte al Player per schermo (/screen/) e media (/media/), gli stream di associazione e le route probe (/.ready, /.health): ogni membro piatto al livello superiore. I Player rilasciati dallo store leggono il suo codice e azione di primo livello (docs/player-compatibility.md §5), quindi questa forma resta com’è; ogni altra route risponde con Problem.
RuntimeRect — obbligatori: x, y, width, height
RuntimeReport — obbligatori: none
I corpi e i contesti dei report si leggono in modo tollerante (docs/player-compatibility.md §1.1). Un codice necessita dei propri membri di contesto; altri membri sono ignorati. I Player inviano ancora solo i membri sottostanti, perché un backend pre-contratto rifiuta ogni altro.
RuntimeScreenLabel — obbligatori: screen_label
Il nome schermo memorizzato, il valore che il manifesto porta come screen_label.
RuntimeScreenLabelWrite — obbligatori: screen_label
Il corpo PUT /screen/screen-label. Il server elimina gli spazi iniziali e finali da screen_label e memorizza da 1 a 120 caratteri senza caratteri di controllo. Membri sconosciuti sono ignorati (docs/player-compatibility.md §1.1).
RuntimeScreenPlaylist — obbligatori: playlist_id
La playlist assegnata allo schermo dopo la modifica.
RuntimeScreenPlaylistWrite — obbligatori: playlist_id
Il corpo PUT /screen/playlist. Membri sconosciuti sono ignorati (docs/player-compatibility.md §1.1).
RuntimeScreenPlaylists — obbligatori: playlists, more
Le playlist che il selettore on-device di uno schermo offre, in ordine alfabetico per nome senza distinzione tra maiuscole e minuscole, poi per id.
RuntimeSelectorPlaylistSnapshot — obbligatori: selections, pageMaxMs
Le selezioni di una playlist dello stack, indicate dagli ID di pagina propri di quella playlist.
RuntimeSelectorSnapshot — obbligatori: manifestRevision, snapshotRevision, selections, pageMaxMs
RuntimeSession — obbligatori: paired, capabilities, event_cursor, public_url
Sessione di proprietà runtime (docs/player-compatibility.md §8). I lettori ignorano membri e valori di capacità sconosciuti. Un nuovo membro è inviato solo alle sessioni le cui concessioni lo coprono.
RuntimeSessionRequest — obbligatori: public_id
Mint visualizzatore anonimo. Membri sconosciuti sono ignorati (docs/player-compatibility.md §1.1).
RuntimeStack — obbligatori: levels, playlists
Ogni livello dello stack dello schermo, inviato solo a un Player che ha dichiarato la capacità host schedule.stack e solo quando lo stack ha più di un livello (docs/player-compatibility.md §6.11). I membri radice del manifesto sono la playlist del livello più basso; il Player risolve da sé i livelli con il contratto di programmazione.
RuntimeStackPlaylist — obbligatori: playlistRevision, pages
RuntimeStatusWrite — obbligatori: observed_at, chip
Il corpo PUT /screen/status. Membri sconosciuti sono ignorati (docs/player-compatibility.md §1.1). Il valore memorizzato è ScreenStatus del progetto.
RuntimeStorageWrite — obbligatori: observed_at, volume, cache, durability, plan, transfer_24h
Il corpo PUT /screen/storage. Membri sconosciuti sono ignorati (docs/player-compatibility.md §1.1). Il valore memorizzato è ScreenStorage del progetto più received_at del server.
RuntimeStreamPrimitive — obbligatori: id, primitive, sources, muted, fallback, grantId, rect, layer, contentFit
RuntimeSuspension — obbligatori: message, since
Emesso mentre lo schermo è sospeso (docs/player-compatibility.md §6.9): pages è [] senza diagnostics, e un Player mostra message come avviso a schermo intero al posto della schermata senza contenuti. since indica quando lo schermo è stato sospeso per la prima volta. La revisione del manifesto è quella propria dell’avviso, mai quella di una playlist, e lo schermo non richiede una playlist assegnata.
RuntimeTelemetryBatch — obbligatori: telemetry_epoch, stream_id, sequence, created_at, reports
Una coda Player FIFO durevole invia al massimo un batch ordinario al minuto con una fase randomizzata, o prima se piena. Il corpo JSON totale è al massimo 256 KiB; al massimo 64 report, ciascuno al massimo 32 KiB. Ogni report conserva il timestamp di occorrenza e play_id stabile.
Mantieni un batch immutabile in volo su disco fino a 202, incrementa la sequenza solo dopo l’accettazione e riprova gli stessi byte dopo risposte perse o riavvii. La sequenza parte da 1 e non ha interruzioni.
Dedupe mantiene al massimo otto stream live per schermo, ogni watermark per almeno le 24 ore in cui il suo batch può ancora essere riprodotto; mantenere lo stesso stream durante il rinnovo delle credenziali. I record scadono localmente dopo 24 ore con contabilità esplicita. manifest.activated e manifest.upgrade restano individuali e immediati.
Scritture interattive, risoluzione annunci, recupero contenuti, screenshot e SDK emitConfirmed() restano immediati. Il campionamento salute mantiene la cadenza di quindici minuti; transizioni urgenti display/salute sono inviate immediatamente. Osservazioni e snapshot salute ordinarie sono latest-wins con tempi di occorrenza originali. Salute richiede health.write.
I report individuali esistenti restano accettati. I limiti abuso item report si applicano per nuovo item, non per pacchetto HTTP; la riproduzione impegnata consuma solo ammissione richiesta.
RuntimeTransition — obbligatori: type, durationMs
Transizione pagina creata. Le mosse semplici mantengono tipo, durata e decorazioni opzionali. Lo stinger porta la forma normale del contenuto della scheda sopra entrambi i livelli. Codice mancante o interprete Player incompatibile degrada solo la transizione in dissolvenza incrociata della stessa durata, con diagnostica transition_unavailable.
RuntimeTransitionCard — obbligatori: primitive, card, major, params, version, src, sha256, model, requires
Lo stesso contenuto card proiettato come card canvas, senza geometria di posizionamento canvas. Lo stinger è fissato alla major 1; params include durationMs e hangMs.
RuntimeUpgradeNotice — obbligatori: state, player_kind, recommended
Presente in una risposta mint quando la versione comparabile del lettore è inferiore alla versione raccomandata per player_kind (docs/player-compatibility.md §6.1). Il lettore avvia un controllo di aggiornamento piattaforma e non mostra nulla sullo schermo. Un lettore ignora il membro per uno stato che non conosce.
RuntimeVerbosity — obbligatori: none
Il livello di log e il livello di toast più bassi che il Player genera e mostra (docs/player-compatibility.md §6.12). Emesso a ogni sessione quando lo schermo ne imposta uno dei due; ogni membro è omesso quando non è impostato. Gli errori vengono sempre generati e mostrati. Un Player ignora un membro o un valore sconosciuto e mantiene il suo valore predefinito.
RuntimeVideoPrimitive — obbligatori: id, primitive, selector, resolvedMedia, muted, loop, grantId, rect, layer, contentFit
RuntimeVideoResolvedMedia — obbligatori: mediaId, src, intrinsicSize, sha256, bytes, contentType
RuntimeWall — obbligatori: outputs, arrangement, rotation, span
Il video wall dello schermo come disposto dal suo lettore (docs/player-compatibility.md §6.8). Emesso solo se lo schermo ha un wall. Membri sconosciuti sono ignorati.
SCIMError — obbligatori: schemas, status
Il documento di errore RFC 7644 sezione 3.12.
SCIMEvent — obbligatori: at, action, status
SCIMEventList — obbligatori: events
SCIMGroupList — obbligatori: groups
SCIMGroupProjectBinding — obbligatori: binding_id, project_id, project_name, role
SCIMGroupSummary — obbligatori: id, display_name, member_count, bindings
SCIMResource — obbligatori: none
Un documento SCIM 2.0 nella forma che RFC 7643 e RFC 7644 gli danno sulla rotta che lo trasporta; ogni operazione indica quale sia. È una risorsa User o Group, una ListResponse, un messaggio PatchOp, un ServiceProviderConfig, un ResourceType o uno Schema. I membri che screenRIG non usa sono accettati e ignorati.
SCIMSettings — obbligatori: enabled, base_url, tokens, user_count, group_count
SCIMSettingsWrite — obbligatori: enabled, proof
SCIMToken — obbligatori: id, name, prefix, created_at
SCIMTokenCreate — obbligatori: name, proof
SCIMTokenCreated — obbligatori: id, name, prefix, created_at, token
Un SCIMToken con il suo segreto, restituito una sola volta.
SSODiscovery — obbligatori: sso, required, account
Come l’indirizzo accede o si registra. sso, required e provider_name dipendono solo dal dominio dell’indirizzo; account indica se una persona attiva possiede l’indirizzo.
SSODiscoveryRequest — obbligatori: email
SSOErrorCode — obbligatori: none
Il codice stabile con cui termina un accesso single sign-on quando non si completa: il valore di #sso_error= nell’indirizzo a cui reindirizza POST /api/sso/finish e il codice di un test non riuscito del provider di identità. no_email: il provider non ha asserito alcun indirizzo email. email_unverified: il provider ha contrassegnato l’indirizzo come non verificato. domain_not_allowed: l’indirizzo non appartiene a uno dei domini verificati dell’organizzazione. account_exists: l’indirizzo appartiene già a un account con un proprio accesso; la persona accede come prima e collega l’identità dal proprio account (intent link). managed_elsewhere: un’altra organizzazione gestisce la persona. subject_mismatch: l’account è collegato a un’identità diversa presso lo stesso provider. not_provisioned: nessuno possiede l’indirizzo e la connessione non crea persone. sso_required: l’organizzazione richiede il single sign-on per l’indirizzo. staff_account: un account staff screenRIG non viene mai fatto accedere, adottato o collegato dal provider di identità di un cliente. expired: l’accesso ha superato i suoi 10 minuti. bad_state: lo state dell’accesso o il legame con il browser non corrisponde, oppure è già stato usato. interaction_required: un rinnovo silenzioso richiede la persona. provider_refused: il provider ha risposto con un errore. provider_unavailable: il provider non è raggiungibile o leggibile. verification_failed: il token o l’assertion del provider non ha superato la verifica. deactivated: la persona è disattivata.
SSOPolicy — obbligatori: required, break_glass_user_ids, passkey_admin_ids, policy_revision
SSOPolicyWrite — obbligatori: required, break_glass_user_ids, proof
SSOStart — obbligatori: redirect_url
SSOStartRequest — obbligatori: email
SSOTestStart — obbligatori: redirect_url
ScheduleCalendar — obbligatori: subject, from, to, screens, groups
ScheduleCalendarConflict — obbligatori: kind, level_ids
ScheduleCalendarGroup — obbligatori: key, screens, screen_ids, displays, levels, spans, on_screen, conflicts
ScheduleCalendarOnScreen — obbligatori: display, from, to
ScheduleCalendarSpan — obbligatori: level_id, from, to, state
ScheduleImportCommitted — obbligatori: preview, applied
ScheduleImportLevel — obbligatori: key, action, home, content, screens, priority, rows
ScheduleImportPreview — obbligatori: name, columns, valid, fingerprint, summary, rows, levels, removals
ScheduleImportRemoval — obbligatori: home
ScheduleImportRequest — obbligatori: rows
ScheduleImportResolved — obbligatori: kind, id, name
ScheduleImportRow — obbligatori: row, status
ScheduleImportRowError — obbligatori: code, message
ScheduleImportSummary — obbligatori: rows, rows_with_errors, levels, creates, updates, unchanged, removes, screens, playlists
SchedulePreview — obbligatori: gained, lost, calendar
Che cosa cambierebbe una scrittura di campagna o di programmazione. gained sono gli schermi che porterebbero un livello della scrittura che ora non portano, lost quelli che ne portano uno che non porterebbero più; un livello che resta su uno stack non cambia nessuno dei due e compare in calendar.
SchedulePreviewReach — obbligatori: count, screen_ids
Screen — obbligatori: id, public_id, label, revision, manifest_revision, manifest_upgrade, content_access_generation, state, online, created_at, updated_at
ScreenAction — obbligatori: none
Una azione di flotta, discriminata per tipo. Ogni membro porta solo i propri parametri; un membro di altro tipo è un campo sconosciuto e invalid_request.
ScreenActionAddTags — obbligatori: type, tags
Aggiunge tag che uno schermo non ha già. Uno schermo che supererebbe 16 tag fallisce con invalid_request.
ScreenActionAssign — obbligatori: type, playlist_id
ScreenActionClearDisplaySchedule — obbligatori: type
Rimuove la programmazione display di ogni schermo; uno schermo senza programmazione è ok e resta invariato.
ScreenActionClearPlaylist — obbligatori: type
Rimuove la playlist predefinita propria di ogni schermo, mantenendo l'abbinamento e gli altri livelli di contenuto. Senza contenuto effettivo il Player mostra la schermata di attesa. Di classe revisione, come l'assegnazione.
ScreenActionClearPlaylistSchedule — obbligatori: type
Rimuove la programmazione playlist di ogni schermo; uno schermo senza programmazione è ok e resta invariato.
ScreenActionClearRebootSchedule — obbligatori: type
Rimuove la programmazione dei riavvii di ogni schermo; uno schermo senza programmazione è ok e resta invariato. Solo accesso Gestisci.
ScreenActionDisplay — obbligatori: type, power
Stesse regole di ScreenDisplayWrite. until viene controllato rispetto all’orologio della richiesta quando Idempotency-Key non ha record di flotta, e di nuovo da ogni schermo.
ScreenActionDisplayClear — obbligatori: type
Termina l’override manuale del display di ogni schermo (DELETE /api/screens/{id}/display); uno schermo senza override è ok e resta invariato.
ScreenActionMaintenance — obbligatori: type
POST /api/screens/{id}/clear-cache, /restart-app o /update per schermo; uno schermo il cui host non ha dichiarato la capacità fallisce da solo con command_unsupported. Uno schermo offline mantiene il comando queued finché torna online (expires_in_s).
ScreenActionReboot — obbligatori: type
POST /api/screens/{id}/reboot per schermo; uno schermo il cui host non ha dichiarato reboot fallisce da solo con reboot_unsupported. Uno schermo offline tiene il riavvio in coda finché non torna online (expires_in_s).
ScreenActionReload — obbligatori: type
POST /api/screens/{id}/reload per schermo. Uno schermo offline tiene la ricarica in coda finché non torna online (expires_in_s).
ScreenActionRemoveTags — obbligatori: type, tags
Rimuove i tag elencati; un tag non presente sullo schermo è ignorato.
ScreenActionRequest — obbligatori: selector, action
ScreenActionResult — obbligatori: action, matched, succeeded, failed, results
ScreenActionScreenResult — obbligatori: screen_id, status
Esito di un singolo schermo. ok riporta il risultato del percorso del singolo schermo: revision (e tags per le azioni sui tag) per le azioni assign, tag, takeover, takeover_clear, set_playlist_schedule, clear_playlist_schedule, set_reboot_schedule e clear_reboot_schedule, reload per reload, toast per toast. failed riporta il problema che avrebbe restituito la richiesta di quello schermo da sola.
ScreenActionSelector — obbligatori: none
ScreenActionSelectorFolder — obbligatori: by, folder_id
Ogni schermo attivo nella cartella schermi e in ogni cartella al suo interno, in ordine di creazione. Non c’è limite al numero di schermi.
ScreenActionSelectorIds — obbligatori: by, screen_ids
ScreenActionSelectorTag — obbligatori: by, tag
Ogni schermo attivo i cui tag contengono tag, in ordine di creazione. Non c’è limite al numero di schermi.
ScreenActionSetDisplaySchedule — obbligatori: type, enabled, windows
Sostituisce la programmazione display di ogni schermo (ScreenDisplayScheduleWrite), normalizzata una volta prima della distribuzione. Uno schermo senza fuso orario fallisce da solo con invalid_request.
ScreenActionSetPlaylistSchedule — obbligatori: type, entries
Sostituisce la programmazione playlist di ogni schermo con le stesse voci (ScreenPlaylistScheduleWrite). Gli ID delle voci sono assegnati una volta prima della distribuzione. Uno schermo senza fuso orario o senza playlist predefinita fallisce da solo con invalid_request.
ScreenActionSetRebootSchedule — obbligatori: type, enabled, windows
Sostituisce la programmazione dei riavvii di ogni schermo (ScreenRebootScheduleWrite), normalizzata una volta prima della distribuzione. Solo accesso Gestisci. Uno schermo senza fuso orario fallisce da solo con invalid_request, e uno il cui Player non ha dichiarato reboot con reboot_unsupported.
ScreenActionSetTags — obbligatori: type, tags
Sostituisce il set di tag di ogni schermo; un array vuoto lo cancella.
ScreenActionTakeover — obbligatori: type, playlist_id
Stesse regole di ScreenTakeoverWrite. until viene controllato rispetto all’orologio della richiesta prima della distribuzione quando Idempotency-Key non ha record di flotta, e di nuovo da ogni schermo.
ScreenActionTakeoverClear — obbligatori: type
Termina il takeover di ogni schermo; uno schermo senza takeover è ok e resta invariato.
ScreenActionToast — obbligatori: type, level, text
Stesse regole di livello, testo e durata di ScreenToastWrite, validate una volta prima della distribuzione.
ScreenCampaigns — obbligatori: screen_id, items
ScreenCommand — obbligatori: id, type, state, requested_at, expires_at
Un riavvio, una ricarica, un clear_cache, un restart_app o un update richiesti a uno schermo, in Screen.commands. Un comando inviato a uno schermo online è memorizzato come sent.
Uno richiesto a uno schermo offline è memorizzato come queued senza evento runtime; il backend aggiunge l’evento, con questo id e expires_at, quando applica la successiva transizione online dello schermo prima di expires_at, e il comando diventa sent.
Ogni comando ha esattamente un evento runtime, quindi un Player non può vederlo due volte. expired viene derivato in lettura per un comando in coda oltre expires_at. Un comando più recente dello stesso tipo sostituisce uno ancora in coda. Un riavvio inviato diventa done quando un rapporto di salute con uptime_s colloca l’avvio dopo sent_at; una ricarica non raggiunge mai done.
Un clear_cache, restart_app o update diventa done o failed quando il suo Player lo segnala, con causa e dettaglio.
ScreenCommandPage — obbligatori: items, next_cursor
ScreenCommandWrite — obbligatori: none
Il corpo opzionale di POST /api/screens/{id}/reboot, /reload, /clear-cache, /restart-app e /update. Un corpo vuoto mantiene il valore predefinito.
ScreenDeviceSettingsPatch — obbligatori: none
Una modifica delle impostazioni di oscuramento per inattività e di luminosità di uno schermo e del suo blocco kiosk (patchScreenDeviceSettings). Il corpo nomina almeno uno dei due membri e nessun altro.
ScreenDisplay — obbligatori: requested, source
Stato alimentazione display. requested è ciò che lo schermo dovrebbe mostrare ora: l’override attivo, altrimenti la programmazione display abilitata valutata nel fuso orario dello schermo, altrimenti on (source override, schedule o default); until è quando cambia la prossima volta, se noto. reported è il display dell’ultimo report di salute del Player (power, connected, reported_at, stale dopo 35 minuti). idle e brightness sono le impostazioni display.idle e display.brightness dello schermo (impostate da ScreenPatch).
Assente quando lo schermo non ha programmazione, nessun override, nessuna impostazione di inattività o di luminosità e nessun display segnalato.
ScreenDisplayBrightness — obbligatori: mode
display.brightness: auto associa la luce ambientale del dispositivo alla luminosità della finestra; fixed (il valore predefinito) mantiene la luminosità dell’operatore. Applicato da un Player che dichiara la capacità dell’host brightness.auto, che dichiara solo quando il dispositivo ha un sensore di luce.
ScreenDisplayIdle — obbligatori: after_s, wake
display.idle: il display si oscura dopo after_s secondi senza un tocco, un tasto o, quando wake elenca presence, qualcuno davanti allo schermo (la fotocamera del dispositivo, analizzata sul dispositivo; nessuna immagine ne esce). Un evento di riattivazione lo riaccende subito, e il tocco che riattiva un display oscurato viene assorbito.
Mentre il display è oscurato il Player si trova in uno stato di display spento, come per una programmazione del display: sospende la riproduzione (nessuna riproduzione, nessun annuncio), segnala display.power off nel suo report di salute e riprende alla riattivazione. Una programmazione del display o un override che tiene spento il pannello ha la precedenza, e un’applicazione che tiene device.display prevale sull’inattività finché la sua pagina è sullo schermo.
Applicato da un Player che dichiara la capacità dell’host display_power.idle.
ScreenDisplayOverride — obbligatori: override_id, power, until, ends_at, set_at
ScreenDisplayPatch — obbligatori: none
ScreenDisplayReported — obbligatori: reported_at, stale
L’ultimo report di stato del display del Player. Alimentazione e connettività osservate, indipendenti dall’alimentazione richiesta. stale è true dopo 35 minuti senza report; è contesto, non la prova che l’alimentazione abbia causato un errore di cattura.
ScreenDisplaySchedule — obbligatori: enabled, windows, updated_at
ScreenDisplayScheduleView — obbligatori: display_schedule
ScreenDisplayScheduleWrite — obbligatori: enabled, windows
ScreenDisplayWrite — obbligatori: power
ScreenEffectivePlaylist — obbligatori: id, source
La playlist da cui è costruito il manifesto di runtime dello schermo: il takeover, altrimenti la prima campagna che si applica (entry_id è l’id della campagna), altrimenti la prima voce di programmazione playlist corrispondente (entry_id), altrimenti la playlist predefinita assegnata, altrimenti la playlist predefinita della cartella più vicina che contiene lo schermo (source folder, entry_id è l’id della cartella). until è l’istante successivo in cui si sa che cambia (fine del takeover o il prossimo limite di programmazione entro otto giorni), assente quando nulla di temporale lo modifica.
Il worker di confine applica una modifica al massimo con 60 secondi di ritardo. Un takeover o voce la cui playlist non può essere mostrata viene saltata. Assente quando lo schermo non mostra playlist.
ScreenExplainAt — obbligatori: instant, effective_playlist, verdicts, not_judged
Ciò che lo schermo mostra a instant e perché, secondo il risolutore eseguito dalla scansione dei limiti. Il takeover, il programma playlist dello schermo e le campagne del progetto sono letti come sono ora, non come erano allora. Una campagna la cui playlist manca o non è approvata viene saltata, come la salta la scansione.
Su uno schermo il cui Player risolve il proprio stack (schedule.stack), i verdetti leggono quello stack e not_judged lo indica (player_stack).
ScreenFieldsPatch — obbligatorio: fields
Una modifica dei campi di uno schermo (patchScreenFields). Il corpo non ha altri membri.
ScreenFolder — obbligatori: id, name, parent_id, revision, created_at, updated_at
Una cartella schermi. Uno schermo si trova al massimo in una cartella (Screen.folder_id); una cartella ha come destinazione i suoi schermi e quelli di ogni cartella al suo interno.
ScreenFolderCreate — obbligatori: name
ScreenFolderDeleteResult — obbligatori: levels
ScreenFolderList — obbligatori: items
ScreenFolderPatch — obbligatori: none
ScreenGlass — obbligatori: none
Ciò che il backend ha concluso sull’immagine dello schermo dai rapporti ricevuti, mai da ciò che il Player dice di sé. Un controllo che non ha nulla da dire lascia assente il suo membro. In sola lettura nell’API del progetto. Mai un’autorizzazione né un’ammissione. ScreenPatch non può scriverlo.
ScreenGlassChangedDetails — obbligatori: check, verdict, previous, since, evidence
Oggetto details di un evento screen.glass_changed durevole, solo di progetto, aggiunto quando un controllo dell’immagine cambia il suo verdetto per uno schermo. Non è un comando di audience di runtime e non viene consegnato su GET /screen/events.
La condizione loop_stalled si apre con un verdetto di riproduzione stalled e termina con qualsiasi altro; glass_blank e glass_frozen si aprono con un verdetto di immagine blank o frozen e terminano con qualsiasi altro.
ScreenHealth — obbligatori: reported_at, stale
L’ultimo rapporto di salute del dispositivo (PUT /screen/health), sanificato, con reported_at del server. Un membro che il lettore non ha inviato è assente. stale è true quando reported_at ha più di 35 minuti; la salute stale è ancora mostrata, mai eliminata; archivio e recupero schermo la cancellano.
Le transizioni aggiungono screen.health_changed solo nel progetto con details.changes, un elenco di {change, ...}: display_disconnected, display_reconnected, display_power (from, to), temperature_high (a o sopra 80 °C), temperature_normal (di nuovo sotto 75 °C), on_battery (battery.source è diventato none; level_percent quando segnalato) e plugged_in (di nuovo qualsiasi altra fonte; source), crash_spike e renderer_restart_spike (il conteggio sulle 24 ore è aumentato di 3 o più dall’ultimo evento spike; crashes_24h o renderer_restarts_24h e previous). battery è presente solo quando il dispositivo ne segnala una; il backend non legge nulla da essa tranne battery.source per la condizione on_battery e non deduce alcuna causa.
Sola lettura; mai autorizzazione.
ScreenHealthHistory — obbligatori: none
Una pagina di report (risoluzione raw) o riepiloghi orari (risoluzione hour).
ScreenHealthHour — obbligatori: hour, reports, temperature_max_c, temperature_avg_c, cpu_load_max, memory_used_ratio_max, wifi_rssi_min_dbm, display_disconnected, crashes_24h_max, renderer_restarts_24h_max, last_reported_at
Report di uno schermo in un’ora UTC. Un membro è null quando nessun report dell’ora lo contiene.
ScreenHealthHours — obbligatori: resolution, hours, next_cursor
ScreenHealthSample — obbligatori: reported_at
Un report di salute dispositivo memorizzato: Screen.health senza stale, e senza cpu.utilization_percent e cpu.app_percent, che solo l’ultimo report (Screen.health) contiene. Un membro non inviato dal Player è assente.
ScreenHealthSamples — obbligatori: resolution, samples, next_cursor
ScreenIdentifyAccepted — obbligatori: identify_id, duration_ms, expires_at
ScreenIdentifyDetails — obbligatori: identify_id, label, screen_id, duration_ms, at, expires_at
oggetto details su evento durevole player.identify.
ScreenIdentifyWrite — obbligatori: none
ScreenKiosk — obbligatorio: lock
kiosk.lock: il Player si blocca da solo sullo schermo (blocco su schermo di Android con startLockTask; la persona presente allo schermo conferma la prima volta, e barra di stato, home e recenti sono bloccate finché resta bloccato; la variante managed come proprietario del dispositivo mantiene il suo lock task). Presente solo mentre il blocco è attivo.
Il pannello delle impostazioni dell’operatore offre Esci dal blocco kiosk, che rilascia il blocco finché il manifest successivo o un riavvio non lo applica di nuovo. Applicato da un Player che dichiara la capacità dell’host kiosk_lock.
ScreenKioskPatch — obbligatorio: lock
ScreenLevelChange — obbligatori: source, id, playlist_id, screens
ScreenLevelChanges — obbligatori: gained, lost
Cosa fa una scrittura alle programmazioni degli schermi che modifica: le campagne il cui pubblico raggiungono (gained) o lasciano (lost) e le playlist predefinite di cartella che iniziano o smettono di essere la loro predefinita. screens conta gli schermi interessati per livello.
Su una scrittura di tag, una voce di campagna riporta l’appartenenza al pubblico: ogni campagna live che gli schermi raggiungono o lasciano, che venga riprodotta lì o no, il che dipende dalla playlist predefinita dello schermo. Uno spostamento o una modifica di cartella elenca le campagne il cui pubblico di cartella si sposta sugli schermi che le riproducono.
ScreenLink — obbligatori: hint, created_at
Un URL Player che apre uno schermo in un browser che non conserva dati, come una sorgente browser di vMix o OBS.
ScreenLinkSessionRequest — obbligatori: screen_link
Il segreto del link dello schermo più i suggerimenti facoltativi host, playback e player. I membri sconosciuti sono ignorati, e host, playback e player sono letti con tolleranza (docs/player-compatibility.md §1.1). Il segreto è una credenziale: non viene mai registrato nei log né restituito.
ScreenLinkSummary — obbligatori: hint, created_at
Il link dello schermo, senza il suo url. Presente solo finché lo schermo ha un link. Sola lettura; POST e DELETE /api/screens/{id}/link lo modificano.
ScreenList — obbligatori: items
ScreenLocation — obbligatori: latitude, longitude
La posizione di uno schermo, in gradi decimali, con un nome breve del luogo facoltativo e un indirizzo stradale. Il posizionamento di una card la legge tramite il token {screen.location}, e l'elenco degli schermi filtra per distanza da un punto (near).
ScreenLocationPatch — obbligatorio: location
Una modifica della posizione di uno schermo (patchScreenLocation). Il corpo non ha altri membri.
ScreenMaintenanceAccepted — obbligatori: command_id, command, expires_at, state
ScreenManifestUpgrade — obbligatori: desired_revision, active_revision, desired_playlist, active_playlist, state, code, attempt, retry_at, missing_page_count, state_since, reported_at
Stato sempre presente calcolato di manifest-upgrade per questo schermo, derivato al momento della lettura dalla sua revisione desiderata emessa o dall’obiettivo di contenuto playlist condivisa in coda, dalla sua ultima revisione manifest attiva riconosciuta dal server (manifest.activated) e dall’ultimo slot di report manifest.upgrade accettato.
Stato del progetto in sola lettura: nessun corpo può scriverlo e nessun rapporto promuove mai una concessione. active_revision è l’ultima attivazione riconosciuta, non la prova che ogni sessione simultanea la mostri già.
Essere offline non produce mai un errore, e un retry_at scaduto in stato di ritentativo è presentazione client, mai giudizio server. desired_revision null è nessuno. stato pending indica una revisione desiderata senza report corrispondente; activating indica un target già sullo schermo il cui riconoscimento è ancora in sospeso; uno slot report la cui revisione ha smesso di corrispondere a desired_revision è ignorato finché un nuovo report non corrisponde, quindi un nuovo manifesto desiderato deriva pending senza cancellare nulla.
Prima che il prossimo contatto del manifesto emetta la concessione desiderata di una modifica condivisa, la revisione desiderata e la playlist possono esporre quell’obiettivo in coda come intenzione di sola lettura; non concede accesso. L’identità attiva proviene sempre dalla concessione storica esatta riconosciuta. Un’attivazione più vecchia non può annunciare l’obiettivo in coda più recente come corrente.
ScreenMove — obbligatori: folder_id
Almeno un id tra screen_ids e folder_ids, massimo 1000 in totale.
ScreenMoveResult — obbligatori: screens, folders, levels
ScreenNamePatch — obbligatori: name
Il nuovo nome di uno schermo (patchScreenName). Il corpo non ha altri membri.
ScreenNotJudged — obbligatori: code, detail
Qualcosa che la spiegazione non giudica.
ScreenObservation — obbligatori: observed_at, surfaces
Superficie di riproduzione segnalata dal lettore. Assente sullo schermo fino al primo PUT /screen/observation. accettato. Sola lettura sull’API del progetto; ScreenPatch, PairScreen, corpi di associazione, corpi di sessione, canvas, manifest di runtime e POST /screen/reports non possono scriverlo.
ScreenObservationSurface — obbligatori: id, width, height, pixel_ratio, presentation
ScreenOutage — obbligatori: offline_since
L’ultima interruzione di presenza dello schermo e, quando il primo report di salute dopo il ritorno la decide, perché lo schermo era sparito. Una nuova interruzione la sostituisce; uno schermo che non è mai stato offline da quando le interruzioni vengono registrate non ne ha.
La causa deriva dai contatori di uptime del Player in quel report, letti rispetto all’interruzione e mai rispetto all’orologio del dispositivo: device_restart (il dispositivo è partito dopo l’inizio dell’interruzione), app_crash (il Player è partito e il suo conteggio di arresti anomali nelle 24 ore è aumentato), app_restart (è partito il Player e non il dispositivo), network (nessuno dei due è partito e nulla indica screenRIG) e platform (nessuno dei due è partito, e un report player.stream_down è arrivato a screenRIG durante l’interruzione, oppure l’osservatore di presenza era fermo o in ripresa quando lo schermo è rimasto in silenzio). likely_cause è assente quando è sconosciuta e resta sconosciuta anziché tirare a indovinare: un report senza uptime, uno troppo vicino all’inizio dell’interruzione, un riavvio avvenuto dopo il ritorno dello schermo e un report del Player entro un minuto dalla riconnessione non decidono nulla.
Un report decide solo entro 35 minuti dal ritorno dello schermo. device_restart non distingue un’interruzione di corrente da un riavvio, e network non distingue la rete propria dello schermo da quella a monte.
La decisione aggiunge una sola volta l’evento solo del progetto screen.outage_classified, con i dettagli {offline_since, back_at, likely_cause, evidence, online_event_id}; la notifica di risoluzione di uno schermo offline indica la causa quando è stata stabilita entro l’invio dell’avviso. I lettori trattano come sconosciuto un likely_cause che non conoscono. Sola lettura; mai un’autorizzazione.
ScreenPatch — obbligatori: none
ScreenPlayPageAccepted — obbligatori: screen_id, playlist_id, page_id, manifest_revision, expires_at
ScreenPlayPageDetails — obbligatori: page_id, playlist_id, manifest_revision, expires_at
oggetto dettagli su evento duraturo player.play_page.
ScreenPlayPageWrite — obbligatori: page_id
ScreenPlayerIdentity — obbligatori: legacy, seen_at
Identità accertata dall’ultima sessione runtime associata. Metadati display solo lettura, mai autorizzazione. Concessioni interne e campi mint sono riservati.
ScreenPlaylistPatch — obbligatori: playlist_id
Un’assegnazione della playlist di uno schermo (patchScreenPlaylist). Il corpo non ha altri membri.
ScreenPlaylistSchedule — obbligatori: entries, updated_at
Programmazione playlist valutata dal server. Non raggiunge mai il manifesto di runtime; il manifesto è costruito dalla playlist effettiva selezionata. Scrivila con PUT /api/screens/{id}/playlist-schedule.
ScreenPlaylistScheduleView — obbligatori: entries
ScreenPlaylistScheduleWrite — obbligatori: entries
ScreenPresenceHistory — obbligatori: items, next_cursor
ScreenPresenceTransition — obbligatori: at, state
ScreenProvisioning — obbligatori: screen, public_url, provisioning_url, expires_at
ScreenRebootAccepted — obbligatori: reboot_id, expires_at, state
ScreenRebootSchedule — obbligatori: enabled, windows, updated_at
Le finestre in cui il backend riavvia lo schermo. Presente finché ne è impostata una.
ScreenRebootScheduleView — obbligatori: reboot_schedule, next_reboot_at
ScreenRebootScheduleWrite — obbligatori: enabled, windows
ScreenRecoveryHost — obbligatori: none
Cosa dice il dispositivo che chiede di recuperare questo schermo, copiato dall’oggetto host dell’avvio associazione. Solo campi descrittivi; non contiene mai duid, seriale o mac. I campi assenti non sono stati segnalati.
ScreenRecoveryPending — obbligatori: expires_at
Presente mentre una sessione di associazione nativa che ha presentato l’identità hardware di questo schermo attende la conferma del progetto proprietario con POST /api/screens/{id}/recovery/confirm. Contiene la scadenza, che è la scadenza della sessione di associazione stessa, e i campi host descrittivi del dispositivo offerente (mai duid, seriale o mac).
Un DUID è leggibile da qualsiasi applicazione sul monitor, quindi un’offerta è una superficie di phishing: confronta host.model e host.firmware con il monitor davanti a te prima di confermare.
Il server rifiuta un’offerta mentre la chiave associata allo schermo ha mostrato attività negli ultimi dieci minuti (session mint, runtime stream, manifest fetch o presenza heartbeat), e accetta al massimo tre offerte per schermo per ora mobile; una nuova offerta sostituisce quella in sospeso. Assente una volta confermata, scaduta o reclamata come nuovo schermo. Sola lettura.
ScreenReloadAccepted — obbligatori: reload_id, expires_at, state
ScreenReplaceWrite — obbligatori: with
ScreenScheduleEntry — obbligatori: id, playlist_id
ScreenScheduleEntryWrite — obbligatori: playlist_id
Una voce di programmazione playlist, un livello dello stack proprio dello schermo (packages/schedule-contract SEMANTICS.md, Levels and the stack). id è facoltativo (entry_N viene assegnato in ordine se omesso) e univoco nella programmazione.
È in vigore finché lo sono tutti i suoi membri della regola: from (incluso) e until (escluso), limiti civili con precisione al minuto e senza offset; un’occorrenza di windows, monthly o dates (se nessuno dei tre è presente ricorre ogni giorno) la cui data non è in except; data, una condizione card-data; interaction, mentre qualcuno sta usando lo schermo.
Una voce imposta almeno un membro della regola. data, interaction, covers e un blocco displays che lascia fuori alcune uscite sono rispettati da un Player che risolve il proprio stack; la risoluzione del server per gli altri Player salta una voce simile (stack_only).
ScreenSchedulePreviewRequest — obbligatori: entries
ScreenScheduleRevision — obbligatori: revision, created_at, change, current, entries
Una revisione memorizzata della programmazione playlist di uno schermo: l’intero elenco entries dopo una scrittura (nessuna entries: lo schermo non aveva programmazione). revision è la revisione dello schermo al momento della scrittura. change è edited, restored (una copia di una revisione precedente, indicata da restored_from) o baseline (la programmazione che lo schermo aveva quando è iniziata la sua cronologia).
ScreenScheduleRevisionList — obbligatori: items
ScreenScheduleWindow — obbligatori: days
Una finestra screenrig.schedule/v1 nel fuso orario dello schermo. I giorni sono memorizzati da lunedì a domenica. Ometti start e end per l’intera giornata. end <= start attraversa la mezzanotte e il giorno di inizio la possiede (ven 22:00-02:00 arriva al mattino di sabato); bordi uguali coprono 24 ore complete.
ScreenScope — obbligatori: folder_ids, screen_ids
Su che cosa può agire un membro o un agente con ambito (docs/screen-scope.md): gli schermi nelle cartelle di schermi elencate e in ogni cartella al loro interno, e gli schermi elencati. Almeno un id in tutto. Un id che al momento della scrittura non indica alcuna cartella o schermo live del progetto è invalid_request nella sua posizione; un’eliminazione successiva lascia un id morto, che non concede nulla.
L’ambito viene letto a ogni richiesta, quindi una modifica si applica alla successiva. I tag non sono mai ambito.
ScreenScreenshotAccepted — obbligatori: capture_id, expires_at
ScreenScreenshotFailedDetails — obbligatori: capture_id, reason
oggetto dettagli su evento duraturo screen.screenshot_failed.
ScreenScreenshotReadyDetails — obbligatori: capture_id, bytes, width, height, sha256
oggetto dettagli su evento duraturo screen.screenshot_ready. Pixel e chiavi oggetto non presenti.
ScreenScreenshotRequestedDetails — obbligatori: capture_id, expires_at, max_width_divisor, max_height_divisor, format, quality, max_bytes
oggetto dettagli su evento duraturo screen.screenshot_requested. Byte immagine e chiavi oggetto non presenti.
ScreenScreenshotStatus — obbligatori: state
ScreenStackStatus — obbligatori: manifest_revision, levels, playing, reported_at
Ciò che il Player dello schermo ha riportato da ultimo sul suo stack (docs/player-compatibility.md §6.11): la disponibilità di ogni livello e il livello mostrato da ogni display in ogni regione (la pagina ed eventuali fasce). Presente solo per un Player che risolve il proprio stack, finché quello stack è aggiornato.
ScreenStatus — obbligatori: chip, observed_at, received_at
Il chip di stato che il Player dello schermo ha segnalato per ultimo con PUT /screen/status (docs/player-compatibility.md §9.5): la condizione screenrig.overlay/v1 che prevale per rango, o null quando il Player non mostra alcun chip. Assente fino al primo report accettato. Cancellato al reset dell’identità, alla disassociazione e all’archiviazione.
È l’ultimo report del Player, quindi i consumatori lo considerano obsoleto quando lo schermo non è online (Screen.online), come ogni report del Player. level e icon provengono dal catalogo del backend per chip, mai dal Player, e sono assenti quando chip è null. Sola lettura sull’API del progetto. Mai autorizzazione o ammissione. ScreenPatch non può scriverlo.
ScreenStatusChangedDetails — obbligatori: chip
oggetto dettagli di un evento durevole screen.status_changed solo del progetto, aggiunto quando PUT /screen/status modifica il chip, il level o l’icon memorizzato. level e icon sono assenti quando chip è null. Questo tipo non è un comando runtime audience e non viene consegnato su GET /screen/events.
ScreenStorage — obbligatori: observed_at, received_at, volume, cache, durability, plan, transfer_24h
Rapporto di archiviazione lettore sanificato. Assente fino al primo PUT /screen/storage. accettato. Cancellato al reset dell’identità, disassociazione e archiviazione. I consumatori considerano received_at più vecchi di 24 ore come obsoleti. Sola lettura sull’API del progetto. Mai autorizzazione o ammissione. ScreenPatch non può scriverlo.
ScreenStorageCache — obbligatori: house_used_bytes, capacity_bytes, reserve_bytes, protected_bytes, fallback_bytes, warm_bytes, ad_headroom_bytes
ScreenStorageExcludedPage — obbligatori: page_id, reason
ScreenStorageForecast — obbligatori: manifest_revision, fit, excluded_page_count, basis, received_at
Selezione approssimativa dello stato stazionario target (solo piano A.3, nessuna transizione) dall’ultima capacità segnalata e dal manifesto desiderato dello schermo. Assente senza un report di archiviazione, che i consumatori leggono come sconosciuto. base è reported_capacity. Ricalcolato quando arriva un report di archiviazione e quando cambia la revisione del manifesto dello schermo. Mai autorizzazione o ammissione.
ScreenStorageForecastDryRun — obbligatori: fit, excluded_page_count, required_bytes, capacity_bytes, basis, received_at
Simulazione di adattamento pre-assegnazione per una playlist. fit, excluded_page_count e required_bytes provengono dal piano A.3 selezione target contro l’ultima capacità segnalata dello schermo (base reported_capacity); non c’è previsione di transizione e nulla è trattato come locale. required_bytes è il costo trattenuto di ogni pagina della playlist. fit sconosciuto significa che lo schermo non ha un report di archiviazione, o i riferimenti ai contenuti della playlist non sono pronti; required_bytes, capacity_bytes e received_at sono nulli allora. received_at è il tempo di ricezione del report di archiviazione, e un report più vecchio di 24 ore è obsoleto ma ancora usato per la previsione, esattamente come Screen.storage_forecast.
È metadato di sola lettura e mai autorizzazione o ammissione.
ScreenStorageForecastRequest — obbligatori: playlist_id
Corpo della simulazione di pre-assegnazione. playlist_id deve essere una playlist del progetto autenticato; quella di un altro progetto o un id sconosciuto è not_found.
ScreenStoragePlan — obbligatori: manifest_revision, fit, transition, required_bytes, target_bytes, excluded_pages
ScreenStorageShortfall — obbligatori: at, fit, required_bytes, capacity_bytes, excluded_page_count
Presente mentre l’adattamento segnalato del lettore è parziale, transition_blocked o none_fit, tranne un piano transition_blocked il cui unico motivo di blocco è anchor_unavailable: quello è un download fallito su un dispositivo con spazio, non una carenza. at è quando la condizione è iniziata.
Viene impostato una volta all’inizio della condizione e rimosso alla fine, ogni transizione aggiunge un evento solo progetto, screen.storage_shortfall o screen.storage_shortfall_cleared. Quegli eventi non sono consegnati su GET /screen/events. Cancellato con Screen.storage al reset identità, disassociazione e archivio.
Metadati di salute del progetto in sola lettura; non modifica la revisione dello schermo o l’autorità del manifesto e non è mai autorizzazione.
ScreenStorageTransfer — obbligatori: new, refetch, repair, failed
ScreenStorageVolume — obbligatori: total_bytes, available_bytes
ScreenSurfaceChangedDetails — obbligatori: observed_at, surfaces
oggetto dettagli su evento duraturo screen.surface_changed progetto. Pixel non presenti. Questo tipo non è un comando runtime audience e non viene consegnato su GET /screen/events.
ScreenSuspendWrite — obbligatori: message
ScreenSuspension — obbligatori: message, since
Presente mentre lo schermo è sospeso (docs/player-compatibility.md §6.9). Il manifesto runtime porta lo stesso oggetto nel suo membro suspension.
ScreenTags — obbligatori: none
Tag selettore flotta, da 0 a 16 tag unici esatti, ciascuno conforme alla grammatica dei tag media. Su ScreenPatch l’array sostituisce l’intero set e un array vuoto lo cancella; un tag duplicato o malformato è invalid_request. Cambiare i tag aggiorna la revisione dello schermo (protetta da If-Match) e aggiunge screen.updated con details.tags; non modifica mai la revisione del manifesto.
I tag non sono mai nel manifesto di runtime e mai nell’autorizzazione.
ScreenTagsPatch — obbligatori: tags
Un set completo di nuovi tag per uno schermo (patchScreenTags). L’array sostituisce ogni tag che lo schermo porta e un array vuoto li cancella. Il corpo non ha altri membri.
ScreenTakeover — obbligatori: playlist_id, until, set_at
La playlist che prevale su campagne, programmazione e assegnazione fino a until, oppure finché non viene rimossa se until è null.
ScreenTakeoverWrite — obbligatori: playlist_id
ScreenTimelineSegment — obbligatori: from, to, source
ScreenToastAccepted — obbligatori: expires_at
ScreenToastDetails — obbligatori: level, text, duration_ms, expires_at
oggetto dettagli su evento duraturo screen.toast. Colori non presenti.
ScreenToastWrite — obbligatori: level, text
ScreenUptime — obbligatori: items
ScreenVerbosityPatch — obbligatori: none
Una modifica del livello di log e del livello di toast di uno schermo (patchScreenVerbosity). Il corpo indica almeno uno dei due membri e nessun altro.
ScreenVerdict — obbligatori: kind, playlist_id, verdict
Un candidato all’istante spiegato. won: il risolutore lo sceglie (su uno schermo il cui Player risolve il proprio stack: riempie la sua regione su un display di destinazione). outranked: è in vigore, e by è il candidato che ha vinto. not_started: prima del suo from. ended: al suo until o dopo (un takeover: la sua fine). outside_hours: tra from e until, fuori dalle sue finestre. conditional: su uno schermo il cui Player risolve il proprio stack, è valido in base all’orario e viene riprodotto finché è soddisfatta anche la condizione osservata solo dal Player (reason interaction o data). off: non si applica, e reason dice perché.
ScreenWall — obbligatori: outputs, arrangement
Il video wall che il Player di uno schermo dispone: da due a dodici uscite che mostrano una tela. Per impostarlo serve un Player che abbia dichiarato la capacità display.wall host (docs/player-compatibility.md §6.5, §6.8). Lo copre una playlist con un formato.
ScreenshotCaptureID — obbligatori: none
Prefisso opzionale stage_, qa_ o development_, poi shot_ e un suffisso casuale. I nuovi suffissi usano 16 caratteri alfanumerici escludendo oOlL; i suffissi legacy mantenuti sono accettati.
SelectorPreview — obbligatori: primitive, selector, matched_count, candidates
SelectorPreviewInput — obbligatori: primitive, selector
SelectorPreviewMedia — obbligatori: media_id, filename, tags
ServiceClient — obbligatori: id, project_id, name, capabilities, access, state, created_by, keys, secrets, created_at, updated_at, authenticated_requests, tokens_issued
ServiceClientChange — obbligatori: none
ServiceClientKey — obbligatori: kid, alg, thumbprint, jwk, added_at
ServiceClientList — obbligatori: items
ServiceClientResult — obbligatori: client
ServiceClientSecret — obbligatori: id, hint, added_at
SessionDescription — obbligatori: type, sdp
SessionSSOStartRequest — obbligatori: intent
SignInPolicy — obbligatori: password, passkey, passkey_enrollment_required, policy_revision, federated
Politica di accesso persona verificata. Le impostazioni passive preservano l’accesso locale. Una politica organizzativa applicata indirizza l’accesso tramite il suo provider di identità.
SignInResetAccepted — obbligatori: status
Identico per indirizzi noti e sconosciuti; nessun indirizzo, credenziale, progetto o stato di consegna viene restituito.
SignInResetRequest — obbligatori: email
SignupCreated — obbligatori: user_id, project_id, organization_id
SignupHeardDetail — obbligatori: none
Il seguito di heard. kind indica una scelta da un breve elenco, e text è testo libero.
SignupPasskeyOptionsRequest — obbligatori: email, display_name
SignupProfile — obbligatori: none
Le risposte che una persona dà dopo la registrazione. Ogni membro è opzionale e può essere null, cioè senza risposta o saltato.
SignupRequest — obbligatori: email, display_name, marketing_email, credential
L’indirizzo email e il nome visualizzato sono quelli con cui è stata avviata la cerimonia.
Source — obbligatori: id, name, kind, target, enabled, config, preset, settings, secrets, refresh_seconds, stale_after_seconds, revision, status, created_at, updated_at
SourceArea — obbligatori: key, name, rooms, status, screens
SourceCreate — obbligatori: name, target
La configurazione di JSON, CSV e Sheets può impostare key_template, una chiave dei dati della scheda con token {screen.field.NAME}. La mappatura produce quindi {documents:[{fields:{NAME:VALUE},document:{...}}]} anziché un solo documento. Ogni risultato viene convalidato rispetto alla scheda di destinazione.
Le chiavi sono univoche ed esterne agli spazi dei nomi delle istanze di scheda e dei feed; source test mostra un’anteprima della struttura e convalida ogni risultato. Ogni chiave usa il periodo di validità della fonte. Le chiavi mancanti conservano dati e scadenza; gli errori di archiviazione possono lasciare scritture parziali e l’esecuzione successiva riprova.
SourceError — obbligatori: code, message, at
SourceKind — obbligatori: none
Da dove provengono i dati. ics legge indirizzi iCalendar e webcal:// (gli altri tipi sono descritti in /docs/sources). Un tipo non disponibile risponde invalid_request su kind.
SourceList — obbligatori: items, next_cursor
SourcePreset — obbligatori: name, title, category, description, kind, cards, fields, secrets, refresh_seconds, min_refresh_seconds, stale_after_seconds, attribution, docs
Una configurazione pronta e testata dell’origine dati json.
SourcePresetAttribution — obbligatori: text
SourcePresetCard — obbligatori: type, default
SourcePresetField — obbligatori: name, label, type, required, help
Un’informazione che una persona fornisce a un preset. Un testo viene controllato con pattern e max_length, una scelta è una tra options, e un elenco contiene da min_items a max_items oggetti compilati con fields.
SourcePresetList — obbligatori: items
SourcePresetOption — obbligatori: value, label
SourcePresetSecret — obbligatori: name, label, help, how_to_get, required
Una credenziale di cui un preset ha bisogno, inserita sotto name in secrets.
SourceRoom — obbligatori: key, status, screens
SourceRoomRef — obbligatori: id, name
SourceRoomScreen — obbligatori: id, name, kind, field, value, status
SourceRooms — obbligatori: source_id, room_field, room_key_prefix, area_field, area_key_prefix, rooms_as_of, summary, rooms, areas, screens, warnings
La mappatura delle sale di una fonte di dati che scrive un documento per ogni sala o area: le sale che la fonte offriva all’ultimo aggiornamento riuscito rispetto agli schermi che le leggono.
Uno schermo appartiene al rapporto di un campo quando ha un valore per esso, o quando la sua playlist colloca una scheda la cui chiave dati è il prefisso di chiave seguito da {screen.field.NAME}; una playlist raggiunta tramite una cartella, una campagna o un livello di pianificazione non viene seguita.
SourceRoomsSummary — obbligatori: rooms, unmapped_rooms, areas, unmapped_areas, screens, missing_screens, unknown_screens
SourceSecretView — obbligatori: set, hint, updated_at
SourceStaleAfter — obbligatori: none
Per quanto tempo la scheda conserva gli ultimi dati validi della fonte quando non riesce ad aggiornarsi, in secondi.
La fonte scrive i suoi documenti in modo che scadano così a lungo dopo l’ultimo aggiornamento riuscito: se continua a fallire, si svuotano su ogni schermo (anche offline) e le pagine la cui visibilità dipende dai dati passano alle pagine successive; una fonte che non fallisce rinnova la scadenza a ogni aggiornamento.
Almeno il doppio di refresh_seconds. null conserva gli ultimi dati validi fino al prossimo aggiornamento della fonte (il valore predefinito di ogni tipo tranne momentus, il cui valore predefinito è 1800 quando il membro è omesso alla creazione). Una fonte in errore che supera il periodo è scaduta (status.stale) e aggiunge source.stale.
SourceStatus — obbligatori: state, last_attempt_at, last_success_at, last_change_at, next_run_at, failures, stale, data_expires_at, error, warnings, stats
Cosa hanno fatto le ultime esecuzioni. state è pending (non ancora eseguita), ok (l’ultimo recupero è riuscito e la scheda ha accettato il documento), error (l’ultima esecuzione è fallita e la scheda ha conservato l’ultimo documento valido) o disabled. ok non valuta se i dati di origine sono corretti o aggiornati, né se uno schermo mostra la scheda.
SourceTarget — obbligatori: card_id
SourceTestRequest — obbligatori: none
SourceTestResult — obbligatori: document, valid, warnings, stats, fetched_at
SourceUpdate — obbligatori: none
StackLevel — obbligatori: id, source, playlist_id
Un livello dello stack di uno schermo (packages/schedule-contract SEMANTICS.md, Levels and the stack). id è takeover, campaign:ID, schedule:ENTRY_ID, default o folder:FOLDER_ID; record_id indica la campagna, la voce o la cartella, name il nome della campagna o della cartella. Con rule assente il livello è sempre in vigore.
StackLevelRule — obbligatori: none
StreamSource — obbligatori: none
StreamSourceWrite — obbligatori: none
Una sorgente stream. Una sorgente può indicare solo il suo url e lasciare che lo schema indichi il protocollo: https è hls, rtsp e rtsps sono rtsp.
SupportConversation — obbligatori: id, subject, created_at, updated_at, last_sequence, human_requested, unread_staff, closed
SupportConversationList — obbligatori: items, next, unread_staff_total
SupportHours — obbligatori: timezone, start, end, weekdays, excludes_bc_holidays
SupportMessage — obbligatori: id, conversation_id, sequence, role, author, body, created_at
SupportMessageList — obbligatori: items
SupportRead — obbligatori: sequence
SupportStatus — obbligatori: chat_allowed, available, staffed, human_available, hours, human_wait_seconds, docs_url
SupportSubmission — obbligatori: conversation, message
SupportWrite — obbligatori: body
TabShare — obbligatori: id, until, screens, skipped, warnings
TabShareCookie — obbligatori: name, value, domain
Un cookie nel formato dell’API dei cookie del browser. Il valore è segreto.
TabShareScreen — obbligatori: id, label
TabShareSkip — obbligatori: id, label, code, detail
Una destinazione non presa in controllo. code è il codice di problema che restituirebbe il controllo di quello schermo da solo.
TabShareState — obbligatori: id, until, screens
TabShareStopped — obbligatori: id, screens
TabShareWarning — obbligatori: code, url, detail
TabShareWrite — obbligatori: tabs
Schede da mostrare e relativi schermi. Almeno uno tra screen_ids, folder_ids e tags.
Trigger — obbligatori: id, kind, label, target, default_for_seconds, url, username, revision, created_at, updated_at
Un trigger CAP o un trigger di sovrapposizione. La sua password viene restituita solo da create e rotate-secret.
TriggerAlert — obbligatori: id, revision, state, status, msg_type, sender, identifier, until, screens, started_at, updated_at
L’ultimo avviso del trigger, dai campi del messaggio CAP.
TriggerAlertScreens — obbligatori: targeted, taken_over, cleared, skipped, failed, pending
Cosa ha fatto l’ultima modifica takeover. saltati gli schermi senza playlist predefinita, archiviati o spariti, e, durante la cancellazione, gli schermi che un altro takeover ha sostituito nel frattempo.
Uno schermo in una cartella di schermi protetta viene lasciato com’è e contato in protected, non saltato; terminare un avviso (annullamento, tutto chiaro, cancellazione da parte di un operatore) rimuove comunque ciò che il trigger ha impostato su tale schermo.
TriggerClear — obbligatori: none
TriggerDelivery — obbligatori: at, outcome, status, bytes, request_id
TriggerDeliveryList — obbligatori: items
TriggerList — obbligatori: items
TriggerOverlay — obbligatori: show, style, enabled, signing, alerts, screens, pending
Configurazione e stato di un trigger di sovrapposizione.
TriggerOverlayAlert — obbligatori: id, until, started_at, updated_at, revision
TriggerOverlayReceipt — obbligatori: outcome, trigger_id, until, active
TriggerOverlayRequest — obbligatori: none
Un invio a un trigger di sovrapposizione, come letto dopo il mapping del trigger (se presente). Una chiusura ignora ogni membro tranne alert_id, clear e state.
TriggerOverlayScreens — obbligatori: targeted, holding, taken_over, removed, edge_taken, skipped, failed
Che cosa ha fatto l’ultima distribuzione agli schermi di destinazione. Uno schermo in una cartella di schermi protetta viene lasciato com’è e contato in protected, non saltato; terminare l’avviso rimuove comunque ciò che il trigger ha impostato su di esso.
TriggerOverlayStyle — obbligatori: none
I parametri statici della scheda di testo con cui viene disegnata una sovrapposizione. Il trigger sceglie il layout.
TriggerOverlayWrite — obbligatori: show
TriggerPatch — obbligatori: none
TriggerReceipt — obbligatori: outcome, trigger_id
TriggerSecretRotate — obbligatori: none
TriggerTarget — obbligatori: none
Esattamente uno tra tag e screen_ids.
TriggerWithPassword — obbligatori: none
TriggerWithSecrets — obbligatori: none
TriggerWrite — obbligatori: label, target
UDPStreamSource — obbligatori: protocol, group, port
URLStreamSource — obbligatori: url
UploadScope — obbligatori: playlist_ids, folder_ids
Ciò che un uploader può usare (docs/uploaders.md): le playlist di cui modifica le pagine e le cartelle media in cui carica. Le cartelle sono esattamente quelle elencate, mai le loro sottocartelle. Un id che al momento della scrittura non indica alcun oggetto attivo del progetto è invalid_request alla sua posizione; una successiva eliminazione lascia un id morto, che non concede nulla.
L’ambito viene letto a ogni richiesta, quindi una modifica si applica alla successiva.
UptimeDay — obbligatori: day, online_s, offline_s, availability, coverage
Un giorno UTC. la disponibilità è online_s su online_s più offline_s, null quando non è stato registrato nulla. la copertura è la quota del giorno (di ogni giorno di schermo riportato in una riga di progetto) con uno stato registrato, da 0 a 1: un intervallo vuoto riduce la copertura e non è mai tempo offline. gli intervalli (righe schermo) sono quanti intervalli registrati hanno toccato il giorno; gli schermi (righe progetto) quanti schermi hanno avuto uno stato registrato; live indica un giorno schermo che include l’intervallo aperto fino ad ora.
UsageFrame — obbligatori: page_id, primitive_id, rect
Una primitiva immagine o video che indica il file multimediale, con il suo riquadro e il modo in cui il file lo riempie.
UsageScreen — obbligatori: id, label, screen, playlist_ids, how
Uno schermo attivo che usa almeno una delle playlist elencate.
UsageScreenHow — obbligatori: playlist_id, uses
UsageTagFilter — obbligatori: all, any, none
Il filtro di un selettore tag. Un file corrisponde quando ha tutti i tag di all, almeno uno dei tag di any se any ne indica, e nessuno dei tag di none; il selettore tag in forma abbreviata è all con un solo tag.
UsageTrack — obbligatori: index, id
UserEmailChangeAccepted — obbligatori: none
UserEmailChangeRequest — obbligatori: email, proof
Richiede una modifica email verificata usando una prova recente. L’email attuale resta valida mentre la verifica è in sospeso. Il vecchio indirizzo riceve solo un avviso, senza link di annullamento.
VerifiedOrganizationDomain — obbligatori: domain, organization_id, state, verified_at
VersionResponse — obbligatori: version, commit, api_version, protocol_version
Webhook — obbligatori: id, url, event_types, enabled, revision, status, created_at, updated_at
Un webhook di progetto. I record del log del lettore (runtime.reported) non vengono consegnati.
Ogni evento progetto corrispondente è POSTato a url come lo stesso oggetto JSON che GET /api/events restituisce, con header ScreenRig-Webhook-Id, ScreenRig-Event-Id (il cursore evento, stabile tra i retry), User-Agent e ScreenRig-Signature t=<unix seconds>,v1=<hex HMAC-SHA256 over "<t>.<raw body>" firmato con la stringa segreta>.
Una risposta 2xx entro 10 secondi ha successo; qualsiasi altro stato, un reindirizzamento (mai seguito), un timeout o un errore di connessione o TLS viene ritentato con backoff esponenziale (30 secondi raddoppiati fino a un’ora, con jitter) per 24 ore e poi fallisce. Dopo tre timeout consecutivi il timeout di tentativo scende a 5 secondi fino a ricevere una risposta.
Un webhook ha al massimo un tentativo in corso e un progetto al massimo due, su tutti i server. La consegna è almeno una volta e non ordinata; deduplica su ScreenRig-Event-Id.
Ogni tentativo viene conteggiato come un evento del flusso di ascolto (1 credito dopo la quota mensile di 10.000 API/SSE), e gli stessi eventi gratuiti sul flusso di ascolto lo sono anche qui: screen.*, runtime.*, alert_mute.*, application.event, playback.page_failed e agent.command.
Un tentativo rifiutato prima che venga inviato qualsiasi dato (url_rejected, dns_failed) non viene addebitato. payment_required e secret_unavailable attivano il backoff ma non contano mai per lo stato failing né per la disattivazione automatica. status è failing finché nessuna consegna ha avuto successo da failing_since; dopo 72 ore di errori continui il webhook viene disattivato (disabled_reason delivery_failures) e viene aggiunto notification.disabled.
WebhookDelivery — obbligatori: id, webhook_id, event_id, event_type, state, attempts, created_at
WebhookDeliveryAttempt — obbligatori: attempt, at, status, error, duration_ms
WebhookDeliveryAttemptList — obbligatori: items
WebhookDeliveryList — obbligatori: items, next_cursor
WebhookEventTypes — obbligatori: none
Tipi di evento esatti come screen.online, oppure prefissi che terminano con .* come screen.* (ogni tipo che inizia con screen.). notification.test non viene mai distribuito da una sottoscrizione; viene inviato solo da POST /api/webhooks/{id}/test.
WebhookHandshake — obbligatori: none
Un handshake di fornitore a cui risponde l’URL, per un fornitore senza schema di firma qui. microsoft_graph risponde a un POST che porta un parametro di query validationToken restituendo il token decodificato come text/plain. monday risponde a un POST JSON di {"challenge": "..."} con lo stesso JSON. trello risponde al suo controllo HEAD con 200. azure_event_grid risponde a un SubscriptionValidationEvent (aeg-event-type: SubscriptionValidation) con {"validationResponse": "<validationCode>"}. verify.vendor slack risponde alla sfida url_verification firmata di Slack, e verify.vendor asana risponde all’handshake X-Hook-Secret di Asana e conserva quel segreto per verificare i suoi eventi.
Un handshake riceve risposta solo per un webhook configurato per quel fornitore, non scrive nulla, non viene mai fatturato e non consuma budget di frequenza, ed è registrato nel registro delle consegne con l’esito handshake. Un webhook disattivato non risponde a nessuno.
WebhookList — obbligatori: items
WebhookPatch — obbligatori: none
WebhookVerify — obbligatori: vendor, secret
La verifica del fornitore di un webhook o di un trigger, come la mostra una lettura. Il segreto è sempre solo un suggerimento.
WebhookVerifyVendor — obbligatori: none
WebhookVerifyWrite — obbligatori: vendor
Un fornitore la cui firma propria autentica un invio al posto del segreto, perché questi fornitori non possono inviare il nostro.
L’intestazione e lo schema di ciascuno sono quelli del fornitore e sono fissi: github invia X-Hub-Signature-256, sha256= e l’HMAC-SHA256 esadecimale del corpo; stripe invia Stripe-Signature, t=<unix seconds>,v1=<hex HMAC-SHA256 of "<t>.<body>"> (più v1 mentre un segreto viene ruotato, t entro cinque minuti); shopify invia X-Shopify-Hmac-Sha256, l’HMAC-SHA256 del corpo in base64; slack invia X-Slack-Signature, v0= e l’HMAC-SHA256 esadecimale di "v0:<X-Slack-Request-Timestamp>:<body>" (entro cinque minuti); linear invia Linear-Signature, l’HMAC-SHA256 esadecimale del corpo, e il membro webhookTimestamp del corpo (millisecondi Unix) deve essere entro un minuto; vercel invia x-vercel-signature, l’HMAC-SHA1 esadecimale del corpo; asana invia X-Hook-Signature, l’HMAC-SHA256 esadecimale del corpo con chiave l’X-Hook-Secret dell’handshake di Asana; generic_hmac è qualsiasi mittente che firma con HMAC-SHA256 nell’intestazione che indichi tu.
Un invio che porta una firma valida viene accettato senza il segreto, e il segreto continua a funzionare accanto. verify non può essere combinato con signing. Un invio viene giudicato sul corpo così come è arrivato, prima che consumi budget di frequenza. Slack e Asana rispondono anche ai propri handshake (vedi WebhookHandshake).
WebhookWithSecret — obbligatori: id, url, event_types, enabled, revision, status, created_at, updated_at, secret
Un webhook più il suo segreto di firma. Restituito solo da create e rotate-secret.
WebhookWrite — obbligatori: url, event_types
WebsiteSetupCode — obbligatori: code, expires_at