Schémas : référence de l’API, types et champs obligatoires

OpenAPI YAML OpenAPI JSON problèmes YAML Vue d’ensemble de l’API

Index du schéma

AccessLevel — obligatoires: none
lire (Lecture seule) < proposer < gérer. Proposer lit, contribue (médias, notes, commentaires, assistance, retours, captures d’écran, brouillons de pub) et transforme les modifications de liste de lecture et d’écran en révisions (docs/reviews.md).
AccessLimitedBy — obligatoires: none
Pourquoi effective_access est inférieur à l’accès des identifiants. projet - le projet exige une révision pour les modifications d’agent. personne - la personne responsable de l’agent est un membre qui ne peut pas approuver les révisions.
AdslotPageWrite — obligatoires: id, type, adslot_id
Emplacement publicitaire pleine page. Au maximum 16 pages adslot, et au moins une page ordinaire sans visibilité, sont des vérifications serveur et ne sont pas exprimées ici.
AdvertisingAvailability — obligatoires: estimated_plays, booked_plays, available_plays, screens, observed_from, observed_to, flight_start, flight_end
Une estimation : les occurrences d’emplacement que les écrans ciblés ont produites sur la fenêtre observée, projetées sur la période de diffusion, moins les lectures dont d’autres objectifs directs ont encore besoin sur les mêmes écrans.
AdvertisingAvailabilityQuery — obligatoires: flight_start, flight_end
AdvertisingCampaign — obligatoires: 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 — obligatoires: name, daily_cap_mcr, lifetime_cap_mcr, flight_start, flight_end, networks
AdvertisingCampaignList — obligatoires: campaigns
AdvertisingCampaignNetwork — obligatoires: 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 — obligatoires: seller_project_id, screen_ids, slot_ids, creative_ids
AdvertisingCategory — obligatoires: none
La catégorie de l’annonceur. Deux publicités d’une même catégorie ne jouent jamais dans la même pause publicitaire sur un écran ; une publicité sans catégorie n’est jamais séparée.
AdvertisingCreative — obligatoires: id, revision, media_id, media_revision, sha256, kind, content_type, duration_ms, width, height, bytes, state, created_at
AdvertisingCreativeCreate — obligatoires: media_id
AdvertisingCreativeList — obligatoires: creatives
AdvertisingCreativeReview — obligatoires: id, seller_project_id, creative_revision, state, created_at
AdvertisingDaypart — obligatoires: start, end
AdvertisingDeliveryReport — obligatoires: gross_mcr, fee_mcr, net_mcr, completed, interrupted, unbillable, rows, coverage
AdvertisingDeliveryRow — obligatoires: screen_id, slot_id, reservation_id, gross_mcr, fee_mcr, net_mcr, completed_at
AdvertisingDirectCampaign — obligatoires: 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 — obligatoires: name, advertiser, flight_start, flight_end, media_ids
Une campagne directe : l’entente du vendeur avec un annonceur externe sur son propre inventaire publicitaire. Elle ne déplace aucun fonds.
AdvertisingDirectCampaignList — obligatoires: direct_campaigns
AdvertisingDirectPace — obligatoires: status, expected_plays
Livraison par rapport à l’objectif, qui s’accumule uniformément sur la période de diffusion.
AdvertisingDirectPrice — obligatoires: model, amount, currency
Le prix de l’entente enregistré par le vendeur. screenRIG ne le facture jamais ; il sert à valoriser le rapport.
AdvertisingDirectReport — obligatoires: campaign_id, name, advertiser, from, to, delivered_plays, reserved_plays, pace, plays, played_ms, not_played, rows
AdvertisingDirectReportRow — obligatoires: day, screen_id, slot_id, media_id, plays, played_ms
AdvertisingDirectValue — obligatoires: model, amount, currency
Le prix enregistré appliqué aux lectures livrées : par millier de lectures pour cpm, le montant total pour flat.
AdvertisingFillStats — obligatoires: from, to, occurrences, direct, marketplace, vast, unfilled, fill_rate, unfilled_reasons, days
L’offre d’emplacements publicitaires du vendeur pour toutes les heures UTC chevauchant la fenêtre demandée : occurrences demandées, remplissages par source et occurrences non remplies avec la raison de la première demande. La demande couvre au plus 35 jours; les bornes effectives peuvent couvrir 35 jours plus une heure.
AdvertisingFillStatsDay — obligatoires: day, occurrences, direct, marketplace, vast, unfilled, fill_rate
AdvertisingInventory — obligatoires: screen_id, revision, ads_enabled, audience_tags, rate_override_mcr_per_15s, rate_revision, created_at, updated_at
AdvertisingInventoryList — obligatoires: inventory
AdvertisingInventoryWrite — obligatoires: ads_enabled
AdvertisingJoinedInventory — obligatoires: inventory, slots
AdvertisingJoinedNetwork — obligatoires: seller_project_id, membership_id, policy, admission_generation, scope, price_change_pending, default_rate_mcr_per_15s
AdvertisingJoinedNetworkList — obligatoires: networks
AdvertisingMembership — obligatoires: id, seller_project_id, admission_generation, policy_revision, policy, scope, state, revision, created_at, updated_at
AdvertisingMembershipList — obligatoires: memberships
AdvertisingMembershipScope — obligatoires: policy, screen_ids, slot_ids
AdvertisingNetwork — obligatoires: id, revision, enabled, rate_revision, pricing_generation, seller_fee_bps, seller_fee_revision, created_at, updated_at
AdvertisingNetworkCreate — obligatoires: name
AdvertisingQuote — obligatoires: id, campaign_id, campaign_revision, revision, state, expires_at, items, pricing_generations, created_at
AdvertisingQuoteAccept — obligatoires: quote_id
AdvertisingQuoteItem — obligatoires: 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 — obligatoires: rate_mcr_per_15s
AdvertisingReportCoverage — obligatoires: mode, outcomes_complete
Couverture des comptes de résultats de lecture. Les totaux monétaires proviennent toujours de règlements immuables. Lorsque outcomes_complete est faux, les comptes sont des bornes inférieures observées et l’historique manquant est indisponible, pas nul.
AdvertisingReview — obligatoires: id, creative_id, creative_revision, state, created_at
AdvertisingReviewDetail — obligatoires: review, creative
AdvertisingReviewList — obligatoires: reviews
AdvertisingReviewRejection — obligatoires: reason
AdvertisingScope — obligatoires: screen_ids, slot_ids
AdvertisingSellerCampaign — obligatoires: id, buyer_project_id, name, state, flight_start, flight_end, screen_ids, slot_ids, creative_ids, review_state, enabled, price_change_pending, updated_at
Une campagne d’acheteur soumise, projetée sur le seul réseau du vendeur appelant.
AdvertisingSellerCampaignDelivery — obligatoires: completed, reserved_mcr, gross_mcr, fee_mcr, net_mcr
Lectures réglées et montants cumulés depuis l’origine sur le réseau du vendeur appelant, ainsi que son montant retenu actuel.
AdvertisingSellerCampaignDetail — obligatoires: campaign, delivery
AdvertisingSellerCampaignList — obligatoires: campaigns
AdvertisingSlot — obligatoires: 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 — obligatoires: slots
AdvertisingSlotWrite — obligatoires: name, accepted_media, max_image_duration_ms, max_video_duration_ms
AdvertisingSpendReport — obligatoires: campaign_id, spent_mcr, reserved_mcr, completed, unbillable, pending, coverage
Agent — obligatoires: id, name, agent_type, capabilities, state, authenticated_requests, metered_credits, created_at
AgentCapability — obligatoires: none
Une capacité d’agent-credential. Les capacités sont fixes lors de la création du credential ; pour les changer, connectez un nouvel agent et déconnectez l’ancien. L’ordre canonique est celui de cet énuméré ; les listes de capacités ne contiennent jamais de doublons.
AgentConnection — obligatoires: connection_id, name, agent_type, status, capabilities, expires_at, created_at
AgentDisconnectRequest — obligatoires: none
AgentInput — obligatoires: none
AgentList — obligatoires: items
AgentScreenScopeUpdate — obligatoires: screen_scope
AgentSelfStatus — obligatoires: agent, connection_ready
Alert — obligatoires : id, screen_id, condition, state, since, muted, attention
Une condition d’écran tant qu’elle dure. Les clients traitent une condition inconnue comme une condition qu’ils ne savent pas nommer.
AlertAcknowledge — obligatoires: none
AlertActor — obligatoires: kind, id
AlertList — obligatoires : items, next_cursor, counts
AlertMute — obligatoires : id, screen_ids, tags, until, created_at
AlertMuteList — obligatoires: items
AlertMuteWrite — obligatoire : until
Au moins un identifiant d’écran ou une étiquette.
AppStoreNotificationAcknowledgement — obligatoires: acknowledged
AppStoreNotificationRequest — obligatoires: signedPayload
AppStoreOffer — obligatoires: account_token, products, education_eligible, education_eligibility_source, can_purchase, current_plan_id, subscription
AppStoreProduct — obligatoires: product_id, plan_id
AppStoreSubscription — obligatoires: organization_id, plan_id, product_id, original_transaction_id, environment, expires_at, auto_renews, status
L’abonnement App Store d’une organisation.
AppStoreTransactionRequest — obligatoires: signed_transaction
Application — obligatoires: id, name, revision, created_at, updated_at
ApplicationEventContext — obligatoires: primitive_id, code
ApplicationEventReport — obligatoires: severity, code, context
ApplicationList — obligatoires: items
ApplicationPlacement — obligatoires : playlist_id, playlist_name, page_id, primitive_id, release_id, release, controller, rect, canvas, screen_count
Une primitive d’application sur une page d’une liste de lecture.
ApplicationRename — obligatoires: name
ApplicationUploadCommit — obligatoires: sha256, compressed_bytes
Nomme à nouveau l’archive déclarée ; une validation nommant d’autres octets est refusée avec invalid_request.
ApplicationUploadDeclaration — obligatoires: sha256, compressed_bytes, expanded_bytes, file_count
Déclare un tar.gz produit par la CLI, avec les métadonnées qu’un téléversement diffusé envoie comme en-têtes.
ApplicationUploadSession — obligatoires: id, application_id, release_id, operation, upload_url, method, headers, expires_at
ApplicationUsage — obligatoires : placements, screens
ArchivedProjectDevice — obligatoires: screen_id, label, host
AuditActor — obligatoires: kind
AuditActorKind — obligatoires: none
AuditClient — obligatoires: kind
AuditEntry — obligatoires: id, scope, at, actor, source, action, resource, changes
AuditFieldChange — obligatoires: path, before, after
AuditHead — obligatoires: scope, seq, hash, floor_seq, floor_hash, unsealed, format
AuditList — obligatoires: items, next_cursor
AuditProblem — obligatoires: seq, code, detail
AuditResource — obligatoires: type
AuditRevision — obligatoires: type
AuditSource — obligatoires: none
La surface par laquelle une modification est arrivée : une session du tableau de bord, l’API HTTP, la CLI screenrig, un appel d’outil MCP, un membre du personnel sous bail d’écriture, un appel d’appareil signé, un webhook entrant, ou le serveur lui-même (un travailleur appliquant une modification approuvée).
AuditVerifyResult — obligatoires: ok, scope, checked, head, problems
AutoTopUpDisabledSettings — obligatoires: enabled
La désactivation conserve les montants enregistrés et les dépenses mensuelles. Les champs de montant facultatifs sont ignorés, y compris les brouillons inachevés.
AutoTopUpEnabledSettings — obligatoires : enabled, threshold_cents, amount_cents, monthly_limit_cents
AutoTopUpSettings — obligatoires: none
AutoTopUpView — obligatoires : enabled, threshold_cents, amount_cents, monthly_limit_cents, paused, this_month_cents
BIBrowse — obligatoires: 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 — obligatoires: name, ok
BIConnection — obligatoires: id, project_id, kind, name, config, embed_origin, secret, last_test, revision, created_at, updated_at
L’accès d’un projet à un système BI. Chaque connexion appartient à un seul projet.
BIConnectionConfig — obligatoires: none
BIConnectionList — obligatoires: items, next_cursor
BIConnectionPatch — obligatoires: none
BIConnectionWrite — obligatoires: name, kind, config
BISecret — obligatoires: set, hint
Comment s’affiche un secret stocké. Le secret lui-même n’est jamais renvoyé.
BITarget — obligatoires: none
Ce qu’une vue affiche. Grafana avec une connexion : dashboard_uid (et facultativement un panneau). Power BI avec une connexion : workspace_id et report_id, avec pages ou rotate_all_pages. Tableau avec une connexion : view (Workbook/View), avec rotate_sheets. Web avec une connexion : url. Sans connexion : seulement public_url (et rotate_sheets pour Tableau).
BITestReport — obligatoires: at, ok, checks
BIView — obligatoires: id, project_id, kind, name, target, refresh_s, rotate_s, fit, revision, status, embed_url, created_at, updated_at
BIViewError — obligatoires: at, code, detail
BIViewList — obligatoires: items, next_cursor
BIViewPatch — obligatoires: none
BIViewStatus — obligatoires: last_ok_at, last_error
Comment la vue s’est comportée à l’écran la dernière fois. Elle ne change que lorsque le résultat change.
BIViewTest — obligatoires: at, ok, checks
BIViewWrite — obligatoires: name
Définissez connection_id avec exactement l’un de url et target (pour Tableau, url peut accompagner un target qui ne contient que rotate_sheets ; une vue web prend url et aucun target), ou kind (grafana, powerbi ou tableau) avec target.public_url seul.
BIWebCookie — obligatoires: name, value, domain
Un cookie d’un fichier de cookies exporté d’un navigateur connecté.
BIWebSession — obligatoires: state, cookies, cookies_updated_at, last_login_at, login_failures, retry_at
Les cookies et l’ouverture de session d’une connexion web. state : idle (rien encore ; la première capture ouvre une session), active, login_needed (la page a affiché sa page d’ouverture de session ; la capture suivante ouvre une session), paused (une ouverture de session a échoué ; la suivante attend jusqu’à retry_at), stopped (cinq ouvertures de session refusées de suite ; changez les identifiants) ou expired (une connexion avec cookies seulement dont les cookies ont cessé de fonctionner ; donnez-lui un nouveau fichier de cookies).
BIWebStep — obligatoires: action
Une étape d’une ouverture de session scriptée. goto : url (https, publique). fill : selector et value. click et wait_for : selector. press : value, un nom de touche comme Enter ou Tab, et facultativement selector pour donner d’abord le focus. wait_ms : ms.
Une valeur peut contenir {{username}}, {{password}} et {{otp}}, que le moteur de rendu remplit à partir de l’ouverture de session ; ne mettez aucun mot de passe ni code dans une valeur, seulement le marqueur.
BillingBalance — obligatoires: wallet_revision, remaining_mcr, reserved_mcr, available_mcr, sources, withdrawal
BillingPayer — obligatoires: kind, id
BillingPaymentMethod — obligatoires : brand, last4, exp_month, exp_year
BillingPayoutStatus — obligatoires: rails_available, unavailable_reason
BillingPlanSubscription — obligatoires: subscription_id, plan, status, entitlement, cancel_at_period_end
BillingPortalSession — obligatoires: url
BillingSourceBucket — obligatoires: remaining_mcr, reserved_mcr
BillingSources — obligatoires: nonredeemable, purchased, ad_earned
BillingStatement — obligatoires: entries, next_cursor
BillingStatementEntry — obligatoires: sequence, journal_id, kind, amount_mcr, amount_credits, amount_usd, occurred_at
BillingUsageAllowance — requis : storage_bytes, api_events, storage_mcr_per_gb_month
Ce qu'un payeur obtient gratuitement, sous forme de chaînes décimales canoniques. La bande passante n'est jamais facturée, donc elle n'a aucune allocation.
BillingUsageAmounts — requis : bandwidth_bytes, storage_mcr, api_events
BillingWithdrawal — obligatoires: eligible_earned_mcr, amount_usd_cents, threshold_exclusive_usd_cents, allowed, blockers, rails_available
BrowserLinkClaim — obligatoires: session_id, status, screen
BrowserLinkClaimRequest — obligatoires: code
BrowserLinkClaimScreen — obligatoires: id, public_id, state, public_url
BrowserLinkEvent — obligatoires: session_id, status, event_id, expires_at
BrowserLinkSession — obligatoires: session_id, code, display_code, status, expires_at
BrowserLinkStatus — obligatoires: session_id, code, display_code, status, continuation_path, expires_at
BrowserProvisioningCompletion — obligatoires: screen, public_url
BrowserProvisioningExchange — obligatoires: provisioning_token, exchange_id
CLIEnrollment — obligatoires: project, agent, connection_ready, token, issuance_id, issuance_expires_at, invitation
CLIEnrollmentOAuth — obligatoires: project, agent, connection_ready, issuance_id, issuance_expires_at, invitation, access_token, token_type, expires_in, refresh_token, refresh_expires_at, scope
Inscription au format d’identifiants oauth. La subvention d’inscription (client screenrig-cli, Gérer sur le nouveau projet avec toutes les capacités, accès identité Gérer) a émis sa première paire de jetons ; une répétition exacte avant issuance_expires_at renvoie la même paire, les répétitions ultérieures renvoient credential_issuance_expired.
CLIEnrollmentRequest — obligatoires: client_id
Campaign — obligatoires: id, name, playlist_id, audience, priority, paused, reserved, revision, created_at, updated_at
Une campagne de contenu : chaque écran de l’audience affiche playlist_id tant que from, until et windows sont valides dans le fuseau horaire de l’écran. L’absence de from, until et windows signifie toujours.
CampaignAudience — obligatoires: none
Les écrans qu’une campagne cible : exactement un parmi all (chaque règle correspond), any (au moins une correspond), tag (l’écran porte l’étiquette), screen_id (cet écran) ou folder (les écrans de ce dossier d’écrans et de chaque dossier à l’intérieur, GET /api/screen-folders ; le dossier doit exister).
Les règles s’imbriquent sur 3 niveaux au plus et une audience a au plus 500 règles. {"all": []} correspond à chaque écran du projet ; ailleurs, all et any listent au moins une règle.
CampaignList — obligatoires: items
CampaignPatch — obligatoires: none
CampaignPreviewRequest — obligatoires: body
CampaignPromote — obligatoires: revision
CampaignReach — obligatoires: published, current, at, empty_groups
Le nombre d’écrans actifs auxquels l’audience correspond ; un écran en cours de jumelage n’est pas compté.
Il compte les correspondances de l’audience, pas l’endroit où la campagne joue : un écran actif sans liste de lecture par défaut correspond et ne joue rien. published est le compte lors de la dernière publication de la campagne (création, ou mise à jour avec une audience, un playlist_id ou un paused différent) ; current est le compte le plus récent.
Un changement des étiquettes, du dossier ou de l’état d’un écran actif, ou un déplacement de dossier, recompte les campagnes dont l’audience nomme ce qui a changé environ 15 secondes après la fin des changements et ajoute campaign.reach_changed (published, previous, current ; republished true à partir d’une publication) et, pour chaque étiquette ou dossier de l’audience qui commence ou cesse de correspondre à des écrans, campaign.group_changed (kind, value, matched) ; une publication qui retire de l’audience une étiquette ou un dossier vide ajoute campaign.group_changed avec removed true et matched 0.
Absent sur une campagne qui n’a été ni publiée ni recomptée depuis l’introduction de la portée.
CampaignRevision — obligatoires: revision, created_at, change, current, campaign
Une révision stockée d’une campagne : la campagne telle qu’elle était après une écriture. change dit ce qui l’a produite : created, edited (une mise à jour ou une importation d’horaires), restored ou promoted (une copie d’une révision antérieure, nommée par restored_from), ou baseline (la révision que la campagne détenait au début de son historique, avant qu’aucune écriture n’en enregistre une).
Une valeur que ce lecteur ne connaît pas est lue comme edited.
CampaignRevisionList — obligatoires: items
CampaignScreens — obligatoires: campaign_id, counts, items
CampaignStatus — obligatoires: campaign_id, screen_id, status
La situation d’une campagne sur un écran.
Sur un écran dont le Player résout et reçoit sa propre pile (schedule.stack), une campagne en vigueur selon l’heure occupe la place que lui donne cette pile : une campagne en bande ou principale joue dans sa région, et un verrouillage d’affichage sur ses affichages; une campagne absente de la pile est pending ou blocked (playlist_unavailable). playing : l’écran l’affiche. pending : elle devrait s’afficher et le changement arrive dans la minute. waiting : hors de from, until ou windows actuellement (next_start indique le début s’il est dans les huit jours). ended : until est passé. outranked : elle est en vigueur, mais une prise de contrôle de l’écran (reason takeover) ou une autre campagne (reason campaign, by) l’emporte. conditional : elle est en vigueur selon l’heure et joue tant que la condition observée uniquement par le Player est aussi remplie (reason interaction : quelqu’un utilise l’écran; data : sa condition de données). paused. blocked : elle ne peut pas s’afficher ici (reason no_default_playlist, no_timezone ou playlist_unavailable : la liste de lecture est absente, non approuvée ou incompatible avec l’écran; region_not_laid_out : elle n’est disposée sur aucun affichage de cet écran (sa bande ne convient à aucun affichage ciblé, ou son verrouillage ne nomme aucune sortie de l’écran) et est exclue de sa pile; ou stack_only : le Player de l’écran ne résout pas sa propre pile, et seul un Player qui le fait respecte une région, un verrouillage d’affichage, une interaction ou une condition de données). not_in_audience.
CampaignWrite — obligatoires: name, playlist_id, audience
CanvasBackground — obligatoires: none
#RRGGBBAA canonique solide en majuscules, ou un dégradé linéaire de haut en bas.
CanvasColor — obligatoires: none
sRGB majuscule canonique RRGGBBAA.
CapPull — obligatoires: none
Sources CAP que la plateforme lit pour le déclencheur, avec où se trouvent les écrans cibles et quelles alertes comptent : les paramètres d’un placement de carte d’alerte cap (docs/feeds.md « CAP alerts »). Chaque URL source est récupérée une fois par minute pour chaque déclencheur et placement qui la nomme.
Sans sources, les flux publics de la plateforme couvrant l’emplacement sont lus (NWS, Canada NAAD et MeteoAlarm pour un emplacement avec codes régionaux). L’alerte correspondante la plus sévère prend le contrôle des écrans cibles exactement comme un message poussé le ferait ; lorsque les sources n’en montrent aucune (annulation ou expiration), une alerte tirée prend fin.
Une source périmée ou défaillante ne termine jamais une alerte. location est requis sauf si des sources sont données.
Capabilities — obligatoires : 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 — obligatoires: cards
CardCreate — obligatoires: type, params
CardDataEntry — obligatoires: key, document, bytes, sha256, revision, created_at, updated_at
CardDataList — obligatoires: items, next_cursor
CardDataSummary — obligatoires: key, bytes, sha256, revision, created_at, updated_at
CardDataWrite — obligatoires: document
CardDetails — obligatoires: id, major, version, params_schema, data_schema, feed, tier, layouts, example
CardFile — obligatoires: src, sha256
CardInstance — obligatoires: id, project_id, type, major, params, created_at, updated_at, revision
CardKVWebhook — obligatoires: id, card_id, description, mapping, enabled, signing, url, created_at, updated_at
Un webhook entrant qui écrit le document de données d’une carte.
CardKVWebhookCreate — obligatoires: none
CardKVWebhookList — obligatoires: items
CardKVWebhookRotate — obligatoires: none
CardKVWebhookUpdate — obligatoires: none
CardKVWebhookWithSecrets — obligatoires: none
CardKVWebhookWriteResult — obligatoires: status
CardRequirements — obligatoires: cardml, features
CardSummary — obligatoires: id, title, short, category, tags, tier, layouts, majors
Comments — obligatoires: comments
CommentsWrite — obligatoires: comments
Connection — obligatoires: id, project_id, provider, mode, name, status, last_error, config, secret, last_test, revision, created_at, updated_at
L’accès réutilisable d’un projet à Microsoft ou à Google. Les sources, les connexions Power BI et les comptes de synchronisation de médias SharePoint en nomment une dans config.connection_id au lieu de porter leurs propres identifiants.
ConnectionCheck — obligatoires: name, ok, detail
ConnectionConfig — obligatoires: none
Ce qu’une connexion nomme en plus de son secret ; seuls les membres que son fournisseur et son mode utilisent sont présents. Un secret, une clé ou un jeton d’actualisation n’est jamais ici.
ConnectionConfigWrite — obligatoires: none
Microsoft, mode own_app : les deux membres. Non accepté pour une connexion Google ni pour le mode screenrig_app.
ConnectionConsent — obligatoires: none
Une connexion renvoyée avec son lien de consentement à usage unique, que seule une écriture qui en crée un porte : la création d’une connexion en mode screenrig_app et POST /api/connections/{id}/connect. La personne qui donne son consentement ouvre consent_url avant consent_expires_at. C’est le lien d’un seul consentement : ne l’envoyez qu’à cette personne. Une lecture de la connexion ne le porte jamais.
ConnectionError — obligatoires: code, message, at
Pourquoi une connexion ne fonctionne pas. Le message est une phrase fixe plus, pour Microsoft, le code AADSTS ; il ne répète jamais un texte envoyé par un appelant.
ConnectionList — obligatoires: items, next_cursor
ConnectionPatch — obligatoires: none
ConnectionSecret — obligatoires: set, hint
La façon dont une réponse montre le secret, la clé ou le jeton d’actualisation d’une connexion. La valeur n’est jamais renvoyée.
ConnectionTest — obligatoires: at, ok, checks
ConnectionWrite — obligatoires: provider, mode, name
CreatedProject — obligatoires: project, organization
CreditPurchase — obligatoires: id, status, amount_cents, credits, credited
DashboardAgentAction — obligatoires: project_id
DashboardApplicationPreviewLaunch — obligatoires: release_id, launch_url, expires_at
DashboardApplicationSummary — obligatoires: count
DashboardBalance — obligatoires: credit_remaining, credit_included, credit_reset
DashboardBoot — obligatoires: none
Une requête pour la coquille du tableau de bord. Chaque membre est le corps que la route nommée renvoie pour cette même session, et il est absent lorsque cette route ne répondrait pas 2xx pour elle. advertising_network est null lorsque le projet n’a pas de réseau.
DashboardDisplayName — obligatoires: none
Nom d’affichage imprimable tronqué, au maximum 80 octets UTF-8. Rejette les contrôles, textes ressemblant à des URL, @, www., ://, et les informations d’identification. Jamais autorisation.
DashboardEmail — obligatoires: email, email_verified, email_revision
La vue courriel propre à l’utilisateur actuel. L’adresse vérifiée reste effective pendant qu’un changement est en attente, et le candidat en attente est visible uniquement par son propriétaire.
DashboardEmailVerificationAccepted — obligatoires: status
DashboardHealthSummary — obligatoires: display_disconnected, hot, crashing, stale
Écrans actifs avec un rapport d’état, comptés par condition ; un écran peut compter dans plusieurs. display_disconnected, hot et crashing comptent uniquement les écrans en ligne dont le dernier rapport est actuel (pas périmé) ; stale compte les écrans en ligne dont le rapport date de plus de 35 minutes et rien d’autre.
DashboardMe — obligatoires: user_id, display_name, email, password, passkeys, created_at
DashboardMediaSummary — obligatoires: count, bytes
Compteurs des médias prêts du projet de la session. bytes ne compte que les octets de médias stockés ; ce n’est pas le total used_bytes du projet, qui couvre aussi les arborescences de versions et les entrées clé/valeur. image_bytes, video_bytes et audio_bytes répartissent bytes par primitive et totalisent toujours bytes tant que image, video et audio sont les seules primitives ; si une autre primitive est un jour stockée, les trois totalisent moins que bytes.
DashboardMember — obligatoires: user_id, display_name, joined_at, passkeys, password, owner, external
DashboardMemberList — obligatoires: items, viewer_user_id, viewer_is_owner
DashboardPasskey — obligatoires : id, name, credential_id, provider, created_at, last_used_at
DashboardPasskeyAssertion — obligatoires: ceremony_id, request_options
DashboardPasskeyAssertionComplete — obligatoires: ceremony_id, credential
DashboardPasskeyComplete — obligatoires: ceremony_id, credential
DashboardPasskeyList — obligatoires : rp_id, user_handle, items
DashboardPasskeyPatch — obligatoires: name
DashboardPasskeyProof — obligatoires: type, ceremony_id, credential
DashboardPasskeyRegistration — obligatoires: ceremony_id, creation_options
DashboardPasswordLogin — obligatoires: email, password
DashboardPasswordProof — obligatoires: type, password
DashboardPasswordSet — obligatoires: password, proof
DashboardPendingEmail — obligatoires: email, expires_at
DashboardProject — obligatoires: status, created_at, email, screen_count, screen_limit, used_bytes, reserved_bytes, content_limit_bytes, event_retention_days, name
Statut, adresse de contact, limites appliquées, utilisation, conservation et état public du crédit total pour un projet. L’identifiant interne du forfait reste non publié.
DashboardProjectList — obligatoires: items
DashboardProjectListItem — obligatoires: id, name, last_used_at
DashboardProjectReference — obligatoires: id, name
DashboardProjectSwitch — obligatoires: project_id
DashboardProof — obligatoires: none
DashboardProofRequest — obligatoires: proof
DashboardReauthentication — obligatoires: ceremony_id, options
DashboardReauthenticationRequest — obligatoires: kind
DashboardSSOProof — obligatoires: type
Preuve par une authentification unique récente. Elle est valide tant que la session actuelle s’est ouverte par le fournisseur d’identité de l’organisation il y a 10 minutes au plus, et ne comporte ni cérémonie ni secret. Sinon la route répond reauthentication_required, et la personne se reconnecte par son fournisseur (POST /api/session/sso-starts, intent reauth).
DashboardScreenSummary — obligatoires: total, online, pairing_pending, active, archived
Compteurs d’écran pour le projet de la session. total est pairing_pending plus active et exclut les archivés, correspondant à screen_count du projet. online est dérivé des flux d’événements runtime live appariés exactement comme Screen.online ; ce n’est pas un booléen stocké ni un signal de vie du lecteur.
DashboardSession — obligatoires: user_id, display_name, email, project, auth_method, authenticated_at, expires_at, dev_auth, staff, shadow, passkey_enrollment_required, email_verification_required
Session de personne. Les identifiants sont descriptifs ; le cookie de session établit l’autorité. Une personne sans projet a project : null.
DashboardSessionOrganization — obligatoires: id, name, managed
L’organisation d’appartenance de la personne.
DashboardSessionSSO — obligatoires : organization_id, provider_name, linked
Le contexte d’authentification unique de la personne. Présent chaque fois que l’adresse vérifiée de la personne appartient à un domaine dont l’organisation a une connexion de fournisseur d’identité; linked est false tant que la personne ne s’est pas connectée par celle-ci ou ne l’a pas liée. Une session d’authentification unique dure 24 heures à compter de l’ouverture de session et n’est pas prolongée par l’usage.
DashboardStaffWriteMode — obligatoires: request_id, project_id, expires_at
DashboardSummary — obligatoires: screens, media, applications
DeletedProject — obligatoires: id, screens, paired_screens_active, paired_screens_archived, paired_screens_completed_pending, agents, media, applications, playlists, memberships
DemoRequestInput — obligatoires: email, country, screen_range, organization, budget, timezone, source, flow_id
DemoResult — obligatoires: route, booking, review_requested, video_url, email, country, timezone, flow_id, source
DemoSlots — obligatoires: slots, timezone
DemoSource — obligatoires: none
DeviceSessionRequest — obligatoires: none
Création de session par navigateur jumelé par cookie. Le corps est optionnel. Les membres inconnus sont ignorés (docs/player-compatibility.md §1.1).
DisplayWindow — obligatoires: days
DocsPage — obligatoires: url, title, markdown, truncated, sections, corpus_commit
DocsSearchResponse — obligatoires: results, corpus_commit
DocsSearchResult — obligatoires: url, title, section, snippet, score
EducationEligibilitySource — obligatoires: none
Qui a décidé de education_eligible. staff est une décision du personnel, dans un sens comme dans l’autre, et elle est définitive. school_email est la décision automatique issue de l’adresse courriel K-12 vérifiée d’un administrateur (un domaine scolaire comme k12.ca.us ou sch.uk ; jamais un domaine d’enseignement général comme .edu ou .ac.uk). La chaîne vide signifie que personne n’a décidé.
EmailVerifyRequest — obligatoires: token
EmailVerifyResult — obligatoires: purpose, status
EmptyPaymentRequest — obligatoires: none
EnrollmentInvitation — obligatoires: id, status, expires_at
Event — obligatoires: cursor, type, severity, message, at
EventActor — obligatoires: user_id, display_name
Utilisateur du tableau de bord ayant causé cette mutation. Optionnel et absent sur chaque événement produit par un agent, le CLI, un lecteur ou un travailleur, ce champ distingue une mutation du tableau de bord plutôt que d’étiqueter tout le trafic. Il s’agit uniquement d’une attribution descriptive et jamais d’une autorisation. display_name est le nom choisi par l’utilisateur lors de l’inscription et n’est pas vérifié.
EventAgent — obligatoires: agent_id, name, agent_type
Attribution principale d’agent sécurisée présente uniquement lorsque l’événement a été directement causé par un agent authentifié. Ce n’est jamais une autorisation.
EventCommand — obligatoires: name, method
La requête de l’agent qui a causé cet événement. Optionnelle et absente pour chaque événement produit par un utilisateur du tableau de bord, un lecteur ou un travailleur. C’est une attribution descriptive uniquement et jamais une autorisation. Chaque champ est écrit par le serveur à partir de la route correspondante ou du registre des problèmes.
Un objet commande ne peut pas porter un vecteur d’arguments, un corps de requête, un en-tête ou tout texte choisi par l’appelant, et il n’y a délibérément aucun champ pour cela. name et method apparaissent sur chaque événement qu’une requête agent a validé.
Les champs de résultat apparaissent UNIQUEMENT lors d’un événement agent.command, qui est l’enregistrement d’une requête n’ayant commis aucun événement de domaine : un événement de domaine commis est lui-même la preuve que la requête a réussi.
EventList — obligatoires: items, next_cursor
FeedDocument — obligatoires: schema, fetchedAt, attribution
FeedPending — obligatoires: key, state, retry_after_seconds
FeedbackContext — obligatoires: none
Enveloppe de diagnostic fermée. Chaque membre est un scalaire contraint optionnel, l’imbrication est structurellement impossible, et un membre inconnu est rejeté avec invalid_request. La forme existe pour qu’un client ne puisse pas persister des valeurs d’argument, des identifiants ou des données d’environnement libres à travers elle.
FeedbackList — obligatoires: items
FeedbackReplyWrite — obligatoires: text
FeedbackResponse — obligatoires: id, text, status, created_at
Une réponse immuable du personnel ou de l’agent. Un auteur absent identifie une réponse du personnel. Texte brut (échappez-le pour tout contexte d’affichage) ; le texte en forme de credential est remplacé par [redacted] avant stockage.
FeedbackStatus — obligatoires: none
Où en est le personnel sur une soumission. waiting_on_user demande des informations à l’agent soumetteur ; une réponse de l’agent la rouvre ou ferme un rapport. Un rapport « planifié » conserve son statut.
FeedbackSubmission — obligatoires: id, kind, title, body, created_at
Une soumission à l’échelle du projet. Ses propres champs (id, kind, title, body, context, created_at) ne changent jamais après écriture. status est ouvert jusqu’à réponse du personnel puis prend le statut de la dernière réponse ; les réponses d’agent rouvrent les rapports en attente ou fermés, tandis qu’un rapport « planned » conserve son statut.
Les réponses sont des répliques du personnel et des agents, les plus anciennes en premier et au maximum 20, jamais modifiées ni supprimées. Chaque réplique ajoute aussi un événement feedback.responded au flux d’événements du projet (resource.id est l’identifiant de la soumission ; les détails portent response_id, status, fixed_in et author pour les réponses des agents, jamais le texte).
L’identifiant de soumission n’est jamais une autorisation : seul le projet propriétaire le lit.
FeedbackWrite — obligatoires: title, body
FleetLink — obligatoires: id, label, enabled, tags, screens_created, revision, created_at, updated_at
Une URL de Lecteur qui transforme chaque appareil l’ouvrant en son propre écran dans ce projet.
FleetLinkList — obligatoires: items
FleetLinkPatch — obligatoires: none
FleetLinkWrite — obligatoires: label
GroupBinding — obligatoires : binding_id, group_id, group_name, role, created_at
GroupBindingCreate — obligatoires : group_id, role
GroupBindingGroup — obligatoires : id, display_name, member_count
GroupBindingList — obligatoires : bindings, groups
HLSStreamSource — obligatoires: protocol, url
HealthResponse — obligatoires: status
HealthTrend — obligatoires: items, next_cursor
HealthTrendHour — obligatoires: hour, screens_reporting, hot, display_disconnected, crashing
HostContext — obligatoires: platform
Le shell et le matériel sur lesquels un lecteur s’exécute, tel que rapporté par le lecteur. Un INDICE qui nomme un appareil ; jamais un identifiant, jamais une autorisation. Seule la clé Ed25519 autorise.
Stocké par écran, remplacé par chaque session mint qui en porte une, supprimé avec l’écran, jamais écrit dans les journaux d’opération, jamais renvoyé dans les réponses aux problèmes, et jamais retourné à un projet autre que celui du propriétaire. Lecture seule via l’API projet ; ScreenPatch ne peut pas l’écrire.
HostDevice — obligatoires: none
Identifiants matériels optionnels. duid et serial sont les deux seuls consultés par l’indice de récupération ; une lecture échouée sur le player omet le champ.
IceServer — obligatoires: urls
Un RTCIceServer. Les URL du port 53 sont retirées, car les navigateurs les bloquent et rien n’est transmis au fil de l’eau.
IdentityProvider — obligatoires : connection_id, kind, preset, name, jit, service_provider, ready_to_require, policy, revision, created_at, updated_at
La connexion d’authentification unique de l’organisation. Elle ne contient aucun secret.
IdentityProviderCertificate — obligatoires : sha256, subject, not_after
IdentityProviderOIDC — obligatoires : issuer, client_id, client_secret_set, scopes
IdentityProviderOIDCWrite — obligatoires: client_id
IdentityProviderSAML — obligatoires : idp_entity_id, idp_sso_url, certificates
IdentityProviderSAMLWrite — obligatoires: none
IdentityProviderServiceProvider — obligatoires : oidc_redirect_uri, saml_entity_id, saml_acs_url, saml_metadata_url
Les valeurs à saisir chez le fournisseur d’identité, dérivées de l’origine du tableau de bord et de l’id de la connexion.
IdentityProviderTest — obligatoires : at, ok, subject_present
Le résultat du dernier test d’ouverture de session par la connexion.
IdentityProviderWrite — obligatoires : kind, preset, name, proof
Invitation — obligatoires: id, kind, delivery, status, project_id, created_at, expires_at
InvitationAcceptRequest — obligatoires: token, mode
De nouvelles informations d’identification sont requises pour create_login et reset. Le lien create_login nécessite le cookie d’inscription vérifié et utilise son nom d’affichage et son courriel.
Le courriel create_login nécessite display_name. signed_in doit se connecter dans les dix minutes ou fournir une preuve invitation_accept liée à l’identifiant d’invitation. acheteur s’applique uniquement à ad_buyer ; les nouveaux projets acheteurs commencent avec zéro crédit.
InvitationAccepted — obligatoires: kind, project_id, next
InvitationAdvertising — obligatoires: screen_ids, slot_ids, policy
Portée détenue par le vendeur : au moins un écran ou emplacement. Écrans seulement, emplacements seulement ou les deux sont acceptés.
InvitationBuyer — obligatoires: none
InvitationCreate — obligatoires: kind
La livraison par courriel nécessite des adresses courriel. La livraison par lien est réservée à project_member et exclut les courriels et la publicité. ad_buyer exige de la publicité. Un maximum de 50 invitations en attente pour les membres et acheteurs par organisation ; une invitation courriel en attente du même type et à la même adresse est réutilisée.
InvitationCreated — obligatoires: invitations
InvitationCredential — obligatoires: none
InvitationEmailVerificationAccepted — obligatoires: status, expires_at
InvitationEmailVerificationRequest — obligatoires: token, display_name, email
InvitationInspect — obligatoires: id, kind, delivery, project, expires_at, person, modes, methods
Inspection non consommatrice. person est nul pour les liens. Ne rapporte jamais l’état de vérification d’inscription, sauf qu’une réinitialisation de connexion, dont le lien n’est allé qu’à l’adresse, indique si la mener à terme remplace un compte non vérifié (replaces_unverified_account). Les modes de courriel sont create_login ou signed_in ; les liens offrent les deux, et les réinitialisations offrent reset.
InvitationInspectRequest — obligatoires: token
InvitationIssued — obligatoires: id, kind, delivery, status, project_id, created_at, expires_at
InvitationKind — obligatoires: none
InvitationList — obligatoires: items, next_cursor
InvitationPasskeyOptionsRequest — obligatoires: token, mode
InvitationPasswordCredential — obligatoires: type, password
InvitationSignup — obligatoires: email, display_name, verified, expires_at
InvitationStatus — obligatoires: none
KVEntry — obligatoires: application_id, key, value_base64, content_type, bytes, sha256, revision
KVList — obligatoires: items, next_cursor
KVSummary — obligatoires: application_id, key, content_type, bytes, sha256, revision
KVWebhook — obligatoires: id, application_id, key, description, url, created_at
Un webhook clé/valeur entrant. Son secret est renvoyé uniquement par create et rotate-secret.
KVWebhookCreate — obligatoires: key
KVWebhookDelivery — obligatoires: at, outcome, status, bytes, request_id
KVWebhookDeliveryList — obligatoires: items
KVWebhookList — obligatoires: items
KVWebhookWithSecret — obligatoires: none
KVWebhookWriteResult — obligatoires: key, revision, bytes, sha256, content_type, updated_at
KVWrite — obligatoires: value_base64
LevelDate — obligatoire: date
Une date civile précise, la journée entière ou entre start et end comme pour une fenêtre. Elle commence entre from et until et n’est pas une date d’exception.
LevelInteraction — obligatoires: none
Le niveau est en vigueur tant que quelqu’un utilise l’écran : d’un toucher, d’un clic ou d’une touche jusqu’à ce que idle_s secondes s’écoulent sans saisie. Usage typique : une page interactive au-dessus d’une boucle d’attraction. idle_s est stocké et renvoyé (60 si omis).
LevelMonthly — obligatoires: none
Une occurrence mensuelle dans le fuseau horaire de l’écran : day (1 à 31 ; un mois sans ce jour l’ignore), ou nth (1 à 4, -1 pour le dernier) et weekday. start et end comme pour une fenêtre ; la date où l’occurrence commence en est propriétaire.
LinearGradientBackground — obligatoires: type, stops
Dégradé linéaire de haut en bas. Il n’y a pas de champ angle. stops a de 2 à 8 entrées, strictement croissantes dans [0, 1], la première à 0, la dernière à 1.
LinearGradientStop — obligatoires: at, color
Un arrêt sur un arrière-plan de canevas linéaire de haut en bas. at=0 est le bord supérieur, at=1 est le bord inférieur.
LiveFrames — obligatoires: live_id, state
Progression de l’adaptateur d’images d’une session en direct. Schéma ouvert.
LiveSession — obligatoires: state, screen_id, viewer_url
Session en direct d’un écran. Schéma ouvert.
LiveStartRequest — obligatoires: none
LiveViewer — obligatoires: viewer_id, live_id, offer, ice_servers, expires_at
Offre du relais pour un visionneur. Schéma ouvert.
LiveViewerAnswer — obligatoires: answer
ManifestActivatedContext — obligatoires: manifest_revision
ManifestActivatedReport — obligatoires: severity, code, context
ManifestUpgradeContext — obligatoires: manifest_revision, state
ManifestUpgradePlaylist — obligatoires: id, name, revision
L’identité de la liste de lecture derrière une révision désirée émise ou en attente : desired_playlist utilise sa subvention désirée exacte ou l’objectif de contenu partagé en lecture seule pour l’affectation effective actuelle avant l’émission de la subvention. active_playlist utilise toujours la subvention historique reconnue exacte, jamais une affectation ou modification de contenu plus récente. id plus révision sont la version de la liste de lecture qu’un opérateur lit comme Cible v42 / Lecture v41 ; name est le nom d’affichage de la liste de lecture, nul lorsque la liste de lecture n’existe plus ou ne peut pas être résolue.
Une subvention active historique manquante est nulle, jamais une révision fabriquée. Un objectif désiré en file d’attente n’accorde aucun accès au contenu.
ManifestUpgradeReport — obligatoires: severity, code, context
Un instantané du cycle de vie de mise à niveau de manifeste latest-wins pour l’écran de session.
Le serveur stocke un emplacement par écran et en dérive le modèle de lecture de projet Screen.manifest_upgrade ; un rapport périmé, remplacé ou pré-activation post-activation est accepté sans changement (202), jamais refusé comme conflit, et aucun rapport ne promeut jamais une attribution. severity est enveloppe uniquement : la gravité d’événement dérivée du projet vient de l’état.
McrString — obligatoires: none
Montant exact en millicrédits sous forme de chaîne décimale canonique. 1 crédit équivaut à 1000 mcr.
Media — obligatoires: id, filename, primitive, content_type, operation_id, sha256, bytes, revision, state, created_at, updated_at
MediaAvailability — obligatoires: none
Quand les sélecteurs dynamiques peuvent choisir le média, dans le fuseau horaire de chaque écran : à l’intérieur de [from, until) et sur une occurrence de windows, monthly ou dates (aucun des trois : chaque jour) dont la date n’est pas dans except. La grammaire de niveau de la programmation sans data ni interaction.
MediaAvailabilityPatch — obligatoires: availability
MediaCommit — obligatoires: content_type, bytes, sha256
Déclare uniquement ce que le serveur peut revérifier octet par octet contre l’objet stocké. L’identité du codec n’est pas déclarée ici : le serveur la déduit du conteneur lors de la vérification asynchrone, donc un client ne peut pas affirmer un codec qui influence le comportement du player.
MediaFolder — obligatoires: id, name, parent_id, revision, created_at, updated_at
Un dossier de bibliothèque média. Un sélecteur de liste de lecture par :dossier joue directement les fichiers prêts à l’intérieur, pas ceux des sous-dossiers.
MediaFolderCreate — obligatoires: name
MediaFolderList — obligatoires: items
MediaFolderPatch — obligatoires: none
MediaGenerationReference — obligatoires: none
Exactement un de media_id ou b64. Les URL HTTP sont rejetées.
MediaGenerationRequest — obligatoires: prompt
Demande une image fixe. L’invite est des octets client et n’est jamais renvoyée, enregistrée ou publiée sur SSE projet. aspect_ratio par défaut 16:9. quality est faible, moyenne ou élevée et par défaut moyenne. tag est stocké sur l’objet média prêt comme un tag de téléversement. Les références optionnelles sont en base64 en ligne ou un media_id de projet ; les URL HTTP sont rejetées.
La taille totale de toutes les références d’une requête, qu’elles soient en ligne ou media_id, ne doit pas dépasser 25 165 824 octets (24 Mio) ; une requête dépassant cette limite est refusée.
Sur Standard, le solde restant qui ne peut couvrir deux fois le coût fournisseur de l’image fixe, arrondi aux crédits entiers, après le plancher d’introduction (moins 1 000 000 crédits jusqu’au 2027-01-01, puis zéro) renvoie payment_required, sauf en développement. Les autres forfaits ne sont jamais refusés en raison de leur solde.
MediaGenerationUsage — obligatoires: quality, credits, usd
Débit côté client pour une image fixe stockée, soit le usage du result d’une Operation media.generate en état succeeded. quality est la qualité demandée et modifie l’image, pas un prix fixe. Les crédits valent deux fois le coût fournisseur de cette image fixe, arrondis au crédit ScreenRig entier supérieur. usd est l’équivalent en dollars de ces crédits.
Jamais de nom de fournisseur, coût fournisseur ou nombre de jetons.
MediaList — obligatoires: items
MediaMove — obligatoires: folder_id
Au moins un id parmi media_ids et folder_ids, au maximum 1000 au total.
MediaMoveResult — obligatoires: media, folders
MediaReplace — obligatoires: upload_id
MediaRestore — obligatoires: none
MediaRestorePending — obligatoires: status, review, warnings
MediaRestored — obligatoires: media, warnings
MediaSelectorTagFilter — obligatoires: none
MediaSelectorWeights — obligatoires: none
Parts d’un sélecteur pondéré, indexées par ID média ou tag:NAME.
Le poids d’un élément est sa clé d’ID média si elle est présente ; sinon la première clé tag:NAME, par ordre alphabétique, parmi les balises qu’il porte, ce poids étant réparti également entre les éléments de la sélection qui la portent, de sorte que la part d’un commanditaire reste la même quel que soit son nombre de créations ; sinon l’élément forme son propre groupe avec un poids de 1.
Chaque cycle complet lit chaque élément exactement selon sa part.
MediaSingleTagPatch — obligatoires: tag
MediaSync — obligatoires: id, project_id, account_id, provider, name, folder_id, every_s, state, source, next_run_at, revision, created_at, updated_at
Un dossier source maintenu en phase avec un dossier de médias.
MediaSyncAccount — obligatoires: id, project_id, kind, name, config, secret, state, revision, created_at, updated_at
Ce que les synchronisations utilisent pour lire : les identifiants de l’application Microsoft Entra propre au projet (microsoft365), la connexion d’une personne à Canva (canva) ou à Dropbox (dropbox), ou un compte de service Google avec lequel des dossiers sont partagés (google_drive). Le secret client, les jetons et la clé sont scellés et jamais renvoyés.
MediaSyncAccountConfig — obligatoires: none
MediaSyncAccountConnect — obligatoires: none
Un compte renvoyé avec son lien de consentement à usage unique : ce que renvoient la création d’un compte Canva ou Dropbox et media sync account connect. La personne titulaire du compte Canva ou Dropbox ouvre authorize_url, connectée à Canva ou à Dropbox, avant authorize_expires_at. C’est le lien d’un seul consentement : ne l’envoyez qu’à cette personne. Les lectures du compte ne le portent jamais.
MediaSyncAccountList — obligatoires: items, next_cursor
MediaSyncAccountPatch — obligatoires: none
MediaSyncAccountWrite — obligatoires: kind, name
MediaSyncCheck — obligatoires: name, ok, detail
MediaSyncDesign — obligatoires: id, title
Un design Canva que la personne connectée peut voir.
MediaSyncDesignList — obligatoires: items, continuation
MediaSyncList — obligatoires: items, next_cursor
MediaSyncPatch — obligatoires: none
MediaSyncRun — obligatoires: at, status, added, updated, removed, pending_delete, skipped_total
Le résumé de la dernière exécution d’une synchronisation.
MediaSyncRunError — obligatoires: code, detail
MediaSyncSecret — obligatoires: set, hint
La façon dont une réponse montre le secret client d’un compte, les jetons d’un compte Canva ou Dropbox (set une fois connecté, sans hint), ou la clé de compte de service propre à un compte Google Drive (set lorsque le compte en a une ; hint est composé des quatre derniers caractères de son private_key_id). La valeur n’est jamais renvoyée.
MediaSyncSkipped — obligatoires: name, reason
MediaSyncSource — obligatoires: web_url
La source qu’une synchronisation lit, résolue à la création de la synchronisation. Un dossier SharePoint a drive_id et item_id ; un dossier Dropbox, item_id et path ; un dossier Google Drive, item_id, drive_id lorsqu’il se trouve dans un disque partagé, et shared_by ; un design Canva a design_id et les membres qui le suivent.
MediaSyncTest — obligatoires: at, ok, checks
MediaSyncWrite — obligatoires: provider, account_id
MediaTagPatch — obligatoires: none
MediaTagsPatch — obligatoires: tags
MediaUploadDeclaration — obligatoires: filename, content_type, bytes, sha256
Déclare un téléversement. Le maximum d’octets est un plafond de transport indépendant du forfait, pas une taille réalisable. Un type de contenu image est limité à 20 971 520 octets, 20 Mio, et une déclaration d’image plus grande est rejetée avec invalid_request avant tout transfert d’octet.
Cette limite d’image est une porte uniquement pour les octets : la déclaration ne décode jamais l’image pour l’appliquer, et elle s’applique aux GIF animés et WebP animés exactement comme elle s’applique à une image fixe. Le forfait par défaut n’a pas de limite de stockage produit.
Un plafond de stockage personnalisé, lorsqu'il est présent, est vérifié en premier, et une déclaration qu'il ne peut pas contenir est rejetée avec quota_exceeded avant le transfert de tout octet.
Un projet Standard sans crédit restant se voit refuser declare et commit avec payment_required lorsque les octets stockés par son payeur, avec ce téléversement, dépassent 1000000000 octets (1 Go, le stockage gratuit de Standard) ; la bande passante n’est jamais facturée.
Une déclaration audio/mpeg (MP3) est limitée à 178 257 920 octets, 170 Mio, et une plus grande est rejetée de la même façon ; lisez media_audio_bytes pour la prévalider.
Une déclaration video/mp4 ou video/webm est limitée par le forfait du projet, 500 000 000 octets, 500 Mo, sur Standard et 1 000 000 000 octets, 1 Go, sur tous les autres forfaits, et une plus grande est rejetée de la même façon, en nommant la limite applicable ; lisez media_video_bytes depuis GET /api/project/capabilities pour la prévalider.
Un changement de forfait n’affecte que les déclarations ultérieures : les vidéos stockées continuent de jouer. Lisez media_image_bytes depuis le document de capacités pour prévalider la limite d’image, et project_content_bytes là, ou content_limit_bytes sur le projet, pour connaître tout plafond de stockage personnalisé. Une étiquette optionnelle est stockée sur l’objet média prêt et n’est pas redéclarée lors de la validation.
Un source_filename optionnel enregistre le nom de fichier original de l’appelant lorsque le client a transcodé les octets avant le téléversement ; le nom de fichier de l’objet prêt en est alors dérivé pour que les sources distinctes ne se chevauchent jamais (photo.png téléversé comme photo.webp est stocké comme photo.png.webp, photo.jpg comme photo.jpg.webp, et une source photo.webp reste photo.webp).
MediaUploadSession — obligatoires: id, operation, upload_url, method, headers, expires_at
MediaUploadSource — obligatoires: filename, content_type, sha256, bytes
Identité de téléversement originale vérifiée lors de l’ingestion de l’orientation EXIF normalisée. Lecture seule ; utilisez-la pour reconnaître les nouvelles tentatives. Le condensé, la taille et le type des médias prêts décrivent les octets de livraison normalisés.
MediaUsage — obligatoires : playlists, screens
MediaUsagePlaylist — obligatoires : id, name, uses, screen_count
MediaUse — obligatoires : kind, where
Une façon dont une liste de lecture détient ou atteint le fichier média ; une liste de lecture qui le fait sur plusieurs pages compte pour une seule utilisation.
MediaVersion — obligatoires: number, current, filename, content_type, sha256, bytes, source, created_at
MediaVersionActor — obligatoires: kind
MediaVersionPage — obligatoires: items, next_cursor
MediaWarning — obligatoires: code, detail, playlists
MediaWarningPlaylist — obligatoires: id, name
MemberActivity — obligatoires: id, project_id, user_id, display_name, at, kind, action, outcome, status, source
MemberActivityClient — obligatoires: kind
Le client tel que nommé dans le journal des requêtes edge, analysé à partir de User-Agent et Sec-CH-UA-Platform.
MemberActivityKind — obligatoires: none
sign_in et sign_in_failed contiennent auth_method ; credential_changed est une passkey ajoutée, renommée ou supprimée, un mot de passe défini, ou une modification ou vérification d’email demandée ; reauthenticated est une preuve vérifiée (action reauthentication.<proof kind>) ; mutation est tout autre changement dans le tableau de bord.
MemberActivityList — obligatoires: items, next_cursor, recorded_since
MemberActivityOutcome — obligatoires: none
ok en dessous du statut 400, refusé pour une réponse 4xx, échec pour une réponse 5xx.
MemberActivityResource — obligatoires: type
MemberApproverUpdate — obligatoires: can_approve
MemberScreenScopeUpdate — obligatoires: screen_scope
MemberUploadScopeUpdate — obligatoires: upload_scope
NativeIdentityChallenge — obligatoires: nonce, expires_at, aud, op, request_hash
Comparez l’op retourné et request_hash avec vos valeurs calculées localement avant de signer. Chaque nonce expire en 120 secondes et peut être consommé une fois.
NativeIdentityChallengeRequest — obligatoires: kid, op, request_hash
Fournissez l’opération et son request_hash pour chaque défi. Une clé inconnue nécessite aussi public_key et op=pairing.start. Créer un défi n’enregistre pas la clé.
NativeIdentityProof — obligatoires: kid, public_key, signature
L’en-tête protégé JWS compact est exactement {"alg":"EdDSA"}. Les revendications sont kid, nonce, aud=screenrig-runtime, op, iat/exp entiers, jti non vide, et request_hash.
Les preuves contextuelles durent au maximum 120 secondes et expirent au plus tard à leur défi émis. request_hash est le SHA-256 hexadécimal en minuscules de chaînes UTF-8 jointes par un NUL unique, sans NUL final, commençant par screenrig.native.identity.request.v1 et op.
Ajouter Idempotency-Key pour pairing.start et session.mint ; ajouter la preuve d’association srp_ exacte puis completion_nonce pour pairing.complete ; ne rien ajouter pour identity.reset. Chaque preuve doit inclure request_hash. Un résultat d’opération en cache nécessite toujours une preuve émise fraîche ou la preuve acceptée exacte tant que son reçu à courte durée reste valide.
Les membres JWS/JWK dupliqués ou inconnus, base64url non canonique et clés non d’ordre premier sont rejetés. Les membres inconnus du corps de la requête sont ignorés.
NativeIdentitySessionRequest — obligatoires: kid, public_key, signature
NativeIdentityProof avec op=session.mint plus l’indication d’hôte optionnelle. Un hôte présent REMPLACE l’hôte stocké sur l’écran, car les versions du micrologiciel et du shell évoluent au cours de la vie d’un écran. L’indication n’affecte jamais l’autorisation ; seule la preuve signée le fait.
Les membres inconnus sont ignorés, et l’hôte et la lecture sont lus avec tolérance (docs/player-compatibility.md §1.1).
NativePairingComplete — obligatoires: completion_nonce, public_key, signature
NativePairingCompletion — obligatoires: screen, public_url
NativePairingFleetLink — obligatoires: status
Ce que le lien de flotte présenté a fait pour cette session de jumelage. réclamé et récupéré signifient que l’écran est déjà choisi, et le Player complète le jumelage sans afficher son code. Tout autre statut laisse le code sur la vitre pour une réclamation ordinaire.
NativePairingRecovery — obligatoires: offered
Présent uniquement quand le duid hôte ou le numéro de série dans la requête de démarrage correspond exactement à un écran existant lié à une clé différente. Il ne porte ni écran, ni étiquette, ni projet : l’offre est visible côté projet comme Screen.recovery_pending et l’événement screen.recovery_offered, et seul le projet propriétaire peut la confirmer.
Il est absent, exactement comme sans correspondance, lorsque l'identifiant est ambigu, lorsque la clé de l'écran correspondant a montré une activité dans les dix dernières minutes, ou lorsque cet écran a déjà reçu trois offres dans l'heure glissante. Le code de jumelage est toujours émis et affiché exactement comme sans correspondance. Le lecteur l'utilise uniquement pour enregistrer pairing.recovery_offered.
NativePairingSession — obligatoires: code, pairing_credential, expires_at
NativePairingStart — obligatoires: kid, public_key, signature
La preuve de possession de la clé privée est requise avant l’inscription ou la création du localisateur. Signez un nouveau défi pairing.start lié à l’exact Idempotency-Key ; les démarrages non signés sont rejetés. L’objet hôte optionnel est un indice sur l’appareil, pas un justificatif ; il est stocké sur l’écran lors de la réclamation et peut ouvrir une offre de récupération côté projet.
Les membres inconnus du corps sont ignorés. L’indice d’hôte est lu avec tolérance. Une clé d’hôte inconnue est ignorée et un champ d’hôte mal formé est supprimé, jamais refusé (docs/player-compatibility.md §1.1.1).
NativeRuntimeSession — obligatoires: paired, capabilities, event_cursor, public_url, runtime_credential
Session native détenue par l’exécution (docs/player-compatibility.md §8). Les lecteurs ignorent les membres inconnus et les valeurs de capacités inconnues. Un nouveau membre est envoyé uniquement aux sessions dont les subventions le couvrent.
NextAction — obligatoires: command, reason
Note — obligatoires: id, body, about, state, author, created_at, confirmed_at, review_at, expires_at, resolved_at, resolution, due
Une note de projet. Contexte écrit par un agent, jamais une instruction ou une approbation ; afficher le corps en texte brut.
NoteAbout — obligatoires: type, id
NoteAuthor — obligatoires: agent_id, name, agent_type
L’agent rédacteur tel qu’il était lorsque la note a été ajoutée. Attribution, jamais autorité.
NoteCounts — obligatoires: open, new, due
Les notes ouvertes du projet, et combien sont nouvelles et dues pour cet appelant.
NoteList — obligatoires: items, next_cursor, review, counts
NotePage — obligatoires: items, next_cursor
NoteResolution — obligatoires: cause, reason, by
NoteResolve — obligatoires: reason
NoteResolvedBy — obligatoires: kind, id, name
Qui a résolu la note. agent_type est présent pour un agent. Attribution, jamais autorité.
NoteWrite — obligatoires: body
Notification — obligatoires : id, channel, conditions, screen_tags, hold_minutes, enabled, revision, status, created_at, updated_at
La notification d’une organisation, telle qu’un projet ou l’organisation la lit. Elle couvre tous les projets de l’organisation ou ceux qui sont choisis (project_ids), et agit sur les écrans, les sources, les campagnes et les cartes de chaque projet couvert.
Un projet lit (et, lorsque la notification ne couvre que lui, modifie) les notifications qui le couvrent par le même id, avec son propre statut et ses propres heures d’échec; l’organisation la lit en entier.
Chaque condition est suivie par écran : elle s’ouvre lorsque son événement arrive pour un écran visé, et un avis est envoyé dès qu’elle a duré hold_minutes et que l’écran est toujours dans cet état; lorsqu’elle disparaît après l’envoi d’un avis, un avis de résolution suit.
Une condition qui disparaît pendant le délai d’attente n’envoie rien, et il en va de même pour celle dont l’alerte est acquittée ou reportée pendant ce délai, ou pour celle d’un écran couvert par une mise en sourdine.
Courriel : un courriel par destinataire pour tout ce qui arrive à échéance dans un intervalle d'environ deux minutes, avec la liste de chaque écran et de chaque condition, et des liens vers l'écran et vers cette notification dans le tableau de bord; les courriels de notification sont gratuits.
Chaque courriel d’alerte et de test contient, pour la personne à qui il est adressé, un lien de désabonnement (les en-têtes List-Unsubscribe et List-Unsubscribe-Post, et le pied de page) qui arrête les courriels de cette notification pour cette seule personne, sans connexion; voir unsubscribed.
Webhook : chaque avis est envoyé par POST en JSON {type: alert.opened ou alert.resolved, id, notification_id, project_id, condition, screen {id, name}, since, at, event_id, severity}, où id est l’identifiant de livraison, since est le moment où la condition a commencé, at est le moment où elle a tenu assez longtemps (ouvert) ou s’est dissipée (résolu), event_id est le curseur de l’événement à l’origine de l’avis, et severity (info, warning ou error) est la gravité de la condition pour alert.opened et info pour alert.resolved, sur chaque notification webhook.
L’avis d’une campagne porte aussi reach {published, current} (reach_dropped : les écrans que la campagne atteignait lors de sa publication et qu’elle atteint à l’envoi de l’avis) ou audience_group {kind: tag ou folder, value: l’étiquette ou l’identifiant du dossier} (group_empty) ; le courriel et la messagerie disent la même chose en mots.
Une notification qui définit min_severity ou severity l’indique aussi dans le texte de son courriel, de Slack, de Telegram et de Teams.
Teams et PagerDuty affichent toujours la gravité effective. alert.resolved pour screen_offline porte aussi likely_cause, la cause de la panne qui a pris fin (ScreenOutage.likely_cause) ou null quand elle est inconnue ; il attend jusqu’à deux minutes après le retour de l’écran que le premier rapport de santé la détermine, et un courriel la nomme aussi.
Un redémarrage est établi immédiatement ; une cause réseau ou plateforme exige un rapport de santé reçu après le retour de l’écran, qu’un Player peut envoyer jusqu’à 15 minutes plus tard : un avis parti avant porte donc null, et la cause apparaît dans ScreenOutage.likely_cause et screen.outage_classified.
Le courriel et les canaux de clavardage annoncent trois écrans ou plus qui passent dans une même condition en cinq minutes et partagent un réseau, un emplacement, un modèle, une version du Player ou une étiquette comme un seul avis avec un seul rétablissement (NotificationDeliveryGroup) ; les avis des autres écrans sont ignorés avec grouped.
Un webhook envoie toujours un avis par écran. Les event_types sont envoyés en POST sous forme du même objet JSON que renvoie GET /api/events.
Chaque POST porte ScreenRig-Webhook-Id (l'identifiant de la notification), ScreenRig-Event-Id (l'identifiant de livraison pour un avis, le curseur d'événement pour un événement; stable d'une nouvelle tentative à l'autre, dédupliquez sur cette valeur), User-Agent et ScreenRig-Signature t=<unix seconds>,v1=<hex HMAC-SHA256 over "<t>.<raw body>" keyed with the secret string>.
Une réponse 2xx reçue dans les 10 secondes réussit; toute autre issue est réessayée avec un délai exponentiel (30 secondes, doublant jusqu'à une heure, avec gigue aléatoire) pendant 24 heures, puis marquée comme échouée; les échecs de courriel sont réessayés de la même façon.
Les avis d'écran et les événements screen.* sont gratuits; les autres événements sont mesurés comme un événement listen-stream. status vaut failing tant que rien n'a réussi depuis failing_since; après 72 heures d'échecs continus, la notification est désactivée (disabled_reason delivery_failures) et notification.disabled est ajouté.
NotificationActiveHours — obligatoires: timezone, windows
Quand les avis ouverts partent : les fenêtres (screenrig.schedule/v1), lues dans timezone. Un avis qui arrive à échéance pendant qu’elles sont fermées attend la prochaine ouverture (outside hold, la valeur par défaut) et part alors si sa condition tient toujours, de sorte qu’une condition qui disparaît d’abord n’envoie rien, ou est ignoré (outside drop ; last_error outside_hours).
Un avis résolu pour un avis ouvert qui a été envoyé part toujours, dans les heures ou non, et un test les ignore. crashing est mis en attente ou abandonné comme n’importe quelle autre condition. Les heures jugent un avis lorsqu’il part pour la première fois ; un avis en échec est retenté selon le calendrier habituel, quelles que soient les heures.
Ajouter, modifier ou retirer les heures fait juger de nouveau aussitôt les avis mis en attente pour les anciennes.
NotificationCondition — obligatoires: none
Un changement d’état important d’un écran. screen_offline : le Player a perdu sa connexion (screen.offline, écrit 60 secondes après l’expiration de sa présence) ; disparaît avec screen.online. display_disconnected : le Player signale que son afficheur est déconnecté (screen.health_changed avec change display_disconnected) ; disparaît avec display_reconnected. running_hot : l’appareil signale une température égale ou supérieure au seuil de surchauffe (temperature_high) ; disparaît avec temperature_normal. on_battery : l’appareil a une batterie et son dernier rapport de santé nomme une source de batterie none, ce qui signifie qu’il est débranché (screen.health_changed avec change on_battery) ; disparaît lorsqu’un rapport nomme toute autre source (plugged_in).
L’avis indique que l’écran fonctionne sur sa batterie et ne nomme aucune cause. storage_full : le stockage du Player ne peut pas contenir son contenu (screen.storage_shortfall) ; disparaît avec screen.storage_shortfall_cleared. content_stuck : la mise à jour du contenu de l’écran est en nouvelle tentative, en échec, bloquée ou partielle (screen.manifest_upgrade) ; disparaît lorsqu’un état ultérieur n’est aucun de ceux-là. not_playing : le Player affiche un statut de niveau erreur au lieu de son contenu (screen.status_changed avec level error, autre que storage_full) ; disparaît lorsque son statut n’est plus une erreur. loop_stalled : le Player ne signale aucun problème et son contenu est à jour, mais aucun démarrage de média n’est parvenu au backend depuis plus longtemps que la boucle de l’écran ne le permet (screen.glass_changed avec le verdict de lecture stalled ; Screen.glass indique quand il juge et ce qu’il laisse de côté) ; disparaît lorsqu’un démarrage de média arrive ou que l’écran n’est plus jugé, par exemple lorsqu’il passe hors ligne. glass_blank et glass_frozen : le backend a lu les captures d’écran de l’écran sur une série couvrant sa boucle, et toutes étaient d’un seul ton uni (glass_blank) ou la même image (glass_frozen) (screen.glass_changed avec le verdict d’image blank ou frozen ; Screen.glass indique quand il juge et ce qu’il laisse de côté) ; disparaît lorsque deux captures d’écran de suite montrent une image en mouvement ou que l’écran n’est plus jugé.
Un écran qui cesse d’être jugé ferme l’alerte, mais les notifications par courriel et par clavardage n’envoient aucun avis de rétablissement pour lui, puisqu’on n’a rien vu se rétablir (la ligne de résolution est ignorée avec no_longer_judged) ; un démarrage de média ou deux bonnes captures d’écran en envoient un. crashing : le lecteur a planté ou redémarré son moteur de rendu à répétition (screen.health_changed avec change crash_spike ou renderer_restart_spike); envoyé immédiatement, jamais retenu ni résolu. source_failed et source_stale concernent une source de données, pas un écran : le membre screen de l’avis porte l’identifiant et le nom de la source, le lien est la page de la source, et screen_tags ne correspond jamais à une source, donc une notification limitée par étiquettes ne les surveille pas. source_failed : une actualisation de la source a échoué (source.status_changed avec state error); s’efface à la prochaine actualisation réussie (state ok). source_stale : la dernière bonne actualisation de la source est plus ancienne que son stale_after_seconds, le moment où les données de ses cartes expirent et où les pages qui en dépendent basculent sur leur repli (source.stale); s’efface à la prochaine actualisation réussie.
Aucun des deux n’est une alerte d’écran. reach_dropped et group_empty concernent une campagne (un niveau partagé de la pile d’horaires), pas un écran : le membre screen de l’avis porte l’identifiant et le nom de la campagne, le lien est le calendrier de la campagne dans le tableau de bord, et une campagne appartient au projet, donc screen_tags et audience ne les limitent jamais. reach_dropped : un recomptage a constaté que la campagne atteint moins d’écrans qu’à sa dernière publication, parce que des écrans ont quitté l’une de ses étiquettes ou l’un de ses dossiers, ou ont été archivés ou supprimés (campaign.reach_changed avec current sous published) ; reach_drop fixe l’ampleur d’une baisse qui déclenche un avis ; se dissipe quand elle atteint de nouveau autant d’écrans.
Une publication qui fixe une nouvelle base de référence, ou la suppression de la campagne, la dissipe aussi, ce qui ferme un incident PagerDuty et l’alerte d’un webhook mais n’envoie aucun courriel ni avis de rétablissement dans une messagerie (no_longer_judged). group_empty : une étiquette ou un dossier de l’audience de la campagne ne correspond à aucun écran (campaign.group_changed avec matched 0) ; un avis par étiquette ou dossier (audience_group) ; se dissipe quand il correspond de nouveau à un écran, ou quand une publication le retire de l’audience (removed true), ce qui ferme un incident PagerDuty et l’alerte d’un webhook mais n’envoie aucun courriel ni avis de rétablissement dans une messagerie (no_longer_judged).
Les entrées d’horaire propres à un écran ciblent des listes de lecture, pas des écrans, donc seules les campagnes ont une portée.
Aucun des deux n’est une alerte d’écran. card_data_stale concerne une carte, pas un écran : le membre screen de l’avis porte l’ID de la carte et son nom (le type de la carte, comme dans « carte météo »), le lien est l’éditeur de pages du tableau de bord sur une page qui place la carte (la page propre de la notification quand aucune ne le fait), et since est le moment où ses données ont expiré.
Elle s’ouvre quand le document de données d’une carte, qu’un agent, une tâche ou une personne a écrit avec une expiration (ttl_seconds ou expires_at, comme dans card data put --ttl), atteint cette expiration sans autre écriture pour le renouveler pendant qu’un écran affiche la carte (card.data_expired), de sorte que la carte est vide sur cet écran ; elle se ferme quand une écriture des données de la carte aboutit (card.data_renewed).
Les documents d’une source de données ne sont pas annoncés : ils expirent selon la période de péremption de la source, que couvre source_stale. Une carte qu’aucun écran n’affiche n’envoie rien, pas plus qu’une carte renouvelée, supprimée ou retirée de tous les écrans avant l’échéance de l’avis.
Supprimer les données d’une carte met fin à l’avis sans avis de rétablissement, comme une publication met fin à une baisse de portée (no_longer_judged). Dimensionnez ttl_seconds selon le calendrier de celui qui écrit, afin qu’une tâche arrêtée soit remarquée. Comme une source de données, une carte n’a pas de tags d’écran : une notification limitée à screen_tags ne surveille pas les cartes, et ce n’est pas une alerte d’écran.
Les consommateurs traitent une valeur inconnue comme absente.
NotificationConditions — obligatoires: none
NotificationDelivery — obligatoires : id, notification_id, event_id, event_type, state, attempts, created_at
NotificationDeliveryAttempt — obligatoires: attempt, at, status, error, duration_ms
NotificationDeliveryAttemptList — obligatoires: items
NotificationDeliveryGroup — obligatoires: id, attribute, value, count
Un groupe d’écrans que représente un seul avis. Lorsqu’au moins trois écrans d’un projet passent dans la même condition à moins de cinq minutes d’intervalle et partagent une valeur, une notification par courriel, Slack, Teams, PagerDuty ou Telegram envoie un seul avis pour eux au lieu d’un par écran.
Un écran qui passe dans la condition plus tard avec une valeur dont le groupe ouvert est constitué le rejoint sans nouvel avis, et un seul avis annonce le groupe lorsque son dernier écran est rétabli. Une notification webhook envoie toujours un avis par écran.
NotificationDeliveryList — obligatoires: items, next_cursor
NotificationDestination — obligatoires: none
Slack, Teams, PagerDuty et Telegram seulement ; obligatoire pour eux. L’identifiant sous la forme où le service l’émet : slack, l’URL du webhook entrant (hooks.slack.com) ; teams, l’URL du webhook Workflows (logic.azure.com ou powerplatform.com ; les URL de connecteur Office 365 sont retirées) ; pagerduty, la clé d’acheminement Events API v2 de 32 caractères ; telegram, le jeton du bot.
Une autre forme donne notification_destination_rejected. Il est scellé, jamais renvoyé, et n’apparaît en lecture que sous la forme destination_hint.
NotificationEventTypes — obligatoires: none
Webhook seulement. Événements du projet également envoyés par POST dès qu'ils se produisent, exactement comme un webhook les envoie : types exacts comme screen.online, ou préfixes se terminant par .* comme screen.*. notification.test n'est jamais diffusé.
NotificationList — obligatoires: items
NotificationPatch — obligatoires: none
NotificationProjectIDs — obligatoires: none
Projets actifs de l’organisation, chacun nommé une seule fois. Une liste vide n’en couvre aucun.
NotificationReachDrop — obligatoires: none
La plus petite baisse de la portée d’une campagne pour laquelle un avis reach_dropped est envoyé : screens est le moins d’écrans perdus (1 par défaut) et percent, s’il est défini, la plus petite part des écrans que la campagne atteignait lors de sa publication ; une baisse doit remplir les deux seuils.
Une baisse plus petite ne met aucun avis en file, et un avis en file dont la baisse est passée sous le seuil à l’échéance est ignoré (condition_cleared). Seulement avec la condition reach_dropped ; sur une notification sans elle, invalid_request.
NotificationRecipients — obligatoires: none
Courriel seulement. owner (la personne propriétaire du projet au moment de l'envoi d'un avis) ou le user_id d'une personne membre du projet; un user_id qui n'est pas celui d'un membre entraîne invalid_request. Chacun reçoit un courriel à son adresse courriel vérifiée. Une personne qui a depuis quitté le projet ou qui n'a aucune adresse courriel vérifiée est ignorée.
NotificationSeverity — obligatoires: none
La gravité d’un avis, de la moins grave à la plus grave. Un avis ouvert a la gravité de sa condition : error pour screen_offline et warning pour toute autre condition, sauf si la gravité de la notification en décide autrement. Un avis résolu et un test sont info.
NotificationSeverityOverrides — obligatoires: none
Condition vers gravité pour cette notification, comme {"not_playing": "error"}. Elle compte pour min_severity et est la gravité que Teams et PagerDuty affichent pour la condition. Une condition non listée garde sa valeur par défaut. Lors d’un patch, un objet vide, comme null, efface chaque substitution.
NotificationTelegramChat — obligatoires: none
Telegram seulement ; obligatoire pour lui. La conversation où publier : son identifiant numérique (négatif pour un groupe ou un canal) ou @channelname. Ce n’est pas un identifiant secret.
NotificationUnsubscription — obligatoires: user_id, at
NotificationWrite — obligatoires: channel
email envoie aux destinataires, webhook envoie un POST signé à url, et slack, teams, pagerduty et telegram publient un message par panne et par écran dans une messagerie ou un outil d’astreinte avec le destination en écriture seule (telegram exige aussi telegram_chat_id), puis un rétablissement ensuite ; PagerDuty ouvre un incident et le résout. Ils exigent au moins une condition et n’acceptent pas event_types.
OAuthAuthorization — obligatoires: id, client_name, client_registered, redirect_host, access, capabilities, created_at, expires_at
OAuthAuthorizationRedirect — obligatoires: redirect_uri
OAuthError — obligatoires: error
OAuthTokenResponse — obligatoires: access_token, token_type, expires_in
OnboardingSiteCTA — obligatoires : label, path, href, at
Le lien d’inscription ou de connexion du site web sur lequel la personne a cliqué.
OnboardingSiteVisit — obligatoires : path, at
OnboardingStepName — obligatoires: none
Une étape des flux d’entrée, dans l’ordre d’affichage. email_verified, email_gate_reached et les jalons du compte (agent_connected, screen_paired, playlist_with_content, activated) sont écrits ou joints par le serveur et ne sont pas des noms qu’un client envoie.
OnboardingStepRequest — obligatoires : journey_id, step
OnboardingValue — obligatoires: none
Ce que la personne a saisi à une étape : l’adresse tapée (email_submitted, reset_requested), le nom (signup_name_entered), oui ou non (signup_marketing_choice), les options choisies ou le texte de suivi (question_answered, question_follow_up), une adresse ou un nom saisis dans une invitation. Jamais un mot de passe, un code ni un jeton. Une valeur vide équivaut à une valeur absente.
Operation — obligatoires: id, kind, state, created_at, updated_at
OperationAccepted — obligatoires: id, release_id, operation_id
OrganizationAdminInvitation — obligatoires: id, kind, delivery, status, recipient_email, organization_id, created_at, expires_at
OrganizationAdminInvitationCreate — obligatoires: emails
OrganizationAdminInvitationCreated — obligatoires: invitations
OrganizationAdminInvitationList — obligatoires: items, next_cursor
OrganizationAdmins — obligatoires: admins, candidates, revision
OrganizationAdminsUpdate — obligatoires: admin_user_ids
OrganizationBillingUsage — requis : org_id, period, pool, allowance, stored_bytes, screens, projects, next_cursor
OrganizationDomainChallenge — obligatoires: organization_id, challenge_id, domain, name, value, expires_at
OrganizationDomainInput — obligatoires: domain
OrganizationDomainProof — obligatoires: challenge_id
OrganizationDomainRemoved — obligatoires: status
OrganizationGuestPolicy — obligatoires: mode, domains
La politique relative aux invités de l’organisation en vigueur. Les invités sont les personnes dont l’organisation d’appartenance est une autre, ou qui n’en ont aucune ; une politique ne retire jamais une personne qui est déjà membre.
OrganizationGuestPolicyDomain — obligatoires: none
Un nom DNS en minuscules d’au moins deux étiquettes, tel qu’il apparaît après le @ d’une adresse courriel vérifiée (les noms internationalisés sous leur forme xn--).
OrganizationGuestPolicyMode — obligatoires: none
allow admet tous les invités. domains admet un invité dont l’adresse courriel vérifiée se trouve dans l’un des domaines énumérés (correspondance exacte). none n’admet aucun invité. Les membres de l’organisation ne sont jamais des invités.
OrganizationGuestPolicyResult — obligatoires: mode, domains, outside_policy
La politique relative aux invités maintenant en vigueur, avec le nombre de personnes qu’elle laisse à l’extérieur.
OrganizationGuestPolicyUpdate — obligatoires: mode
OrganizationLibraryUpdate — obligatoires: project_id
OrganizationList — obligatoires: organizations, new_organization_allowed
OrganizationMemberInvitation — obligatoires: id, kind, delivery, status, recipient_email, organization_id, created_at, expires_at
OrganizationMemberInvitationCreate — obligatoires: emails
OrganizationMemberInvitationCreated — obligatoires: invitations
OrganizationMemberInvitationList — obligatoires: items, next_cursor
OrganizationNotificationList — obligatoires: items
OrganizationNotificationPatch — obligatoires: none
Un NotificationPatch et project_ids.
OrganizationNotificationWrite — obligatoires: channel
Un NotificationWrite et les projets que couvre la notification. Un project_ids absent ou null couvre tous les projets de l’organisation, y compris ceux ajoutés plus tard; une liste couvre exactement ces projets, chacun étant un projet actif de l’organisation.
OrganizationPayments — obligatoires: organization_id, available, local_simulation, purchases
OrganizationPeople — obligatoires: projects, people, truncated
OrganizationPeopleMembership — obligatoires : project_id, role, can_approve
OrganizationPeoplePerson — obligatoires: user_id, display_name, email, admin, member, managed, outside_guest_policy, projects
OrganizationPeopleProject — obligatoires: project_id, name
OrganizationPerson — obligatoires: user_id, display_name, email
OrganizationPersonal — obligatoires: none
L’organisation n’est que l’enveloppe de son unique projet : exactement un projet actif, aucun domaine vérifié, aucun forfait d’organisation actuel ou prévu, et aucun administrateur autre que le propriétaire de ce projet. Le tableau de bord masque le niveau organisation pour elle.
OrganizationProject — obligatoires: id, name, organization_id, status, screen_count
OrganizationProjectAccess — obligatoires: project_id, joined
OrganizationProjectAccessChange — obligatoires : project_id, user_id, access
OrganizationProjectAccessRequest — obligatoire : changes
OrganizationProjectAccessResult — obligatoire : changes
OrganizationProjectOwner — obligatoires: project_id, owner_user_id
OrganizationProjectOwnerUpdate — obligatoires: user_id
OrganizationProjectPage — obligatoires: projects, next_cursor
OrganizationRename — obligatoires: name
OrganizationSummary — obligatoires: id, name, personal
OrganizationView — obligatoires: id, name, personal, revision, admin, home, project_count, plan_id, free, plan_required, education_eligible, education_eligibility_source
PageDataCondition — obligatoires: key
Un prédicat de données de carte, évalué avant l’heure civile. Les données manquantes ou expirées ne correspondent jamais. La page respecte aussi ses bornes temporelles ordinaires. Nécessite la capacité hôte page.conditions ; les hôtes plus anciens reçoivent la page désactivée.
PageFailure — obligatoires: page_id, code, at
Dernier rapport playback.page_failed accepté pour cet écran. Absent jusqu’à ce qu’un lecteur en rapporte un. Métadonnées de santé du projet en lecture seule ; ne modifie pas la révision d’écran ni l’autorité du manifeste.
PageVisibility — obligatoires: enabled
Programmation optionnelle de visibilité de page. C’est un frère de advance et ne fait jamais partie de screenrig.canvas/v1 ; il décrit l’orchestration de lecture, pas la géométrie. Le serveur valide et porte ces règles comme données. Le player les évalue selon le fuseau horaire de l’écran publié à la racine du manifeste.
Une page est admissible lorsque enabled est vrai, que now est dans [from, until), et que windows est absent ou qu’au moins une fenêtre correspond. Chaque liste de lecture doit conserver au moins une page sans champ de visibilité, donc du contenu admissible existe toujours. Les vecteurs de conformité pour les règles d’évaluation sont la famille screenrig.schedule/v1 dans packages/schedule-contract.
PageVisibilityWindow — obligatoires: days
Une fenêtre civile récurrente. Omettre start et end sélectionne toute la journée. Quand end est inférieur ou égal à start, la fenêtre traverse minuit et le jour de début en est propriétaire, donc ven 22:00 à 02:00 couvre le samedi matin.
PairScreen — obligatoires: code
PairingClaim — obligatoires: screen, public_url
PairingClaimedEvent — obligatoires: type, completion_nonce
PairingComplete — obligatoires: completion_nonce
PairingCompletion — obligatoires: screen, public_url
PairingSession — obligatoires: code, expires_at
PasskeyAdditionProof — obligatoires: authorization_ceremony_id, authorization_credential
PlaybackAggregate — obligatoires: screen_id, media_id, filename, day, play_count, last_page_id, last_manifest_revision, first_started_at, last_started_at
PlaybackAggregateCsv — obligatoires: none
CSV RFC 4180, enregistrements CRLF, UTF-8, avec la ligne d’en-tête screen_id,media_id,filename,primitive,day,play_count,last_page_id,last_manifest_revision,first_started_at,last_started_at. Les heures sont en UTC RFC 3339. Une cellule commençant par =, +, -, @, tabulation ou retour chariot est préfixée d’une apostrophe simple pour que les tableurs ne l’évaluent pas.
Content-Disposition nomme playback-aggregates.csv. Un flux qui échoue après l’en-tête est interrompu à la connexion.
PlaybackAggregateList — obligatoires: items
PlaybackApplicationStartedContext — obligatoires: manifest_revision, page_id, primitive_id, release_id
PlaybackApplicationStartedReport — obligatoires: severity, code, context
Un début visible d’un primitif d’application sur une page : l’application est devenue visible à l’écran, rapportée une fois par apparition de page par le contrôleur Player — le contenu de l’application ne rapporte jamais sa propre visibilité, et un téléchargement de paquet n’est jamais un début.
L’écran émetteur est authentifié ; les identités page, primitive, release et manifest sont des observations rapportées sans contenu ni vérification d’appartenance. Stocke un enregistrement durable par lecture (GET /api/playback/plays). Les horodatages de maintenance release/application appartenant au projet suivent via une projection par lots récupérable.
Les accusés de réception de lecture ordinaires omettent les en-têtes optionnels de solde de crédits. Il n’y a pas de ligne d’agrégation quotidienne pour les démarrages d’application ; les enregistrements de lecture en sont la preuve.
PlaybackCompleteness — obligatoires : day_from, day_to, measured_plays, missing_plays, completeness, days, gaps, truncated
Parmi les lectures effectuées par les écrans, combien sont parvenues au backend, sur les jours UTC compris entre day_from et day_to, bornes incluses. measured_plays et missing_plays sont les sommes de days, et completeness est measured_plays divisé par leur somme, null lorsque les deux valent 0. days liste, du plus ancien au plus récent, uniquement les jours comptant une lecture mesurée ou manquante. gaps liste les trous de la numérotation des lectures, du plus récent au plus ancien.
Les lectures sans numéro (anciens Players, débuts de lecture enregistrés avant les numéros de lecture) ne figurent dans aucun de ces chiffres.
PlaybackCompletenessDay — obligatoires : day, measured_plays, missing_plays, completeness
La numérotation des lectures d'un jour de réception UTC.
PlaybackCompletenessShare — obligatoires: none
Rapport entre les lectures arrivées et la somme des lectures arrivées et des lectures manquantes, de 0 à 1. null lorsqu'il n'y a ni lectures arrivées ni lectures manquantes, comme pour les anciens Players qui ne numérotent aucune lecture.
PlaybackGap — obligatoires : screen_id, day, from, to, missing_plays
Une suite de numéros de lecture qu'un Player a sautés; autant de lectures ont donc été effectuées sans jamais arriver.
PlaybackGrant — obligatoires: none
La poignée de lecture accordée par le backend : l’intersection de PlaybackHandshake de la création et de ce que ce backend supporte, connecté à la session. Omise de la session quand rien ne s’intersecte, donc une session créée sans poignée reste inchangée. Un lecteur utilise /screen/manifest seulement quand manifest_versions contient 3.
PlaybackHandshake — obligatoires: none
Poignée de lecture optionnelle qu’un Player déclare à mint. C’est un indice qui sélectionne un comportement, jamais une autorisation : les membres inconnus et les entrées du mauvais type sont ignorés, et une valeur qui n’est pas un objet ne négocie rien. La réponse mint renvoie l’intersection prise en charge comme PlaybackGrant. adslot-v1 est accordé uniquement aux sessions jumelées.
PlaybackMediaStartedContext — obligatoires: media_id, manifest_revision, page_id, primitive
PlaybackMediaStartedReport — obligatoires: severity, code, context
Un début visible d’un primitif image ou vidéo sur une page. Les Players envoient ceci une fois par apparition de page du média, pour les images exactement comme pour les vidéos ; les boucles dans une même apparition ne sont pas des redémarrages. L’écran envoyeur est authentifié ; les identités média, page, primitif et manifeste sont des observations sans contenu ni vérification d’appartenance à une autorisation.
Le succès reconnaît l’insertion brute durable ; les comptes quotidiens suivent via une projection par lots récupérable. Les accusés de lecture ordinaires omettent les en-têtes facultatifs de solde de crédits.
PlaybackPageFailedContext — obligatoires: page_id, code
PlaybackPageFailedReport — obligatoires: severity, code, context
Signale qu’une page n’a pas pu être prête. Lors de l’acceptation, le serveur remplace Screen.last_page_failure et ajoute un événement durable playback.page_failed propre au projet dans la même transaction. Cela ne modifie pas la révision de l’écran ni l’autorité du manifeste.
PlaybackPlay — obligatoires: screen_id, page_id, media_id, primitive, received_at
Un démarrage durable rapporté par Player d’une image, vidéo ou application.
La session authentifie écran et projet ; les identités item, page, manifest, primitive et release sont des observations rapportées et n’autorisent pas l’accès au contenu. playlist_id et playlist_revision sont des métadonnées optionnelles enrichies de manière asynchrone à partir d’un manifeste d’écran correspondant ; les métadonnées manquantes restent absentes.
Les démarrages d’application portent release_id avec media_id et primitive vides. primitive_id et started_at sont présents uniquement quand le Player les rapporte ; started_at est limité à [received_at - 24h, received_at + 5m].
Une page JSON nomme aussi son écran, son média, sa liste de lecture et son application sous forme de texte d’affichage lu lorsque la page est servie ; l’exportation CSV ainsi que les rapports xlsx et pdf omettent ces noms.
PlaybackPlayCsv — obligatoires: none
CSV RFC 4180, enregistrements CRLF, UTF-8, avec la ligne d’en-tête screen_id,playlist_id,page_id,primitive_id,media_id,primitive,started_at,received_at,manifest_revision,playlist_revision dans cet ordre fixe ; une valeur absente est une cellule vide. Les heures sont en UTC RFC 3339. Une cellule commençant par =, +, -, @, tabulation ou retour chariot est préfixée d’une apostrophe simple.
Content-Disposition nomme playback-plays.csv. Une exportation complète se termine après son dernier enregistrement CRLF sans remorque ; un flux qui échoue après l’en-tête est interrompu à la connexion (le client voit une erreur de transport, jamais une fin propre), donc réessayez à partir du dernier received_at.
PlaybackPlayList — obligatoires: items, next_cursor
PlaybackTotals — obligatoires: by, day_from, day_to, truncated
Totaux de lecture sur les jours UTC inclusifs day_from à day_to. Exactement un des éléments jours (par=jour), écrans (par=écran), médias (par=média) ou screen_days (par=screen_day, groupé par écran en ordre de classement, jours croissants) est présent, celui nommé dans la requête. truncated est vrai lorsqu’un classement peut omettre des clés classées en dessous du meilleur d’une tranche ou d’un magasin.
PlaybackTotalsDay — obligatoires: day, play_count, first_started_at, last_started_at
PlaybackTotalsMedia — obligatoires: media_id, play_count, first_started_at, last_started_at
PlaybackTotalsScreen — obligatoires: screen_id, play_count, first_started_at, last_started_at
PlaybackTotalsScreenDay — obligatoires: screen_id, day, play_count
PlaybackVideoStartedContext — obligatoires: media_id, manifest_revision, page_id
PlaybackVideoStartedReport — obligatoires: severity, code, context
Signaler un démarrage visible de vidéo. Cela utilise la même agrégation quotidienne que playback.media_started avec vidéo primitive. Envoyez un rapport par démarrage ; envoyer les deux types d’événements compte le démarrage deux fois. Utilisez playback.media_started pour signaler à la fois images et vidéos.
PlayerBrowserIdentity — obligatoires: kind, version, pwa
Moteur de navigateur et mode d’installation pour les Players navigateur, y compris les shells natifs. Un indice de navigateur optionnel mal formé est ignoré sans rejeter la demande.
PlayerCardsIdentity — obligatoires: none
La bibliothèque de cartes intégrée que le lecteur porte (docs/player-compatibility.md §3.1) : la version CalVer de la bibliothèque et le semver de chaque carte, dont la majeure indique quelles positions de carte l’écran rend. Stocké sur l’écran avec le reste du lecteur. Les entrées malformées sont supprimées une par une ; ce n’est jamais un 400.
PlayerIdentity — obligatoires: kind
Auto-identification du lecteur, envoyée uniquement sur les trois itinéraires mint (docs/player-compatibility.md §3.1). C’est un indice et jamais une autorisation, et ce n’est pas couvert par la preuve native. Elle est lue avec tolérance : les membres inconnus sont ignorés, un membre optionnel invalide est supprimé seul, et un lecteur qui n’est pas un objet ou n’a pas de type valide ne déclare rien.
Ce n'est jamais un 400. Un mint jumelé le stocke sur l'écran pour l'histogramme de la flotte d'opérateurs.
PlayerPublicKey — obligatoires: kty, crv, x
PlayerShellIdentity — obligatoires: kind
Le shell sous lequel un lecteur Web s’exécute. Ses jetons de compatibilité sont enregistrés, jamais accordés. Un type invalide abandonne le shell.
Playlist — obligatoires: id, name, revision, pages
PlaylistAdvance — obligatoires: none
PlaylistAdvanceWrite — obligatoires: none
PlaylistApplicationAdvance — obligatoires: mode, max_ms
PlaylistApplicationPrimitive — obligatoires: id, primitive, release_id, rect, layer, content_fit
PlaylistApplicationPrimitiveWrite — obligatoires: id, primitive, release_id, layer, content_fit
PlaylistApproval — obligatoires: state, review_id
Présent pendant qu’une révision de cette liste de lecture est en attente. La liste de lecture elle-même est la version en direct (approuvée).
PlaylistAudio — obligatoires: tracks, loop, volume
Bande sonore de liste de lecture stockée avec valeurs par défaut remplies.
PlaylistAudioCue — obligatoires: track
Indice optionnel de bande sonore sur une page ordinaire. Quand la page devient courante, le Player passe à la piste nommée depuis son début sauf si elle joue déjà ; restart true la redémarre même alors. La séquence continue depuis cette piste.
Les lecteurs peuvent ignorer un indice. track doit nommer un identifiant de piste dans l’audio de la liste de lecture ; un cue sans audio de liste de lecture est invalid_request. Non autorisé sur les pages adslot. Une page avec mode avancé audio_end se termine quand la piste indiquée se termine ; elle nécessite ce cue.
PlaylistAudioEndAdvance — obligatoires: mode, max_ms
PlaylistAudioEndAdvanceWrite — obligatoires: mode
La page se termine lorsque la piste de bande sonore nommée audio_cue se termine. La page doit porter un audio_cue et la liste de lecture une bande sonore audio (docs/playlist-audio.md).
PlaylistAudioTrack — obligatoires: id, media_id
PlaylistAudioWrite — obligatoires: tracks
Bande sonore optionnelle de la liste de lecture : médias audio prêts ordonnés (MP3) qui jouent continuellement pendant que les pages changent (docs/playlist-audio.md). Les changements de page ne l’arrêtent ni ne le redémarrent jamais. PUT remplace toute la liste de lecture, donc omettre l’audio supprime la bande sonore.
PlaylistCanvas — obligatoires: width, height, background
PlaylistCardPrimitive — obligatoires: id, primitive, card, major, params, rect, layer, content_fit, controller
PlaylistCardPrimitiveWrite — obligatoires: id, primitive, card, layout, content_fit
Une carte intégrée que le Lecteur dessine nativement (horloge, météo, tableau de menu, bandeau, tuiles KPI et le reste du catalogue de cartes vendues, screenrig.cards.contract/v1). layout la place : full (tout le canevas), free (votre propre rectangle et couche), center (900 x 420), wide (le canevas avec un retrait de 30 à gauche et à droite et 80 en haut et en bas), header (tout le bord supérieur, 80 de haut), footer (tout le bord inférieur, 80 de haut), corner (270 carré), chip (240 x 70) ou strip (tout le bord, 120 de haut), en unités de design 1080p mises à l’échelle par min(largeur canevas, hauteur canevas) / 1080. corner et chip prennent un coin d’ancrage (haut-gauche, haut-droit, bas-gauche, bas-droit) et strip un bord d’ancrage (haut, bas, gauche, droite) ; les autres mises en page n’en prennent pas.
Sauf pour gratuit, le serveur dérive rect et layer du canevas, ou des affichages du cadre cover : omettez-les, ou envoyez exactement ce qu’il dérive.
Une page contient au maximum une carte pleine, centrale ou large, une carte d’angle ou puce par coin, et une bande par bord (une carte avec présence peut partager un bord avec une bande normale) ; un en-tête prend la place de la bande normale du bord supérieur et un pied de page celle du bord inférieur, donc une page contient au maximum un de chaque, pas de bande normale sur ce bord, et une carte avec présence peut toujours la partager.
Un coin ou éclat sur un bord qui maintient une bande avance de 120 au-delà, et de 80 au-delà d’un en-tête ou pied de page.
Sur une playlist avec un format, displays est le cadre dont la mise en page dérive (full est le cadre, corner le coin du cadre ; free refuse displays), l’échelle de la carte est la min(largeur, hauteur) de la tuile / 1080 = 1 plutôt que dérivée du cadre, et deux cartes se disputent une place, ou se déplacent dans les bandes l’une de l’autre, seulement lorsque leurs cadres partagent un affichage (no displays est chaque affichage).
Le niveau d'une carte détermine ses dispositions (GET /api/card-types) : core accepte les neuf, fullscreen accepte full. params contient les propriétés statiques du placement (thème, emplacement, titres, définitions de colonnes) et ne change qu'avec une republication.
Une chaîne de params peut contenir {screen.name}, {screen.timezone} et {screen.field.NAME}, et un paramètre location peut être la chaîne {screen.location}; le backend les remplace pour chaque écran, de sorte qu'une même liste de lecture affiche à chaque écran ses propres valeurs. data désigne un document de données de carte (GET/PUT /api/card-data/{key}) qui contient les propriétés dynamiques de la carte (sections de menu, éléments de bandeau défilant, tuiles d'indicateurs clés); les agents le modifient sans republication. {screen.field.NAME} dans une clé de données lit un document propre à chaque écran, par exemple menu-{screen.field.store_number}.
Avec des données, les paramètres ne peuvent pas contenir de propriétés dynamiques ; sans données, les paramètres contiennent toute la configuration. Chaque chaîne dans les paramètres qui commence par media: est une référence média, media:<id>, désignant une image prête dans ce projet que la carte affiche (spotlight people[].photo, product-grid products[].photo) ; une carte ne prend jamais une URL d’image.
La publication refuse une carte inconnue ou des paramètres majeurs invalides (card_invalid), une mise en page, ancre, rectangle ou couche que la carte ne peut porter (card_layout_invalid), des cartes qui revendiquent un même emplacement sur la page (card_layout_conflict), une référence média qui ne nomme aucune image prête du projet (card_media_invalid), et une clé liée dont le document stocké est rejeté par la carte (card_data_invalid).
Les écrans affichant le placement reçoivent ses médias, et une écriture en direct approuve les médias en attente qu’elle nomme, comme avec un sélecteur by:id. Une carte avec un flux tiers (météo) le lit depuis la clé dérivée par le serveur de ses paramètres statiques.
PlaylistCreateRequest — obligatoires: none
Les pages d'une liste de lecture, un modèle à partir duquel la créer, ou le modèle de départ intégré.
PlaylistDisplays — obligatoires: none
Listes de lecture avec un format uniquement. Les afficheurs qu’une primitive couvre : des numéros d’afficheur uniques croissants à base 1 dans 1..format.displays qui remplissent un rectangle des tuiles du mur, tels que [2], [1, 2] ou, sur une grille de 4 colonnes, [2, 3, 6, 7]. Dans une rangée ou une colonne, ils sont contigus.
Le serveur déduit rect comme le rectangle englobant de ces tuiles ; rect est omis ou correspond exactement à la valeur déduite. Stocké et renvoyé à la lecture.
PlaylistDurationAdvance — obligatoires: mode, after_ms
PlaylistExpandRequest — obligatoires: none
PlaylistExpanded — obligatoires: pages
PlaylistFormat — obligatoires: none
Ce pour quoi une liste de lecture est conçue : un mur vidéo (PlaylistWallFormat) ou une région (PlaylistRegionFormat), jamais les deux. Une liste de lecture sans format est une liste de lecture ordinaire qui se lie à n’importe quel écran comme page.
PlaylistFromTemplate — obligatoires: playlist_id
Crée une liste de lecture à partir d'un modèle : ses pages actuelles avec les valeurs renseignées, validées par toutes les règles des listes de lecture. Une valeur média doit être un média prêt du bon type, une valeur d'adresse une adresse http ou https.
PlaylistFromTemplateWrite — obligatoires: name, from_template
Crée une liste de lecture à partir d'un modèle. Envoyez seulement name et from_template.
PlaylistIframePrimitive — obligatoires: id, primitive, src, title, rect, layer, content_fit, controller
PlaylistIframePrimitiveWrite — obligatoires: id, primitive, src, title, layer, content_fit
PlaylistImagePrimitive — obligatoires: id, primitive, selector, resolved_media, rect, layer, content_fit, controller
PlaylistImagePrimitiveWrite — obligatoires: id, primitive, selector, layer, content_fit
PlaylistInstance — obligatoires: id, name, revision, template_revision, outdated
PlaylistInstanceList — obligatoires: items
PlaylistIntrinsicSize — obligatoires: width, height
PlaylistList — obligatoires: items
PlaylistMediaEndAdvance — obligatoires: mode, max_ms
PlaylistMediaEndAdvanceWrite — obligatoires: mode
PlaylistMediaSelector — obligatoires: none
PlaylistMediaSelectorByAll — obligatoires: by
PlaylistMediaSelectorByFolder — obligatoires: by, folder_id
Les fichiers prêts du primitif directement à l’intérieur d’un dossier média (GET /api/media-folders), pas ceux de ses sous-dossiers, ordonnés et cadencés comme par :all. Comme une étiquette, le dossier est relu à chaque résolution de sélecteur, donc déplacer des fichiers dedans ou dehors change ce que les écrans en lecture affichent à leur prochaine boucle.
L’écriture d’une liste de lecture exige que le dossier existe dans le projet ; il peut être vide. Un dossier qui ne contient aucun fichier prêt du primitif, ou est supprimé plus tard, ne correspond à rien. Les lecteurs le reçoivent comme by:all ; le serveur résout le dossier.
PlaylistMediaSelectorByID — obligatoires: by, media_id
PlaylistMediaSelectorByIDs — obligatoires: by, media_ids
PlaylistMediaSelectorByTag — obligatoires: by
PlaylistPage — obligatoires: id, canvas, transition, advance, primitives
PlaylistPageAdd — obligatoires: page
PlaylistPageStructure — obligatoires: id
Une page qui reste, et les deux réglages de page qu’une personne modifie. advance remplace l’avance de la page quand présente et la conserve quand omise ; une page de slot publicitaire n’en a pas. visibility remplace la visibilité de la page quand un objet, la supprime quand null et la conserve quand omise.
Un objet visibilité qui ne définit que enabled true est une opération nulle et est rejeté : envoyez null pour supprimer les règles.
PlaylistPageV2 — obligatoires: none
PlaylistPageWrite — obligatoires: id, canvas, transition, advance, primitives
PlaylistPageWriteV2 — obligatoires: none
PlaylistPatch — obligatoires: none
Les champs omis sont conservés. Le nom, les pages, l’audio et le format fournis remplacent ces valeurs de premier niveau ; audio ou format null les supprime. Les pages fournies sont vérifiées par rapport au format stocké lorsque le format est omis, et un format fourni par rapport aux pages stockées lorsque les pages sont omises. Identité, révision, commentaires et horodatages ne peuvent pas être définis ici.
Les commentaires ont leurs propres points de terminaison.
PlaylistPrimitive — obligatoires: none
PlaylistPrimitiveLocked — obligatoires: none
Une primitive verrouillée est un contenu de marque fixe d'un modèle (logo, arrière-plan, disposition, thème) : seul le propriétaire du projet ou un membre qui peut approuver l'ajoute, la retire, la déplace ou la modifie, ou lève son verrou, et une liste de lecture créée à partir du modèle la garde verrouillée. Omise, elle n'est pas verrouillée. Une primitive verrouillée ne peut lire aucun champ.
Une écriture par toute autre personne est primitive_locked (403), ou une révision sous Propose.
PlaylistPrimitiveWrite — obligatoires: none
PlaylistRect — obligatoires: x, y, width, height
PlaylistRegionFormat — obligatoires : region, orientation
Une bande dessinée par-dessus la page le long d’un bord d’un affichage : un header en haut, un footer en bas, un side sur le bord droit, sur toute la hauteur. orientation est l’orientation de l’affichage pour lequel elle est conçue, telle que la voit le spectateur après rotation.
Toutes les pages ont le même canevas (width et height) ; un header ou un footer est plus large que haut et un side plus haut que large, le grand côté valant au moins le double du petit, sinon 400 invalid_request à pages[i].canvas.
La liste de lecture ne contient que des primitives d’image et de carte (une page de vidéo, de flux, d’iframe, d’application ou d’emplacement publicitaire est refusée) et n’a pas de bande sonore (l’audio est refusé) ; une primitive ne nomme aucun affichage.
Une liste de lecture de région n’est jamais une liste par défaut d’écran, une liste par défaut de dossier ni une prise de contrôle : elle joue comme entrée de programmation ou comme campagne avec covers réglé sur sa région (covers avec main ou full la refuse), et covers header, footer ou side exige une liste de lecture de cette région.
L’entrée ou la campagne est refusée avec 409 playlist_format_mismatch quand la bande n’est disposée sur aucun des affichages qu’elle cible : une bande est disposée sur un affichage de son orientation, jugée sur la surface que le Player rapporte après rotation (la rotation du mur de l’écran quand il n’en a pas rapporté), et seulement si elle ne couvre pas plus de la moitié de l’affichage (sa hauteur pour un header ou un footer, sa largeur pour un side).
Une campagne n’est refusée que si elle n’est disposée sur aucun des écrans de son audience ; sur un écran d’une audience mixte où elle ne l’est pas, la campagne quitte la pile de cet écran et son explication indique region_not_laid_out.
Un changement de format qui fait entrer une liste de lecture dans une région, la fait en sortir ou la fait passer à une autre région est refusé avec 409 resource_conflict tant qu’une programmation d’écran, une prise de contrôle ou une liste par défaut, une liste par défaut de dossier ou une campagne l’utilise.
PlaylistResolvedMedia — obligatoires: media_id, intrinsic_size
PlaylistRevision — obligatoires: 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).
Une valeur que ce lecteur ne connaît pas est lue comme edited.
PlaylistRevisionAuthor — obligatoires: type, name
Qui a fait la révision, tel que le journal d’événements du projet les nomme ; absent lorsque l’écriture n’a nommé personne (une base de référence, ou un travail du système).
PlaylistRevisionDetail — obligatoires: revision, playlist
PlaylistRevisionList — obligatoires: items
PlaylistStarterWrite — obligatoires: starter
Ajoute le modèle intégré Avis urgent (un titre et un message). Envoyez seulement starter, et éventuellement name.
PlaylistStinger — obligatoires: none
Une carte stinger de transition seule (majeure 1). Tous les membres sont optionnels ; les valeurs par défaut restent dans le placement d’exécution synthétique. hang_ms par défaut à 1000 et au maximum 60 % de la duration_ms de transition (vérifié par le serveur). logo nomme une image prête dans ce projet, utilisant le chemin d’autorisation des médias de la carte.
PlaylistStreamPrimitive — obligatoires: id, primitive, sources, fallback_media_id, rect, layer, content_fit, muted, controller, resolved_media
PlaylistStreamPrimitiveWrite — obligatoires: id, primitive, sources, fallback_media_id, layer, content_fit
PlaylistStructurePatch — obligatoires: none
La structure d’une liste de lecture et rien de ce qu’une page affiche (patchPlaylistStructure). Les membres omis sont conservés. Un nom fourni remplace le nom. Des pages fournies sont le nouvel ordre complet des pages que la liste de lecture contient : une page stockée omise est supprimée.
Le contenu de la page (canevas, transition, audio_cue, primitives, commentaires) et la bande sonore ne peuvent pas être envoyés et sont toujours ceux stockés.
PlaylistTemplateField — obligatoires: name, label, type
Une valeur que prend un modèle. Les pages la lisent sous la forme {field.NAME} : dans les params d'une carte (champs texte et adresse), comme media_id du sélecteur d'une image ou d'une vidéo (champ média) ou comme src entier d'un iframe (champ adresse).
PlaylistTemplateFields — obligatoires: none
Déclarer des champs fait de la liste de lecture un modèle. Chaque jeton lu par une page doit nommer un champ déclaré du bon type et chaque champ doit être lu ; une liste de lecture sans champs ne lit aucun jeton. Un modèle n'est jamais affiché sur un écran (playlist_is_template). Un PUT sans fields les conserve ; null ou un tableau vide les retire.
PlaylistTransition — obligatoires: type, duration_ms
Transition de page. type et duration_ms sont tous deux requis ; OpenAPI ne les définit pas par défaut. Les exemples d’auteur de balayage utilisent duration_ms 600 ; cette valeur n’est pas une valeur par défaut du schéma.
PlaylistV2 — obligatoires: id, name, revision, pages
PlaylistV2List — obligatoires: items
PlaylistValuesChange — obligatoires: values
PlaylistVideoPrimitive — obligatoires: id, primitive, selector, resolved_media, muted, loop, rect, layer, content_fit, controller
PlaylistVideoPrimitiveWrite — obligatoires: id, primitive, selector, layer, content_fit
PlaylistWallFormat — obligatoires: displays, arrangement, orientation
Le mur vidéo pour lequel une playlist est créée : de 2 à 12 afficheurs, des tuiles de 1920 x 1080 (paysage) ou 1080 x 1920 (portrait), disposées en rangée, en colonne ou en grille. Une rangée a les afficheurs en colonnes et une seule rangée, une colonne a une seule colonne et les afficheurs en rangées, une grille a columns colonnes et displays / columns rangées.
L’afficheur n se trouve à la colonne (n - 1) mod columns et à la rangée floor((n - 1) / columns) : de gauche à droite, puis de haut en bas.
La toile de c colonnes et r rangées de tuiles de largeur w et hauteur h est (c * w, r * h), par exemple 5760 x 1080 pour 3 afficheurs paysage en rangée, 1080 x 3840 pour 2 afficheurs portrait en colonne et 7680 x 3240 pour 12 afficheurs paysage dans une grille de 4 colonnes.
La largeur et la hauteur du canevas de chaque page ordinaire doivent lui correspondre exactement, sinon 400 invalid_request à pages[i].canvas. L’échelle de la carte sur une telle liste de lecture est la min(largeur, hauteur) de la tuile divisée par 1080 = 1.
Une liste de lecture avec un format ne peut se lier qu’à un écran dont le mur a la même forme (afficheurs = nombre de sorties, disposition, colonnes, portrait si et seulement si la rotation est 90 ou 270), sinon 409 playlist_format_mismatch : affectation, affectation de flotte, entrées de programmation et prise de contrôle. Une liste de lecture sans format se lie à n’importe quel écran.
PlaylistWarning — obligatoires: code, message, page_id, primitive_id
Quelque chose sur quoi l’auteur d’une écriture réussie devrait agir. L’écriture a stocké ce qu’elle portait ; un avertissement ne la fait jamais échouer. Une écriture de liste de lecture répond avec des avertissements sur la liste de lecture ; une écriture d’écran (updateScreen, les routes de champs, d’emplacement et de liste de lecture du tableau de bord) sur l’écran ; une assignation de flotte sur la page de résultats.
Deux codes. iframe_framing_refused : une page https publique nommée par une primitive iframe (son src ou son fallback_src) envoie X-Frame-Options (DENY, SAMEORIGIN ou l’obsolète ALLOW-FROM) ou une liste frame-ancestors de Content-Security-Policy qui n’admet pas l’origine de l’application Web du Player.
Le Player web et les Players macOS, Samsung Tizen, LG webOS et BrightSign encadrent la page et ne peuvent donc pas l’afficher ; les Players Android, Linux et Windows ouvrent une page iframe entière et ne sont pas touchés.
Le backend lit les en-têtes de réponse après la validation de l’écriture, pour au plus 8 pages distinctes par écriture ; une page inaccessible à temps ou qui répond par une erreur n’est pas signalée. Chaque page distincte apparaît une fois, avec la première primitive qui l’utilise, et ajoute un événement playlist.iframe_framing_refused (avertissement) au journal du projet.
Un src avec des jetons d’écran n’est pas une seule page et n’est pas lu. screen_fact_missing : un écran que l’écriture atteint n’a pas une valeur que lit le src d’un iframe ou les params d’une application par un jeton d’écran ({screen.field.NAME}, {screen.location.…}, {screen.timezone}), ou les valeurs qu’il a forment une adresse que le manifeste refuse (une adresse de plus de 2048 caractères, un segment de chemin . ou .., des params de lancement de plus de 4096 caractères dans l’URL de lancement), de sorte que la primitive est omise du manifeste de cet écran (diagnostic de manifeste screen_fact_missing ou screen_fact_invalid) jusqu’à ce que l’écran ait la valeur.
Un avertissement par écriture nomme la première primitive de ce type, les jetons qu’aucun écran listé n’a pu remplir (au plus 64), les 20 premiers écrans touchés et leur nombre.
Une écriture de liste de lecture (un remplacement, un patch, un changement de structure, une promotion ou une revue appliquée) atteint les écrans qui affichent la liste de lecture ; une écriture d’écran atteint cet écran, pour la liste de lecture qu’il affiche et celle qui vient de lui être assignée ; une assignation de flotte atteint les écrans de sa page ; l’approbation d’un changement d’écran atteint les écrans qu’il nomme.
PlaylistWrite — obligatoires: name, pages
PlaylistWriteV2 — obligatoires: name, pages
PrimitiveEnter — obligatoires: type
Entrée d’objet optionnelle. L’écriture de liste de lecture et le manifeste d’exécution utilisent cet objet tel quel ; il n’y a pas de renommage snake_case à l’intérieur. Absent signifie peinture au repos, opacité complète. L’entier optionnel stagger 0 à 8 retarde le démarrage de stagger*120 ms après le délai partagé de 500 ms. Absent ou 0 est le démarrage d’aujourd’hui. La durée est une constante nommée dans screenrig.canvas/v1.
PrimitiveMotion — obligatoires: none
Mouvement d’objet persistant optionnel. L’écriture de liste de lecture et le manifeste d’exécution utilisent cet objet tel quel ; il n’y a pas de renommage snake_case à l’intérieur. Absent signifie que le primitif reste au repos après l’entrée.
Copié sans interpolation. spin et drift s’appliquent uniquement à l’image et à la vidéo ; application et iframe avec spin ou drift sont rejetés par le serveur (motion_not_allowed_for_primitive). path s’applique à l’image, la vidéo, l’application et l’iframe. Cette restriction n’est pas codée en OpenAPI if/then.
PrimitiveMotionDrift — obligatoires: type, zoom, direction, speed
Mise à l’échelle lente continue autour du centre du clipRect combinée à une translation lente. Image et vidéo uniquement ; le serveur rejette la dérive sur application et iframe. Va-et-vient ; jamais de saut.
PrimitiveMotionPath — obligatoires: type, points, rate
Translation le long d’une polyligne de points de passage en unités de toile après le rectangle d’auteur. loop vaut par défaut loop si omis. Valide sur image, vidéo, application et iframe.
PrimitiveMotionPoint — obligatoires: x, y
PrimitiveMotionSpin — obligatoires: type, direction, speed
Rotation continue autour du centre du clipRect. Image et vidéo uniquement ; le serveur rejette la rotation sur application et iframe.
Problem — obligatoires: errors, instance, request_id
Le document de problème que chaque route répond sauf les routes d’exécution, contenu et sonde côté Lecteur (RuntimeProblem). L’erreur elle-même est errors[0] : son statut, code, type, titre, détail et indice. Seuls les membres du document restent au niveau supérieur. Branchez-vous sur errors[0].code, jamais sur détail ou indice, qui sont du texte.
Un champ de requête imputé ajoute errors[0].field ; chaque champ imputé supplémentaire est sa propre entrée avec le détail de ce champ.
ProblemError — obligatoires: status, code, type, title, detail, hint
Une erreur d’un document de problème. Les membres au-delà décrivent cette erreur plus en détail (par exemple dépendances sur not_ready).
ProblemField — obligatoires: field, code, detail
Project — obligatoires: id, revision, status, email, used_bytes, reserved_bytes, screen_count, content_limit_bytes, screen_limit, credit_remaining, created_at, updated_at, name
ProjectBillingUsage — requis : period, usage, stored_bytes, allowance
ProjectCapabilities — obligatoires : project_id, plan_id, features, feature_revision, capabilities, media_video_bytes, plan_features, limits
ProjectContext — obligatoires: project, organization
ProjectContextList — obligatoires: projects
ProjectCreate — obligatoires: name
ProjectDeleteConfirmation — obligatoires: name, revision
ProjectDeletionPreview — obligatoires: project, organization, devices, allowed
ProjectFeatures — obligatoires: advertiser, screens
ProjectMove — obligatoires: organization_id
ProjectMoveDestinations — obligatoires: organizations
ProjectName — obligatoires: none
Nom de projet imprimable tronqué. Rejette les contrôles, textes ressemblant à des URL, @, www., et ://.
ProjectOwnerTransfer — obligatoires: user_id
ProjectPatch — obligatoires: name
ProjectPlanFeature — obligatoires : id, enabled, required_plan
ProjectPlanFeatures — obligatoires : featuresets, features
Les fonctionnalités de forfait dont dispose le projet. Le forfait et les featuresets du projet les déterminent ; le crédit n’en débloque jamais aucune. Une fonctionnalité dont le projet ne dispose pas est refusée avec feature_not_in_plan (402), dont required_plan nomme le forfait le moins élevé vendu en général qui l’inclut.
ProjectPlanLimits — obligatoires : screens, members, video_bytes, event_retention_days
Les limites du projet telles que son forfait et ses featuresets les donnent, les chiffres que l’admission applique. Zéro signifie aucun plafond de forfait.
ProjectUptime — obligatoires: items
ProvisionScreen — obligatoires: none
RTSPStreamSource — obligatoires: protocol, url
ReadyResponse — obligatoires: status, degraded
ReleaseLaunch — obligatoires: launch_url, expires_at
Report — obligatoires: kind, title, generated_at, columns, rows, truncated
Un rapport sous forme de tableau : columns dit ce qu'est chaque membre d'une ligne. Les lignes portent plus de membres que les colonnes n'en montrent (id, parent_id et depth pour l'arborescence des dossiers). Les colonnes de pourcentage vont de 0 à 100.
ReportCatalog — obligatoires: items, formats
ReportColumn — obligatoires: key, label, type
ReportKindInfo — obligatoires: kind, title, description, params
ReportParam — obligatoires: name, description
ReportSchedule — obligatoires: cadence
ReportSubscription — obligatoires: id, name, kind, filters, schedule, format, enabled, recipients, revision, created_at, updated_at
ReportSubscriptionList — obligatoires: items
ReportSubscriptionPatch — obligatoires: none
ReportSubscriptionRecipient — obligatoires: user_id
ReportSubscriptionWrite — obligatoires: name, kind, schedule, format, recipients
Reseller — obligatoires: id, name, spread_bps, spread_effective_at, customer_count, review_state, customer_limit
ResellerCustomer — obligatoires: organization_id, name, plan_id, delegated_at, project_count, screen_count, stored_bytes, annual_list_cents, annual_wholesale_cents
ResellerCustomerPage — obligatoires: items, next_cursor
ResellerCustomerProject — obligatoires: id, name, status, screen_count, member
ResellerCustomerProjectPage — obligatoires: projects, next_cursor
ResellerEnrollment — obligatoires: organization_id
ResellerList — obligatoires: items
ResellerStatement — obligatoires: reseller_id, name, period, spread_bps, lines, usage_list_mcr, usage_wholesale_mcr, plan_annual_list_cents, plan_annual_wholesale_cents
ResellerStatementLine — obligatoires: 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 — obligatoires: id, name
Review — obligatoires: id, kind, state, subject, proposer, url, created_at, updated_at, impact
ReviewAdCreative — obligatoires: creative_id, creative_revision, content_path
ReviewApproveRequest — obligatoires: none
ReviewBlocker — obligatoires: id, state, subject
ReviewChangesRequest — obligatoires: note
ReviewDecider — obligatoires: none
ReviewDecisionResult — obligatoires: review
ReviewDependentResult — obligatoires: id, state
ReviewImpact — obligatoires: screens
ReviewList — obligatoires: items, next_cursor, pending_count
ReviewLocation — obligatoires: project_id, project_name
ReviewMediaChange — obligatoires: media_id, filename, before, after
Le changement en attente d’un élément média qu’une revue selector_refresh demande.
ReviewMediaFields — obligatoires: tags, folder_id
ReviewMediaFile — obligatoires: sha256, bytes, content_type
ReviewMediaPlaylist — obligatoires: id, name, screens, media_added, media_removed
ReviewMediaReplace — obligatoires: media_id, filename, source, version, before, after, aspect_changed, playlists
Le remplacement du fichier d’un élément multimédia sur lequel porte une révision media_replace. Le média garde son fichier jusqu’à l’approbation.
ReviewPageEdit — obligatoires: op, page_id
ReviewPending — obligatoires: status, review
Une écriture de type révision sous l’accès Proposer, ou une écriture qui atteint un écran protégé à n’importe quel niveau d’accès. La modification n’est pas à l’écran tant qu’une personne n’a pas approuvé la révision ; une écriture protégée est décidée par un second approbateur (docs/screen-scope.md).
ReviewPerson — obligatoires: user_id, name
ReviewPlaylistChange — obligatoires: operation, base_revision, proposed, diff
ReviewPlaylistDiff — obligatoires: name_changed, pages_added, pages_removed, pages_changed, soundtrack_changed, media_added, media_removed
ReviewPolicy — obligatoires: agent_changes_require_review, review_policy_revision
ReviewPolicyUpdate — obligatoires: agent_changes_require_review
ReviewPreview — obligatoires: live, proposed
Listes de lecture en direct et proposées dans la forme stockée GET /api/playlists/{id} renvoie (pages avec resolved_media).
ReviewProposer — obligatoires: kind
ReviewProtectedCampaign — obligatoires: none
Un campaign_create, campaign_update ou campaign_delete.
ReviewProtectedChange — obligatoires: subkind
L’entrée stockée d’une révision protected_change, appliquée par le service propriétaire quand un second approbateur approuve. Exactement un parmi campaign, folder et move est présent, comme le nomme subkind. L’approbation rejoue à base_revision ; une campagne ou un dossier qui a évolué rend la révision périmée (review_stale).
ReviewProtectedFolder — obligatoires: none
Un folder_create, folder_update, folder_delete ou folder_unprotect.
ReviewProtectedMove — obligatoires: folder_id, screen_ids, folder_ids
Un screens_move, le corps de POST /api/screens/move.
ReviewRejectRequest — obligatoires: reason
ReviewScreenChange — obligatoires: action, screens, request, playlist_ids
ReviewSubject — obligatoires: type, id, name
ReviewSummary — obligatoires: id, kind, state, url, subject, impact
RuntimeAdslotCandidate — obligatoires: page_id, occurrence_id, check_sequence, earliest_start_at
RuntimeAdslotEvent — obligatoires: event_id, decision_id, occurrence_id, kind, client_sequence
RuntimeAdslotEventBatch — obligatoires: events
RuntimeAdslotEventResponse — obligatoires: results
RuntimeAdslotEventResult — obligatoires: event_id, state
RuntimeAdslotMedia — obligatoires: kind, duration_ms, content_type, bytes, sha256, content_path, fit
RuntimeAdslotPage — obligatoires: id, type, adslot_id
Emplacement publicitaire pleine page, envoyé uniquement à une session jumelée disposant de adslot-v1. Un Player qui rencontre un type de page inconnu abandonne cette page.
RuntimeAdslotResolveRequest — obligatoires: manifest_revision, candidates
RuntimeAdslotResolveResponse — obligatoires: server_time, results
RuntimeAdslotResult — obligatoires: occurrence_id, check_sequence, state
RuntimeAdvance — obligatoires: mode
RuntimeApplicationPackage — obligatoires: version, url, bytes, sha256, entrypoint, contentType
Package normalisé immuable construit uniquement à partir de l’arbre d’application validé indépendamment. Les lecteurs natifs vérifient les octets et le SHA-256 avant de conserver atomiquement cette version pour une restauration hors ligne du dernier état connu bon. L’URL est une référence de transport liée à l’autorisation, pas une URL d’objet public ou durable.
RuntimeApplicationPrimitive — obligatoires: id, primitive, applicationId, releaseId, launchUrl, origin, protocol, grantId, package, rect, layer, contentFit
RuntimeAudio — obligatoires: loop, volume, tracks
Bande sonore de la liste de lecture (docs/playlist-audio.md). Émise uniquement lorsque la liste de lecture en contient une et qu’au moins une piste est projetée. Le Player joue les pistes dans l’ordre, indépendamment du séquenceur de pages ; les changements de page, transitions et visibilité ne la mettent jamais en pause ni ne la redémarrent.
L’identité de la piste est id plus mediaId plus sha256, jamais src, donc un rafraîchissement de manifeste qui conserve la piste en cours ne la redémarre pas. Le gain effectif est le volume multiplié par le volume du lecteur. Une piste défectueuse est abandonnée d’elle-même (invalid_audio_track).
RuntimeAudioCue — obligatoires: track, restart
Indice de bande sonore émis sur une page qui a créé audio_cue. Quand la page devient courante : si une piste différente joue, ou aucune, basculez sur la piste depuis son début ; si la piste joue, redémarrez-la seulement si restart est vrai. La séquence continue depuis la piste. Un indice peut être ignoré. Un signal qui ne nomme aucune piste du manifeste est rejeté (invalid_audio_cue).
RuntimeAudioTrack — obligatoires: id, mediaId, src, sha256, bytes, contentType, durationMs, grantId
RuntimeCanvas — obligatoires: width, height, viewportFit, background
RuntimeCardPrimitive — obligatoires: id, primitive, card, major, params, rect, layer, contentFit
Une carte intégrée. Pour un Lecteur déclarant les capacités CardML, le backend sélectionne la révision publiée compatible la plus récente dans la majeure épinglée, en considérant les révisions retenues et toutes les fonctionnalités requises ; quand aucune ne qualifie, il omet la carte avec des diagnostics card_unavailable et supprime les pages vides.
Le lecteur fusionne les valeurs par défaut de la carte, puis les paramètres, puis, lorsque des données sont présentes, les propriétés dynamiques du document à GET /screen/card-data/{data} (seules les clés marquées dynamiques par la carte).
Une carte avec des données reste cachée jusqu’à ce que son premier document arrive puis apparaît en fondu ; screen.card_data_changed pour la clé la récupère à nouveau sur place. feed, quand présent, est récupéré de la même route et passé à la carte comme son flux. Un Lecteur qui n’a pas la carte ou sa majeure ne dessine rien pour elle.
Une chaîne dans params ou dans le document de données qui commence par media: est une référence média, media:<id>, que le Lecteur résout en octets qu’il détient avant que la carte ne l’affiche, et vide quand il ne peut pas ; il ne transmet jamais une URL de params ou de données à une carte. media liste le nom params des images prêtes, avec les descripteurs qu’un primitif image resolvedMedia porte, ainsi le Lecteur les télécharge et les vérifie à l’arrivée du manifeste ; une référence à un média disparu depuis la publication est absente et la carte affiche son repli.
Les médias qu'un document de données désigne proviennent de /media/{media_id} à l'arrivée du document (ETag est le sha256). Les médias de carte ne retiennent jamais une page. Le backend a déjà remplacé les jetons {screen.name}, {screen.timezone}, {screen.field.NAME} et {screen.location} d'un placement pour cet écran, de sorte que params et data portent ses propres valeurs.
RuntimeChrome — obligatoires: schema_version, banner
Chrome détenu par l’exécution (docs/player-compatibility.md §8). Les lecteurs lisent les membres qu’ils connaissent et ignorent les autres ; une forme de bannière qu’un lecteur ne comprend pas n’affiche aucune bannière.
RuntimeCodecs — obligatoires: none
Liste de codecs RFC 6381 dérivée du serveur pour cette version exacte, jamais déclarée par le client. Elle est sœur de contentType ; un Player peut former une requête de capacité comme contentType suivi de codecs="VALEUR". Une vidéo dont le codec ne peut être dérivé est rejetée à l’upload. La propriété est optionnelle. Une valeur absente ne signifie pas que le codec est non supporté.
Une valeur présente contient actuellement une entrée de piste vidéo ; la grammaire permet des entrées séparées par des virgules.
RuntimeCommandResultWrite — obligatoire: state
Le corps de POST /screen/commands/{command_id}/result. Les membres inconnus sont ignorés (docs/player-compatibility.md §1.1).
RuntimeConditionReport — obligatoires: severity, code, context
RuntimeDisplay — obligatoires: none
Le contrôle de l’afficheur de l’écran, évalué sur l’appareil (docs/player-compatibility.md §6.5) : l’horaire et la substitution d’alimentation, le paramètre d’assombrissement à l’inactivité et le mode de luminosité. Omis lorsque l’écran n’en a pas ; l’afficheur reste alors allumé à la luminosité de l’opérateur. Les membres inconnus sont ignorés.
RuntimeHealthWrite — obligatoires: none
Le corps PUT /screen/health. Chaque membre est optionnel ; envoyez ce que la plateforme peut mesurer. Les membres inconnus sont ignorés et une valeur hors plage est rejetée (non refusée). Les entiers sont des nombres JSON entiers.
RuntimeHostHint — obligatoires: platform
L’indication facultative d’hôte natif au démarrage du jumelage, à la fin du jumelage, et à la création de session d’identité. Elle nomme un appareil et n’est jamais une autorisation.
Il est lu avec tolérance (docs/player-compatibility.md §1.1.1) : les membres inconnus sont ignorés, un champ mal formé ou une entrée de capacités est supprimé, au maximum 32 capacités sont conservées, et une valeur qui n'est pas un objet ou une plateforme hors du motif supprime tout l'indice. Aucun de ces cas ne refuse la requête.
Un Lecteur envoie toujours uniquement les valeurs de plateforme enregistrées et les membres ci-dessous, car un backend pré-contrat refuse tout autre.
RuntimeHostHintDevice — obligatoires: none
Identifiants matériels optionnels dans l’indice d’hôte natif. Un champ mal formé est ignoré.
RuntimeIframeCookie — obligatoires: name, value, domain, path, secure, httpOnly, sameSite
Un témoin d’un onglet partagé, au format de l’API de témoins du navigateur. Sa valeur est secrète.
RuntimeIframePrimitive — obligatoires: id, primitive, src, title, rect, layer, contentFit
RuntimeImagePrimitive — obligatoires: id, primitive, selector, resolvedMedia, grantId, rect, layer, contentFit
RuntimeImageResolvedMedia — obligatoires: mediaId, src, intrinsicSize, sha256, bytes, contentType
RuntimeIntrinsicSize — obligatoires: width, height
RuntimeKVEntry — obligatoires: application_id, key, value_base64, content_type, bytes, sha256, revision
RuntimeKVList — obligatoires: items
RuntimeKVSummary — obligatoires: application_id, key, content_type, bytes, sha256, revision
RuntimeKVWrite — obligatoires: value_base64
RuntimeKiosk — obligatoires: lock
Le verrouillage du kiosque (docs/player-compatibility.md §6.5). Émis à chaque session tant que kiosk.lock de l’écran est activé, et omis sinon. Un Player capable de s’épingler à l’écran le fait tant que lock est true et libère l’épinglage lorsque le membre est absent ou que lock est false ; un Player qui ne le peut pas l’ignore. Les membres inconnus sont ignorés.
RuntimeLiveHeartbeat — obligatoires: connection
Le rapport propre du Player. Schéma ouvert.
RuntimeLiveHeartbeatAnswer — obligatoires: lease_until, max_until
RuntimeLiveJoin — obligatoires: live_id, ice_servers, lease_until, max_until, heartbeat_ms, video
Ce vers quoi un Player diffuse et dans quelles limites. Schéma ouvert.
RuntimeLiveJoinRequest — obligatoires: none
Vide. Le corps peut être omis.
RuntimeLiveOffer — obligatoires: sdp
Une description de session sans son type, comme l’offre du Player et la réponse du relais.
RuntimeLiveStopped — obligatoires: reason
RuntimeManifest — obligatoires: schemaVersion, manifestRevision, grantId, contentGeneration, screenId, screenLabel, playlistRevision, generatedAt, pages
Manifeste d’exécution immuable utilisant le contrat déterministe screenrig.canvas/v1 pour toile, rectangle, ajustement et ordre source. Des propriétés supplémentaires en lecture sont permises, donc un lecteur sur ce contrat ignore les clés inconnues (règle de compatibilité 2). Les schémas d’écriture restent fermés.
Les pages sont des pages ordinaires de canevas et, pour une session jumelée avec adslot-v1 accordé, des pages d’emplacement publicitaire pleine page ; un manifeste sans page d’emplacement publicitaire est du contenu maison.
RuntimeManifestDiagnostic — obligatoires: level, code, detail
Une omission de projection d’exécution à sécurité intégrée. Les Players et le CLI peuvent les afficher ; ce ne sont jamais des autorisations.
RuntimeMediaSelector — obligatoires: none
RuntimeMediaSelectorByAll — obligatoires: by, oneAtATime
RuntimeMediaSelectorByID — obligatoires: by, mediaId, oneAtATime
RuntimeMediaSelectorByIDs — obligatoires: by, mediaIds, oneAtATime
RuntimeMediaSelectorByTag — obligatoires: by, oneAtATime
RuntimeObservationSurfaceWrite — obligatoires: id, width, height, pixel_ratio, presentation
RuntimeObservationWrite — obligatoires: observed_at, surfaces
Le corps PUT /screen/observation. Les membres inconnus sont ignorés (docs/player-compatibility.md §1.1). La valeur stockée est ScreenObservation du projet.
RuntimeOrigins — obligatoires: content
La liste blanche d’origines livrées (docs/player-compatibility.md §2.3). Présente uniquement sur une réponse mint pour un Player ayant les origines-v1 accordées.
Le lecteur fusionne le contenu avec ses origines compilées et ignore une entrée invalide. release_suffix remplace le suffixe de version compilé seulement s’il est un suffixe DNS valide d’au moins deux étiquettes ; il est absent quand l’origine d’exécution sert elle-même les versions (développement local).
L’ensemble livré ne change jamais l’origine d’identifiant, et le backend ne met jamais d’URL sur une origine que cette session mint n’a pas livrée. Un Player stocke l’objet validé last-known-good, donc une session ultérieure sans origines garde ce LKG valide.
RuntimePage — obligatoires: contractVersion, id, canvas, transition, advance, primitives
RuntimePairingScreen — obligatoires: id, public_id, label, state, revision, manifest_revision, content_access_generation, created_at, updated_at
Résumé d’écran détenu par l’exécution dans les jumelages et les provisions du navigateur. Son ensemble de membres est figé : les champs d’écran du projet n’apparaissent jamais ici (docs/player-compatibility.md §8). state reste dans les trois valeurs ci-dessous.
RuntimePrimitive — obligatoires: none
RuntimeProblem — obligatoires: type, title, status, detail, instance, code, request_id, errors
Le document de problème des routes écran (/screen/) et médias (/media/) côté Lecteur, les flux de jumelage et les routes de sonde (/.ready, /.health) : chaque membre à plat au niveau supérieur. Les Lecteurs publiés lisent son code et action au niveau supérieur (docs/player-compatibility.md §5), donc cette forme reste telle quelle ; toutes les autres routes répondent Problem.
RuntimeRect — obligatoires: x, y, width, height
RuntimeReport — obligatoires: none
Les corps et contextes des rapports sont lus avec tolérance (docs/player-compatibility.md §1.1). Un code a besoin de ses propres membres de contexte ; les autres membres sont ignorés. Les Players envoient encore uniquement les membres ci-dessous, car un backend pré-contrat refuse tout autre.
RuntimeScreenLabel — obligatoires: screen_label
Le nom d’écran stocké, la valeur que le manifeste porte comme screen_label.
RuntimeScreenLabelWrite — obligatoires: screen_label
Le corps PUT /screen/screen-label. Le serveur retire les espaces au début et à la fin de screen_label et stocke de 1 à 120 caractères sans caractères de contrôle. Les membres inconnus sont ignorés (docs/player-compatibility.md §1.1).
RuntimeScreenPlaylist — obligatoires: playlist_id
La liste de lecture assignée à l’écran après la modification.
RuntimeScreenPlaylistWrite — obligatoires: playlist_id
Le corps PUT /screen/playlist. Les membres inconnus sont ignorés (docs/player-compatibility.md §1.1).
RuntimeScreenPlaylists — obligatoires: playlists, more
Les listes de lecture qu’un sélecteur sur l’appareil d’un écran offre, par ordre alphabétique du nom sans tenir compte de la casse, puis par id.
RuntimeSelectorPlaylistSnapshot — obligatoires: selections, pageMaxMs
Les sélections d’une liste de lecture de la pile, désignées par les propres identifiants de page de cette liste de lecture.
RuntimeSelectorSnapshot — obligatoires: manifestRevision, snapshotRevision, selections, pageMaxMs
RuntimeSession — obligatoires: paired, capabilities, event_cursor, public_url
Session détenue par l’exécution (docs/player-compatibility.md §8). Les lecteurs ignorent les membres inconnus et les valeurs de capacités inconnues. Un nouveau membre est envoyé uniquement aux sessions dont les subventions le couvrent.
RuntimeSessionRequest — obligatoires: public_id
Monnaie anonyme du spectateur. Les membres inconnus sont ignorés (docs/player-compatibility.md §1.1).
RuntimeStack — obligatoires: levels, playlists
Chaque niveau de la pile de l’écran, envoyé uniquement à un Player qui a déclaré la capacité d’hôte schedule.stack et uniquement quand la pile compte plus d’un niveau (docs/player-compatibility.md §6.11). Les membres racines du manifeste sont la liste de lecture du niveau du bas ; le Player résout lui-même les niveaux avec le contrat d’horaire.
RuntimeStackPlaylist — obligatoires: playlistRevision, pages
RuntimeStatusWrite — obligatoires: observed_at, chip
Le corps PUT /screen/status. Les membres inconnus sont ignorés (docs/player-compatibility.md §1.1). La valeur stockée est ScreenStatus du projet.
RuntimeStorageWrite — obligatoires: observed_at, volume, cache, durability, plan, transfer_24h
Le corps PUT /screen/storage. Les membres inconnus sont ignorés (docs/player-compatibility.md §1.1). La valeur stockée est ScreenStorage du projet plus received_at du serveur.
RuntimeStreamPrimitive — obligatoires: id, primitive, sources, muted, fallback, grantId, rect, layer, contentFit
RuntimeSuspension — obligatoires: message, since
Émis tant que l’écran est suspendu (docs/player-compatibility.md §6.9) : pages vaut [] sans diagnostics, et un Player affiche message comme avis plein écran à la place de la surface sans contenu. since est le moment où l’écran a été suspendu pour la première fois. La révision du manifeste est celle de l’avis lui-même, jamais celle d’une liste de lecture, et l’écran n’a pas besoin de liste de lecture assignée.
RuntimeTelemetryBatch — obligatoires: telemetry_epoch, stream_id, sequence, created_at, reports
Une file d’attente FIFO durable du Lecteur envoie au maximum un lot ordinaire par minute avec une phase aléatoire, ou plus tôt si pleine. Le corps JSON total fait au maximum 256 KiB ; au maximum 64 rapports, chacun au maximum 32 KiB. Chaque rapport conserve son horodatage d’occurrence et un play_id stable.
Conserver un lot en cours immuable sur disque jusqu’à 202, incrémenter la séquence uniquement après accusé de réception, et réessayer les mêmes octets après réponses perdues ou redémarrages. La séquence commence à 1 et ne comporte pas de trous.
Dedupe conserve au maximum huit flux en direct par écran, chaque filigrane pendant au moins les 24 heures où son lot peut encore être rejoué ; conservez le même flux lors du renouvellement des identifiants. Les enregistrements expirent localement après 24 heures avec comptabilité explicite. manifest.activated et manifest.upgrade restent individuels et immédiats.
Les écritures interactives, la résolution des annonces, les récupérations de contenu, les captures d’écran et SDK emitConfirmed() restent aussi immédiats. L’échantillonnage santé conserve sa cadence de quinze minutes; les transitions urgentes d’affichage/santé sont envoyées immédiatement. Observation et clichés santé ordinaires sont derniers gagnants avec les temps d’occurrence originaux. Santé requiert health.write.
Les rapports individuels existants restent acceptés. Les limites d’abus d’éléments de rapport s’appliquent par nouvel élément plutôt que par enveloppe HTTP ; la relecture engagée ne consomme que l’admission de la requête.
RuntimeTransition — obligatoires: type, durationMs
Transition de page créée. Les déplacements simples conservent le type, la durée et les décorations optionnelles. Le stinger porte la forme normale du contenu de la carte au-dessus des deux calques. Un code manquant ou un interpréteur Player incompatible dégrade uniquement la transition en fondu enchaîné de même durée, avec diagnostics transition_unavailable.
RuntimeTransitionCard — obligatoires: primitive, card, major, params, version, src, sha256, model, requires
Le même contenu de carte projeté qu’une carte canvas, sans géométrie de placement canvas. Le stinger est fixé à la majeure 1 ; params inclut durationMs et hangMs.
RuntimeUpgradeNotice — obligatoires: state, player_kind, recommended
Présent dans une réponse mint quand la version comparable du lecteur est inférieure à la version recommandée pour player_kind (docs/player-compatibility.md §6.1). Le lecteur démarre une vérification de mise à jour de plateforme et n’affiche rien à l’écran. Un lecteur ignore le membre pour un état qu’il ne connaît pas.
RuntimeVerbosity — obligatoires: none
Le niveau de journal et le niveau de toast les plus bas que le Player génère et affiche (docs/player-compatibility.md §6.12). Émis à chaque session quand l’écran en définit un des deux ; chaque membre est omis quand il n’est pas défini. Les erreurs sont toujours générées et affichées. Un Player ignore un membre ou une valeur inconnus et garde sa valeur par défaut.
RuntimeVideoPrimitive — obligatoires: id, primitive, selector, resolvedMedia, muted, loop, grantId, rect, layer, contentFit
RuntimeVideoResolvedMedia — obligatoires: mediaId, src, intrinsicSize, sha256, bytes, contentType
RuntimeWall — obligatoires: outputs, arrangement, rotation, span
Le mur vidéo de l’écran tel que le lecteur le dispose (docs/player-compatibility.md §6.8). Émis uniquement si l’écran a un mur. Les membres inconnus sont ignorés.
SCIMError — obligatoires : schemas, status
Le document d’erreur de la RFC 7644, section 3.12.
SCIMEvent — obligatoires : at, action, status
SCIMEventList — obligatoires: events
SCIMGroupList — obligatoires : groups
SCIMGroupProjectBinding — obligatoires : binding_id, project_id, project_name, role
SCIMGroupSummary — obligatoires : id, display_name, member_count, bindings
SCIMResource — obligatoires: none
Un document SCIM 2.0 dans la forme que lui donnent la RFC 7643 et la RFC 7644 à la route qui le porte; chaque opération indique lequel c’est. Il s’agit d’une ressource User ou Group, d’une ListResponse, d’un message PatchOp, d’un ServiceProviderConfig, d’un ResourceType ou d’un Schema. Les membres que screenRIG n’utilise pas sont acceptés et ignorés.
SCIMSettings — obligatoires : enabled, base_url, tokens, user_count, group_count
SCIMSettingsWrite — obligatoires : enabled, proof
SCIMToken — obligatoires : id, name, prefix, created_at
SCIMTokenCreate — obligatoires : name, proof
SCIMTokenCreated — obligatoires : id, name, prefix, created_at, token
Un SCIMToken avec son secret, renvoyé une seule fois.
SSODiscovery — obligatoires: sso, required, account
Comment l’adresse se connecte ou s’inscrit. sso, required et provider_name sont déterminés par le domaine de l’adresse seul ; account indique si une personne active détient l’adresse.
SSODiscoveryRequest — obligatoires: email
SSOErrorCode — obligatoires: none
Le code stable avec lequel se termine une ouverture de session par authentification unique lorsqu’elle n’aboutit pas : la valeur de #sso_error= dans l’adresse vers laquelle POST /api/sso/finish redirige, et le code d’un test de fournisseur d’identité en échec. no_email : le fournisseur n’a affirmé aucune adresse courriel. email_unverified : il a marqué l’adresse comme non vérifiée. domain_not_allowed : l’adresse n’appartient à aucun des domaines vérifiés de l’organisation. account_exists : l’adresse appartient déjà à un compte doté de sa propre ouverture de session; la personne se connecte comme auparavant et établit le lien de l’identité depuis son compte (intent link). managed_elsewhere : une autre organisation gère la personne. subject_mismatch : le compte est lié à une identité différente chez le même fournisseur. not_provisioned : personne ne détient l’adresse et la connexion ne crée pas de personnes. sso_required : l’organisation exige l’authentification unique pour l’adresse. staff_account : un compte du personnel de screenRIG n’est jamais connecté, adopté ou lié par le fournisseur d’identité d’un client. expired : l’ouverture de session a dépassé ses 10 minutes. bad_state : le state de l’ouverture de session ou sa liaison au navigateur ne correspond pas, ou elle a déjà été utilisée. interaction_required : un renouvellement silencieux requiert la personne. provider_refused : le fournisseur a répondu par une erreur. provider_unavailable : le fournisseur n’a pas pu être joint ou lu. verification_failed : le jeton ou l’assertion du fournisseur a échoué à la vérification. deactivated : la personne est désactivée.
SSOPolicy — obligatoires : required, break_glass_user_ids, passkey_admin_ids, policy_revision
SSOPolicyWrite — obligatoires : required, break_glass_user_ids, proof
SSOStart — obligatoires : redirect_url
SSOStartRequest — obligatoires: email
SSOTestStart — obligatoires : redirect_url
ScheduleCalendar — obligatoires: subject, from, to, screens, groups
ScheduleCalendarConflict — obligatoires: kind, level_ids
ScheduleCalendarGroup — obligatoires: key, screens, screen_ids, displays, levels, spans, on_screen, conflicts
ScheduleCalendarOnScreen — obligatoires: display, from, to
ScheduleCalendarSpan — obligatoires: level_id, from, to, state
ScheduleImportCommitted — obligatoires: preview, applied
ScheduleImportLevel — obligatoires: key, action, home, content, screens, priority, rows
ScheduleImportPreview — obligatoires: name, columns, valid, fingerprint, summary, rows, levels, removals
ScheduleImportRemoval — obligatoire: home
ScheduleImportRequest — obligatoire: rows
ScheduleImportResolved — obligatoires: kind, id, name
ScheduleImportRow — obligatoires: row, status
ScheduleImportRowError — obligatoires: code, message
ScheduleImportSummary — obligatoires: rows, rows_with_errors, levels, creates, updates, unchanged, removes, screens, playlists
SchedulePreview — obligatoires: gained, lost, calendar
Ce qu’une écriture de campagne ou d’horaire changerait. gained sont les écrans qui porteraient un niveau de l’écriture qu’ils ne portent pas maintenant, lost ceux qui en portent un qu’ils ne porteraient plus ; un niveau qui reste sur une pile ne change ni l’un ni l’autre et apparaît dans calendar.
SchedulePreviewReach — obligatoires: count, screen_ids
Screen — obligatoires: id, public_id, label, revision, manifest_revision, manifest_upgrade, content_access_generation, state, online, created_at, updated_at
ScreenAction — obligatoires: none
Une action de flotte, discriminée par type. Chaque membre porte uniquement ses propres paramètres ; un membre d’un autre type est un champ inconnu et invalid_request.
ScreenActionAddTags — obligatoires: type, tags
Ajoute des balises qu’un écran ne porte pas déjà. Un écran qui dépasserait 16 balises échoue avec invalid_request.
ScreenActionAssign — obligatoires: type, playlist_id
ScreenActionClearDisplaySchedule — obligatoires: type
Supprime la programmation d’affichage de chaque écran ; un écran sans programmation est correct et inchangé.
ScreenActionClearPlaylist — obligatoires: type
Retire la liste de lecture par défaut propre à chaque écran, en conservant le jumelage et les autres niveaux de contenu. Sans contenu effectif, le Player affiche son écran d’attente. De classe révision, comme l’assignation.
ScreenActionClearPlaylistSchedule — obligatoires: type
Supprime la programmation de la liste de lecture de chaque écran ; un écran sans programmation est correct et inchangé.
ScreenActionClearRebootSchedule — obligatoires: type
Supprime l’horaire de redémarrage de chaque écran ; un écran qui n’en a pas est ok et inchangé. Accès Manage seulement.
ScreenActionDisplay — obligatoires: type, power
Mêmes règles que ScreenDisplayWrite. until est vérifié par rapport à l’horloge de la requête lorsque le Idempotency-Key n’a pas d’enregistrement de flotte, et de nouveau par chaque écran.
ScreenActionDisplayClear — obligatoires: type
Met fin à chaque remplacement manuel d’affichage d’écran (DELETE /api/screens/{id}/display) ; un écran sans remplacement est correct et inchangé.
ScreenActionMaintenance — obligatoires: type
POST /api/screens/{id}/clear-cache, /restart-app ou /update par écran ; un écran dont l’hôte n’a pas déclaré la capacité échoue seul avec command_unsupported. Un écran hors ligne conserve la commande à l’état queued jusqu’à son retour en ligne (expires_in_s).
ScreenActionReboot — obligatoires: type
POST /api/screens/{id}/reboot par écran ; un écran dont l’hôte n’a pas déclaré reboot échoue seul avec reboot_unsupported. Un écran hors ligne conserve le redémarrage à l’état queued jusqu’à ce qu’il passe en ligne (expires_in_s).
ScreenActionReload — obligatoires: type
POST /api/screens/{id}/reload par écran. Un écran hors ligne conserve le rechargement à l’état queued jusqu’à ce qu’il passe en ligne (expires_in_s).
ScreenActionRemoveTags — obligatoires: type, tags
Supprime les étiquettes listées ; une étiquette que l’écran ne porte pas est ignorée.
ScreenActionRequest — obligatoires: selector, action
ScreenActionResult — obligatoires: action, matched, succeeded, failed, results
ScreenActionScreenResult — obligatoires: screen_id, status
Le résultat d’un écran. ok porte le résultat du chemin à un seul écran : revision (et tags pour les actions d’étiquette) pour les actions assign, tag, takeover, takeover_clear, set_playlist_schedule, clear_playlist_schedule, set_reboot_schedule et clear_reboot_schedule, reload pour reload, toast pour toast. failed porte le problème que la requête propre à cet écran aurait renvoyé.
ScreenActionSelector — obligatoires: none
ScreenActionSelectorFolder — obligatoires: by, folder_id
Chaque écran actif du dossier d’écrans et de chaque dossier à l’intérieur, dans l’ordre de création. Il n’y a pas de limite de nombre d’écrans.
ScreenActionSelectorIds — obligatoires: by, screen_ids
ScreenActionSelectorTag — obligatoires: by, tag
Chaque écran actif dont les étiquettes contiennent tag, dans l’ordre de création. Il n’y a pas de limite de nombre d’écrans.
ScreenActionSetDisplaySchedule — obligatoires: type, enabled, windows
Remplace la programmation d’affichage de chaque écran (ScreenDisplayScheduleWrite), normalisée une fois avant diffusion. Un écran sans fuseau horaire échoue seul avec invalid_request.
ScreenActionSetPlaylistSchedule — obligatoires: type, entries
Remplace la programmation de la liste de lecture de chaque écran avec les mêmes entrées (ScreenPlaylistScheduleWrite). Les identifiants d’entrée sont assignés une fois avant diffusion. Un écran sans fuseau horaire ou sans liste de lecture par défaut échoue seul avec invalid_request.
ScreenActionSetRebootSchedule — obligatoires: type, enabled, windows
Remplace l’horaire de redémarrage de chaque écran (ScreenRebootScheduleWrite), normalisé une fois avant diffusion. Accès Manage seulement. Un écran sans fuseau horaire échoue seul avec invalid_request, et un écran dont le Player n’a pas déclaré reboot échoue avec reboot_unsupported.
ScreenActionSetTags — obligatoires: type, tags
Remplace l’ensemble de balises de chaque écran ; un tableau vide le vide.
ScreenActionTakeover — obligatoires: type, playlist_id
Mêmes règles que ScreenTakeoverWrite. until est vérifié par rapport à l’horloge de la requête avant la diffusion lorsque le Idempotency-Key n’a pas d’enregistrement de flotte, et de nouveau par chaque écran.
ScreenActionTakeoverClear — obligatoires: type
Met fin à chaque prise de contrôle d’écran ; un écran sans prise de contrôle est correct et inchangé.
ScreenActionToast — obligatoires: type, level, text
Même niveau, texte et règles de durée que ScreenToastWrite, validés une fois avant diffusion.
ScreenCampaigns — obligatoires: screen_id, items
ScreenCommand — obligatoires: id, type, state, requested_at, expires_at
Un redémarrage, un rechargement, un clear_cache, un restart_app ou un update demandé à un écran, dans Screen.commands. Une commande envoyée à un écran en ligne est enregistrée à l’état sent.
Une commande demandée à un écran hors ligne est enregistrée à l’état queued sans événement d’exécution ; le backend ajoute l’événement, avec cet ID et expires_at, quand il applique la prochaine transition en ligne de l’écran avant expires_at, et la commande passe à sent.
Chaque commande a exactement un événement d’exécution, donc un Player ne peut pas le voir deux fois. expired est dérivé à la lecture pour une commande en file d’attente dont expires_at est dépassé. Une commande plus récente du même type remplace celle qui est toujours en file d’attente. Un redémarrage envoyé passe à done quand un rapport de santé avec uptime_s place le démarrage après sent_at ; un rechargement n’atteint jamais done.
Une commande clear_cache, restart_app ou update passe à done ou failed quand son Player rapporte, avec cause et detail.
ScreenCommandPage — obligatoires: items, next_cursor
ScreenCommandWrite — obligatoires: none
Le corps optionnel de POST /api/screens/{id}/reboot, /reload, /clear-cache, /restart-app et /update. Un corps vide conserve la valeur par défaut.
ScreenDeviceSettingsPatch — obligatoires: none
Un changement des paramètres d’assombrissement à l’inactivité et de luminosité d’un écran, et de son verrouillage du kiosque (patchScreenDeviceSettings). Le corps nomme au moins l’un des deux membres et aucun autre.
ScreenDisplay — obligatoires: requested, source
État de l’alimentation de l’afficheur. requested est ce que l’écran doit afficher maintenant : la substitution active, sinon l’horaire d’affichage activé évalué dans le fuseau horaire de l’écran, sinon allumé (source override, schedule ou default) ; until est quand cela change ensuite, si connu. reported est le dernier état d’afficheur du rapport de santé du Player (power, connected, reported_at, périmé après 35 minutes). idle et brightness sont les paramètres display.idle et display.brightness de l’écran (définis par ScreenPatch).
Absent quand l’écran n’a ni horaire, ni substitution, ni paramètre d’inactivité ou de luminosité, ni afficheur signalé.
ScreenDisplayBrightness — obligatoires: mode
display.brightness : auto fait correspondre la lumière ambiante de l’appareil à la luminosité de la fenêtre ; fixed (valeur par défaut) conserve la luminosité de l’opérateur. Appliqué par un Player qui déclare la capacité d’hôte brightness.auto, qu’il déclare seulement lorsque l’appareil a un capteur de lumière.
ScreenDisplayIdle — obligatoires: after_s, wake
display.idle : l’écran s’assombrit après after_s secondes sans toucher, sans touche ou, lorsque wake liste presence, sans personne devant l’écran (la caméra de l’appareil, analysée sur l’appareil ; aucune image ne le quitte). Un événement de réveil le rallume aussitôt, et le toucher qui réveille un écran sombre est consommé.
Tant que l’écran est sombre, le Player est en extinction de l’afficheur, comme pour un horaire d’affichage : il met la lecture en pause (ni diffusion, ni publicité), signale display.power off dans son rapport de santé et reprend au réveil. Un horaire d’affichage ou une substitution qui garde le panneau éteint l’emporte, et une application qui détient device.display l’emporte sur l’inactivité tant que sa page est à l’écran.
Appliqué par un Player qui déclare la capacité d’hôte display_power.idle.
ScreenDisplayOverride — obligatoires: override_id, power, until, ends_at, set_at
ScreenDisplayPatch — obligatoires: none
ScreenDisplayReported — obligatoires: reported_at, stale
Le dernier rapport d’état de l’afficheur du Player. Alimentation et connectivité observées, indépendantes de l’alimentation demandée. stale est vrai après 35 minutes sans rapport ; c’est un contexte, non une preuve que l’alimentation a causé un échec de capture.
ScreenDisplaySchedule — obligatoires: enabled, windows, updated_at
ScreenDisplayScheduleView — obligatoires: display_schedule
ScreenDisplayScheduleWrite — obligatoires: enabled, windows
ScreenDisplayWrite — obligatoires: power
ScreenEffectivePlaylist — obligatoires: id, source
La liste de lecture à partir de laquelle le manifeste d’exécution de l’écran est construit : la prise de contrôle, sinon la première campagne qui s’applique (entry_id est l’identifiant de la campagne), sinon la première entrée d’horaire de liste de lecture correspondante (entry_id), sinon la valeur par défaut assignée, sinon la liste de lecture par défaut du dossier le plus proche qui contient l’écran (source folder, entry_id l’identifiant du dossier). until est l’instant suivant où cela est connu pour changer (fin de la prise de contrôle ou prochaine limite d’horaire dans les huit jours), absent lorsque rien de temporel ne le change.
Le travailleur de frontière applique un changement avec un retard maximal de 60 secondes. Une prise de contrôle ou une entrée dont la liste de lecture ne peut être affichée est ignorée. Absent quand l’écran ne montre aucune liste de lecture.
ScreenExplainAt — obligatoires: instant, effective_playlist, verdicts, not_judged
Ce que l’écran affiche à instant et pourquoi, d’après le résolveur qu’exécute le balayage des limites. La prise de contrôle, la programmation de listes de lecture de l’écran et les campagnes du projet sont lues telles qu’elles sont maintenant, non telles qu’elles étaient alors. Une campagne dont la liste de lecture est absente ou non approuvée est ignorée, comme le balayage l’ignore.
Sur un écran dont le Player résout sa propre pile (schedule.stack), les verdicts lisent cette pile, et not_judged l’indique (player_stack).
ScreenFieldsPatch — obligatoire : fields
Une modification des champs d’un écran (patchScreenFields). Le corps n’a aucun autre membre.
ScreenFolder — obligatoires: id, name, parent_id, revision, created_at, updated_at
Un dossier d’écrans. Un écran se trouve dans au plus un dossier (Screen.folder_id) ; un dossier cible ses écrans et ceux de chaque dossier à l’intérieur.
ScreenFolderCreate — obligatoires: name
ScreenFolderDeleteResult — obligatoire : levels
ScreenFolderList — obligatoires: items
ScreenFolderPatch — obligatoires: none
ScreenGlass — obligatoires: none
Ce que le serveur a conclu sur l’image de l’écran à partir des rapports reçus, jamais à partir de ce que le lecteur dit de lui-même. Une vérification qui n’a rien à dire laisse son membre absent. En lecture seule dans l’API du projet. Jamais une autorisation ni une admission. ScreenPatch ne peut pas l’écrire.
ScreenGlassChangedDetails — obligatoires: check, verdict, previous, since, evidence
Objet details d’un événement screen.glass_changed durable réservé au projet, ajouté lorsqu’une vérification de l’affichage change son verdict pour un écran. Ce n’est pas une commande d’audience d’exécution et il n’est pas livré sur GET /screen/events.
La condition loop_stalled s’ouvre sur un verdict de lecture stalled et prend fin avec tout autre; glass_blank et glass_frozen s’ouvrent sur un verdict d’image blank ou frozen et prennent fin avec tout autre.
ScreenHealth — obligatoires: reported_at, stale
Le dernier rapport d’état de l’appareil (PUT /screen/health), nettoyé, avec reported_at du serveur. Un membre que le lecteur n’a pas envoyé est absent. stale est vrai lorsque reported_at a plus de 35 minutes ; l’état périmé est toujours affiché, jamais supprimé ; l’archivage et la récupération d’écran le suppriment.
Les transitions ajoutent screen.health_changed réservé au projet avec details.changes, une liste de {change, ...} : display_disconnected, display_reconnected, display_power (from, to), temperature_high (à 80 °C ou plus), temperature_normal (en dessous de 75 °C à nouveau), on_battery (battery.source est devenu none ; level_percent lorsqu’il est signalé) et plugged_in (toute autre source de nouveau ; source), crash_spike et renderer_restart_spike (le nombre sur 24 heures a augmenté de 3 ou plus depuis le dernier événement de pic ; crashes_24h ou renderer_restarts_24h et previous). battery n’est présent que lorsque l’appareil en signale une ; le backend n’en lit rien d’autre que battery.source pour la condition on_battery et n’en déduit aucune cause.
Lecture seule ; jamais une autorisation.
ScreenHealthHistory — obligatoires: none
Une page de rapports (résolution brute) ou de résumés horaires (résolution heure).
ScreenHealthHour — obligatoires: 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
Rapports d’un écran pour une heure UTC. Un membre est nul lorsqu’aucun rapport de l’heure ne le contient.
ScreenHealthHours — obligatoires: resolution, hours, next_cursor
ScreenHealthSample — obligatoires: reported_at
Un rapport de santé d’appareil stocké : Screen.health sans stale, ni cpu.utilization_percent ni cpu.app_percent, que seul le dernier rapport (Screen.health) contient. Un membre que le Player n’a pas envoyé est absent.
ScreenHealthSamples — obligatoires: resolution, samples, next_cursor
ScreenIdentifyAccepted — obligatoires: identify_id, duration_ms, expires_at
ScreenIdentifyDetails — obligatoires: identify_id, label, screen_id, duration_ms, at, expires_at
objet details sur un événement durable player.identify.
ScreenIdentifyWrite — obligatoires: none
ScreenKiosk — obligatoires: lock
kiosk.lock : le Player s’épingle à l’écran (épinglage d’écran Android avec startLockTask ; la personne devant l’écran confirme la première fois, et la barre d’état, l’accueil et les applications récentes sont bloqués tant qu’il est épinglé ; la variante gérée, en tant que propriétaire de l’appareil, conserve sa tâche de verrouillage). Présent seulement tant que le verrouillage est activé.
Le panneau de paramètres de l’opérateur propose Quitter le verrouillage du kiosque, qui libère l’épinglage jusqu’à ce que le prochain manifeste ou redémarrage l’applique de nouveau. Appliqué par un Player qui déclare la capacité d’hôte kiosk_lock.
ScreenKioskPatch — obligatoires: lock
ScreenLevelChange — obligatoires: source, id, playlist_id, screens
ScreenLevelChanges — obligatoires: gained, lost
Ce qu’une écriture fait aux programmations des écrans qu’elle modifie : les campagnes dont ils rejoignent l’audience (gained) ou qu’ils quittent (lost), et les listes de lecture par défaut de dossier qui deviennent ou cessent d’être leur liste par défaut. screens compte les écrans touchés par niveau.
Lors d’une écriture d’étiquette, une entrée de campagne signale l’appartenance à l’audience : chaque campagne active que les écrans rejoignent ou quittent, qu’elle y soit diffusée ou non, ce qui dépend de la liste de lecture par défaut de l’écran. Un déplacement ou un changement de dossier liste les campagnes dont l’audience de dossier change sur les écrans qui les diffusent.
ScreenLink — obligatoires: hint, created_at
URL de lecteur qui ouvre un écran dans un navigateur qui ne conserve rien, comme une source navigateur vMix ou OBS.
ScreenLinkSessionRequest — obligatoires: screen_link
Le secret du lien d’écran, plus les indices facultatifs host, playback et player. Les membres inconnus sont ignorés, et host, playback et player sont lus avec tolérance (docs/player-compatibility.md §1.1). Le secret est un identifiant d’accès : il n’est jamais journalisé ni renvoyé.
ScreenLinkSummary — obligatoires: hint, created_at
Le lien de l’écran, sans son url. Présent seulement tant que l’écran a un lien. Lecture seule ; POST et DELETE /api/screens/{id}/link le modifient.
ScreenList — obligatoires: items
ScreenLocation — obligatoires : latitude, longitude
L'endroit où se trouve un écran, en degrés décimaux, avec un nom de lieu court facultatif et une adresse civique. Un placement de carte le lit au moyen du jeton {screen.location}, et la liste des écrans se filtre selon la distance à un point (near).
ScreenLocationPatch — obligatoire : location
Une modification de l’emplacement d’un écran (patchScreenLocation). Le corps n’a aucun autre membre.
ScreenMaintenanceAccepted — obligatoires: command_id, command, expires_at, state
ScreenManifestUpgrade — obligatoires: desired_revision, active_revision, desired_playlist, active_playlist, state, code, attempt, retry_at, missing_page_count, state_since, reported_at
État calculé toujours présent de mise à niveau du manifeste pour cet écran, dérivé à la lecture de sa révision désirée émise ou de l’objectif de contenu partagé en liste de lecture en file d’attente, de sa dernière révision active de manifeste reconnue par le serveur (manifest.activated), et du dernier rapport manifest.upgrade accepté.
État du projet en lecture seule : aucun corps ne peut l’écrire, et aucun rapport ne promeut jamais une autorisation. active_revision est la dernière activation reconnue, pas la preuve que chaque session simultanée la montre déjà.
Être hors ligne ne produit jamais d’échec, et un retry_at en retard dans un état de nouvelle tentative est une présentation client, jamais un jugement serveur. desired_revision null signifie aucun. L’état pending nomme une révision désirée sans rapport correspondant ; activating nomme une cible déjà affichée dont l’accusé est toujours en attente ; un emplacement de rapport dont la révision a cessé de correspondre à desired_revision est ignoré jusqu’à ce qu’un nouveau rapport corresponde, donc un nouveau manifeste désiré dérive pending sans rien effacer.
Avant que le prochain contact manifeste n’émette la subvention désirée d’une édition partagée, la révision désirée et la liste de lecture peuvent exposer cet objectif en attente comme une intention en lecture seule ; cela ne donne aucun accès. L’identité active provient toujours de la subvention historique reconnue exacte. Une activation plus ancienne ne peut pas annoncer l’objectif en attente plus récent comme actuel.
ScreenMove — obligatoires: folder_id
Au moins un id parmi screen_ids et folder_ids, au maximum 1000 au total.
ScreenMoveResult — obligatoires: screens, folders, levels
ScreenNamePatch — obligatoires: name
Le nouveau nom d’un écran (patchScreenName). Le corps n’a aucun autre membre.
ScreenNotJudged — obligatoires: code, detail
Quelque chose que l’explication ne juge pas.
ScreenObservation — obligatoires: observed_at, surfaces
Surface de lecture rapportée par le lecteur. Absente sur l’écran jusqu’au premier PUT accepté /screen/observation. Lecture seule sur l’API projet ; ScreenPatch, PairScreen, corps de jumelage, corps de session, canevas, manifeste d’exécution et POST /screen/reports ne peuvent pas l’écrire.
ScreenObservationSurface — obligatoires: id, width, height, pixel_ratio, presentation
ScreenOutage — obligatoires: offline_since
La dernière panne de présence de l’écran et, une fois que le premier rapport de santé après son retour la tranche, la raison pour laquelle l’écran avait disparu. Une nouvelle panne la remplace; un écran qui n’a jamais été hors ligne depuis l’enregistrement des pannes n’en a aucune.
La cause vient des compteurs de disponibilité propres au Player dans ce rapport, lus par rapport à la panne et jamais par rapport à l’horloge de l’appareil : device_restart (l’appareil a démarré après le début de la panne), app_crash (le Player a démarré et son nombre de plantages sur 24 heures a augmenté), app_restart (le Player a démarré, pas l’appareil), network (aucun des deux n’a démarré et rien ne désigne screenRIG) et platform (aucun des deux n’a démarré, et un rapport player.stream_down est parvenu à screenRIG pendant la panne, ou l’observateur de présence était arrêté ou en reprise quand l’écran s’est tu). likely_cause est absent quand elle est inconnue, et elle reste inconnue plutôt que devinée : un rapport sans durées de fonctionnement, un rapport trop proche du début de la panne, un redémarrage survenu après le retour de l’écran et un rapport du Player dans la minute de la reconnexion ne tranchent rien.
Un rapport ne tranche que dans les 35 minutes suivant le retour de l’écran. device_restart ne distingue pas une coupure de courant d’un redémarrage, et network ne distingue pas le réseau propre de l’écran de son amont.
La décision ajoute une seule fois l’événement réservé au projet screen.outage_classified, avec les détails {offline_since, back_at, likely_cause, evidence, online_event_id}; la notification de résolution d’un écran hors ligne nomme la cause lorsqu’elle est établie au moment où l’avis part. Les lecteurs traitent un likely_cause qu’ils ne connaissent pas comme inconnu. Lecture seule; jamais une autorisation.
ScreenPatch — obligatoires: none
ScreenPlayPageAccepted — obligatoires: screen_id, playlist_id, page_id, manifest_revision, expires_at
ScreenPlayPageDetails — obligatoires: page_id, playlist_id, manifest_revision, expires_at
objet détails sur un événement durable player.play_page.
ScreenPlayPageWrite — obligatoires: page_id
ScreenPlayerIdentity — obligatoires: legacy, seen_at
Identité affirmée à partir du dernier runtime jumelé mint. Métadonnées d’afficheur en lecture seule, jamais d’autorisation. Les octrois internes et champs mint sont retenus.
ScreenPlaylistPatch — obligatoires: playlist_id
Une affectation de la liste de lecture d’un écran (patchScreenPlaylist). Le corps n’a aucun autre membre.
ScreenPlaylistSchedule — obligatoires: entries, updated_at
Programmation de la liste de lecture évaluée par le serveur. Elle n’atteint jamais le manifeste d’exécution ; le manifeste est construit à partir de la liste de lecture effective qu’il sélectionne. Écrivez-la avec PUT /api/screens/{id}/playlist-schedule.
ScreenPlaylistScheduleView — obligatoires: entries
ScreenPlaylistScheduleWrite — obligatoires: entries
ScreenPresenceHistory — obligatoires: items, next_cursor
ScreenPresenceTransition — obligatoires: at, state
ScreenProvisioning — obligatoires: screen, public_url, provisioning_url, expires_at
ScreenRebootAccepted — obligatoires: reboot_id, expires_at, state
ScreenRebootSchedule — obligatoires: enabled, windows, updated_at
Les fenêtres dans lesquelles le backend redémarre l’écran. Présent tant qu’une est définie.
ScreenRebootScheduleView — obligatoires: reboot_schedule, next_reboot_at
ScreenRebootScheduleWrite — obligatoires: enabled, windows
ScreenRecoveryHost — obligatoires: none
Ce que l’appareil demandant à récupérer cet écran déclare être, copié depuis l’objet hôte du début du jumelage. Champs descriptifs seulement ; il ne contient jamais de duid, numéro de série ou mac. Les champs absents n’ont pas été signalés.
ScreenRecoveryPending — obligatoires: expires_at
Présent pendant qu’une session de jumelage native ayant présenté l’identité matérielle de cet écran attend que le projet propriétaire confirme avec POST /api/screens/{id}/recovery/confirm. Porte la date limite, qui est l’expiration propre à la session de jumelage, et les champs descriptifs de l’hôte de l’appareil offrant (jamais duid, numéro de série ou mac).
Un DUID est lisible par toute application sur le panneau, donc une offre est une surface de phishing : comparez host.model et host.firmware avec l’afficheur devant vous avant de confirmer.
Le serveur refuse une offre tant que la clé liée à l’écran a montré une activité dans les dix dernières minutes (émission de session, flux d’exécution, récupération de manifeste ou battement de présence), et accepte au plus trois offres par écran par heure glissante ; une nouvelle offre remplace l’offre en attente. Absent une fois confirmée, expirée ou réclamée comme nouvel écran. Lecture seule.
ScreenReloadAccepted — obligatoires: reload_id, expires_at, state
ScreenReplaceWrite — obligatoires: with
ScreenScheduleEntry — obligatoires: id, playlist_id
ScreenScheduleEntryWrite — obligatoires: playlist_id
Une entrée de programmation de liste de lecture, un niveau de la pile propre à l’écran (packages/schedule-contract SEMANTICS.md, Levels and the stack). id est facultatif (entry_N est assigné dans l’ordre si omis) et unique dans la programmation.
Il est en vigueur tant que tous ses membres de règle le sont : from (inclus) et until (exclu), bornes civiles à la minute sans décalage ; une occurrence de windows, monthly ou dates (aucun des trois ne se répète chaque jour) dont la date n’est pas dans except ; data, une condition de données de carte ; interaction, tant que quelqu’un utilise l’écran.
Une entrée définit au moins un membre de règle. data, interaction, covers et un verrou displays qui laisse des sorties de côté sont respectés par un Player qui résout sa propre pile ; la résolution du serveur pour les autres Players ignore une telle entrée (stack_only).
ScreenSchedulePreviewRequest — obligatoires: entries
ScreenScheduleRevision — obligatoires: revision, created_at, change, current, entries
Une révision stockée de l’horaire de liste de lecture d’un écran : sa liste entries complète après une écriture (sans entries : l’écran n’avait pas d’horaire). revision est la révision de l’écran lors de l’écriture. change est edited, restored (une copie d’une révision antérieure, nommée par restored_from) ou baseline (l’horaire que l’écran détenait au début de son historique).
ScreenScheduleRevisionList — obligatoires: items
ScreenScheduleWindow — obligatoires: days
Une fenêtre screenrig.schedule/v1 dans le fuseau horaire de l’écran. Les jours sont stockés du lundi au dimanche. Omettre début et fin pour toute la journée. end <= start traverse minuit et le jour de début en est propriétaire (ven 22:00-02:00 s’étend au samedi matin); des bords égaux couvrent 24 heures complètes.
ScreenScope — obligatoires: folder_ids, screen_ids
Ce sur quoi un membre ou un agent à périmètre peut agir (docs/screen-scope.md) : les écrans des dossiers d’écrans listés et de chaque dossier qu’ils contiennent, et les écrans listés. Au moins un ID dans l’ensemble. Un ID qui ne nomme aucun dossier ou écran actif du projet au moment de l’écriture est invalid_request à sa position ; une suppression ultérieure laisse un ID mort, qui n’accorde rien.
Le périmètre est lu à chaque requête, de sorte qu’une modification s’applique à la suivante. Les étiquettes ne sont jamais un périmètre.
ScreenScreenshotAccepted — obligatoires: capture_id, expires_at
ScreenScreenshotFailedDetails — obligatoires: capture_id, reason
objet détails sur un événement durable screen.screenshot_failed.
ScreenScreenshotReadyDetails — obligatoires: capture_id, bytes, width, height, sha256
objet détails sur un événement durable screen.screenshot_ready. Pixels et clés d'objet non présents.
ScreenScreenshotRequestedDetails — obligatoires: capture_id, expires_at, max_width_divisor, max_height_divisor, format, quality, max_bytes
objet détails sur un événement durable screen.screenshot_requested. Octets d'image et clés d'objet non présents.
ScreenScreenshotStatus — obligatoires: state
ScreenStackStatus — obligatoires: manifest_revision, levels, playing, reported_at
Ce que le Player de l’écran a rapporté en dernier de sa pile (docs/player-compatibility.md §6.11) : l’état de préparation de chaque niveau et le niveau que montre chaque affichage dans chaque région (la page et toute bande). Présent uniquement pour un Player qui résout sa propre pile, tant que cette pile est à jour.
ScreenStatus — obligatoires: chip, observed_at, received_at
La puce de statut que le Player de l’écran a signalée en dernier avec PUT /screen/status (docs/player-compatibility.md §9.5) : la condition screenrig.overlay/v1 qui l’emporte selon son rang, ou null lorsque le Player n’affiche aucune puce. Absente jusqu’au premier rapport accepté. Effacée lors de la réinitialisation d’identité, du déjumelage et de l’archivage.
C’est le dernier rapport du Player, donc les consommateurs le considèrent comme périmé lorsque l’écran n’est pas en ligne (Screen.online), comme tout rapport du Player. level et icon proviennent du catalogue du backend pour chip, jamais du Player, et sont absents lorsque chip est null. Lecture seule sur l’API projet. Jamais autorisation ou admission. ScreenPatch ne peut pas l’écrire.
ScreenStatusChangedDetails — obligatoires: chip
objet détails d’un événement durable screen.status_changed propre au projet, ajouté lorsque PUT /screen/status modifie le chip, le level ou l’icon stocké. level et icon sont absents lorsque chip est null. Ce type n’est pas une commande d’audience d’exécution et n’est pas livré sur GET /screen/events.
ScreenStorage — obligatoires: observed_at, received_at, volume, cache, durability, plan, transfer_24h
Rapport de stockage du lecteur assaini. Absent jusqu’au premier PUT accepté /screen/storage. Effacé lors de la réinitialisation d’identité, du déjumelage et de l’archivage. Les consommateurs considèrent received_at de plus de 24 heures comme périmé. Lecture seule sur l’API projet. Jamais autorisation ou admission. ScreenPatch ne peut pas l’écrire.
ScreenStorageCache — obligatoires: house_used_bytes, capacity_bytes, reserve_bytes, protected_bytes, fallback_bytes, warm_bytes, ad_headroom_bytes
ScreenStorageExcludedPage — obligatoires: page_id, reason
ScreenStorageForecast — obligatoires: manifest_revision, fit, excluded_page_count, basis, received_at
Sélection approximative de l’état stable cible (plan A.3 seulement, pas de transition) à partir de la dernière capacité rapportée et du manifeste désiré de l’écran. Absent sans rapport de stockage, que les consommateurs lisent comme inconnu. La base est reported_capacity. Recalculé à l’arrivée d’un rapport de stockage et quand la révision du manifeste de l’écran change. Jamais autorisation ou admission.
ScreenStorageForecastDryRun — obligatoires: fit, excluded_page_count, required_bytes, capacity_bytes, basis, received_at
Simulation d’ajustement pré-affectation pour une liste de lecture. fit, excluded_page_count et required_bytes proviennent du plan A.3 sélection cible contre la dernière capacité rapportée de l’écran (base reported_capacity) ; il n’y a pas de prédiction de transition et rien n’est traité comme local. required_bytes est le coût retenu de chaque page de la liste de lecture. fit inconnu signifie que l’écran n’a pas de rapport de stockage, ou que les références de contenu de la liste ne sont pas prêtes ; required_bytes, capacity_bytes et received_at sont alors nuls. received_at est l’heure de réception du rapport de stockage, et un rapport de plus de 24 heures est périmé mais toujours utilisé pour la prévision, exactement comme Screen.storage_forecast.
Ce sont des métadonnées en lecture seule et jamais une autorisation ou admission.
ScreenStorageForecastRequest — obligatoires: playlist_id
Corps de la simulation de pré-affectation. playlist_id doit être une playlist du projet authentifié ; celle d’un autre projet ou un identifiant inconnu est not_found.
ScreenStoragePlan — obligatoires: manifest_revision, fit, transition, required_bytes, target_bytes, excluded_pages
ScreenStorageShortfall — obligatoires: at, fit, required_bytes, capacity_bytes, excluded_page_count
Présent pendant que l’ajustement rapporté du lecteur est partiel, transition_blocked ou none_fit, sauf un plan transition_blocked dont la seule raison de blocage est anchor_unavailable : c’est un échec de téléchargement sur un appareil avec de la place, pas un manque. at est quand la condition a commencé.
Il est défini une fois lorsque la condition commence et supprimé lorsqu'elle se termine, chaque transition ajoutant un événement propre au projet, screen.storage_shortfall ou screen.storage_shortfall_cleared. Ces événements ne sont pas livrés sur GET /screen/events. Effacé avec Screen.storage lors de la réinitialisation d'identité, du désappariement et de l'archivage.
Métadonnées de santé du projet en lecture seule ; ne modifie pas la révision de l’écran ni l’autorité du manifeste et n’est jamais une autorisation.
ScreenStorageTransfer — obligatoires: new, refetch, repair, failed
ScreenStorageVolume — obligatoires: total_bytes, available_bytes
ScreenSurfaceChangedDetails — obligatoires: observed_at, surfaces
objet détails sur un événement durable screen.surface_changed projet. Pixels non présents. Ce type n'est pas une commande d'audience d'exécution et n'est pas livré sur GET /screen/events.
ScreenSuspendWrite — obligatoires: message
ScreenSuspension — obligatoires: message, since
Présent tant que l’écran est suspendu (docs/player-compatibility.md §6.9). Le manifeste d’exécution porte le même objet comme membre suspension.
ScreenTags — obligatoires: none
Étiquettes de sélection de flotte, de 0 à 16 étiquettes exactes uniques, chacune correspondant à la grammaire des étiquettes médias. Sur ScreenPatch, le tableau remplace l’ensemble complet et un tableau vide le vide ; une étiquette en double ou mal formée est invalid_request. Modifier les étiquettes augmente la révision de l’écran (If-Match la protège) et ajoute screen.updated avec details.tags ; cela ne modifie jamais la révision du manifeste.
Les étiquettes ne figurent jamais dans le manifeste d’exécution ni dans l’autorisation.
ScreenTagsPatch — obligatoires: tags
Un ensemble complet de nouvelles étiquettes d’écran (patchScreenTags). Le tableau remplace toutes les étiquettes que l’écran porte et un tableau vide les efface. Le corps n’a aucun autre membre.
ScreenTakeover — obligatoires: playlist_id, until, set_at
La liste de lecture qui l'emporte sur les campagnes, l'horaire et l'assignation jusqu'à until, ou jusqu'à son annulation lorsque until vaut null.
ScreenTakeoverWrite — obligatoires: playlist_id
ScreenTimelineSegment — obligatoires: from, to, source
ScreenToastAccepted — obligatoires: expires_at
ScreenToastDetails — obligatoires: level, text, duration_ms, expires_at
objet détails sur un événement durable screen.toast. Couleurs non présentes.
ScreenToastWrite — obligatoires: level, text
ScreenUptime — obligatoires: items
ScreenVerbosityPatch — obligatoires: none
Une modification du niveau de journal et du niveau de toast d’un écran (patchScreenVerbosity). Le corps nomme au moins l’un des deux membres et aucun autre.
ScreenVerdict — obligatoires: kind, playlist_id, verdict
Un candidat à l’instant expliqué. won : le résolveur le choisit (sur un écran dont le Player résout sa propre pile : il remplit sa région sur un affichage ciblé). outranked : il est en vigueur, et by est le candidat qui l’a emporté. not_started : avant son from. ended : à son until ou après (une prise de contrôle : sa fin). outside_hours : entre from et until, hors de ses fenêtres. conditional : sur un écran dont le Player résout sa propre pile, il est en vigueur selon l’heure et joue tant que la condition observée uniquement par le Player est aussi remplie (reason interaction ou data). off : il ne s’applique pas, et reason dit pourquoi.
ScreenWall — obligatoires: outputs, arrangement
Le mur vidéo qu’affiche le Player d’un écran : de deux à douze sorties qui montrent une seule toile. Sa configuration nécessite un Player ayant déclaré la capacité hôte display.wall (docs/player-compatibility.md §6.5, §6.8). Une playlist avec un format l’étend.
ScreenshotCaptureID — obligatoires: none
Préfixe optionnel stage_, qa_ ou development_, puis shot_ et un suffixe aléatoire. Les nouveaux suffixes utilisent 16 caractères alphanumériques excluant oOlL ; les suffixes hérités conservés sont acceptés.
SelectorPreview — obligatoires: primitive, selector, matched_count, candidates
SelectorPreviewInput — obligatoires: primitive, selector
SelectorPreviewMedia — obligatoires: media_id, filename, tags
ServiceClient — obligatoires: id, project_id, name, capabilities, access, state, created_by, keys, secrets, created_at, updated_at, authenticated_requests, tokens_issued
ServiceClientChange — obligatoires: none
ServiceClientKey — obligatoires: kid, alg, thumbprint, jwk, added_at
ServiceClientList — obligatoires: items
ServiceClientResult — obligatoires: client
ServiceClientSecret — obligatoires: id, hint, added_at
SessionDescription — obligatoires: type, sdp
SessionSSOStartRequest — obligatoires : intent
SignInPolicy — obligatoires: password, passkey, passkey_enrollment_required, policy_revision, federated
Politique de connexion de personne vérifiée. Les paramètres passifs préservent la connexion locale. Une politique d’organisation appliquée dirige la connexion via son fournisseur d’identité.
SignInResetAccepted — obligatoires: status
Identique pour les adresses connues et inconnues ; aucune adresse, identifiant, projet ou statut de livraison n’est retourné.
SignInResetRequest — obligatoires: email
SignupCreated — obligatoires: user_id, project_id, organization_id
SignupHeardDetail — obligatoires: none
Le suivi de heard. kind nomme un choix dans une courte liste, et text est du texte libre.
SignupPasskeyOptionsRequest — obligatoires: email, display_name
SignupProfile — obligatoires: none
Les réponses qu’une personne donne après son inscription. Chaque membre est facultatif et peut être null, ce qui signifie sans réponse ou ignoré.
SignupRequest — obligatoires: email, display_name, marketing_email, credential
L’adresse courriel et le nom d’affichage sont ceux avec lesquels la cérémonie a été démarrée.
Source — obligatoires: id, name, kind, target, enabled, config, preset, settings, secrets, refresh_seconds, stale_after_seconds, revision, status, created_at, updated_at
SourceArea — obligatoires: key, name, rooms, status, screens
SourceCreate — obligatoires: name, target
La configuration JSON, CSV et Sheets peut définir key_template, une clé de données de carte contenant des jetons {screen.field.NAME}. Le mappage produit alors {documents:[{fields:{NAME:VALUE},document:{...}}]} au lieu d’un seul document. Chaque sortie est validée selon la carte cible.
Les clés sont uniques et se trouvent hors des espaces de noms des instances de carte et des flux; source test affiche un aperçu de l’enveloppe et valide chaque sortie. Chaque clé utilise le délai de péremption de la source. Les clés absentes conservent leurs données et leur expiration; une erreur de stockage peut laisser des écritures partielles et l’exécution suivante réessaie.
SourceError — obligatoires: code, message, at
SourceKind — obligatoires: none
D’où viennent les données. ics lit les adresses iCalendar et webcal:// (les autres types sont décrits dans /docs/sources). Un type qui n’est pas disponible répond invalid_request sur kind.
SourceList — obligatoires: items, next_cursor
SourcePreset — obligatoires: name, title, category, description, kind, cards, fields, secrets, refresh_seconds, min_refresh_seconds, stale_after_seconds, attribution, docs
Une configuration toute prête et testée de la source de données json.
SourcePresetAttribution — obligatoires: text
SourcePresetCard — obligatoires: type, default
SourcePresetField — obligatoires: name, label, type, required, help
Une information qu’une personne donne à un préréglage. Un texte est vérifié selon pattern et max_length, un choix est l’une des options, et une liste contient de min_items à max_items objets remplis avec fields.
SourcePresetList — obligatoires: items
SourcePresetOption — obligatoires: value, label
SourcePresetSecret — obligatoires: name, label, help, how_to_get, required
Un identifiant dont un préréglage a besoin, saisi sous name dans secrets.
SourceRoom — obligatoires: key, status, screens
SourceRoomRef — obligatoires: id, name
SourceRoomScreen — obligatoires: id, name, kind, field, value, status
SourceRooms — obligatoires: source_id, room_field, room_key_prefix, area_field, area_key_prefix, rooms_as_of, summary, rooms, areas, screens, warnings
Le mappage des salles d’une source de données qui écrit un document pour chaque salle ou zone : les salles que la source offrait lors de sa dernière bonne actualisation face aux écrans qui les lisent.
Un écran fait partie du rapport d’un champ lorsqu’il a une valeur pour celui-ci, ou lorsque sa propre liste de lecture place une carte dont la clé de données est le préfixe de clé suivi de {screen.field.NAME}; une liste de lecture atteinte par un dossier, une campagne ou un niveau de calendrier n’est pas suivie.
SourceRoomsSummary — obligatoires: rooms, unmapped_rooms, areas, unmapped_areas, screens, missing_screens, unknown_screens
SourceSecretView — obligatoires: set, hint, updated_at
SourceStaleAfter — obligatoires: none
Durée pendant laquelle la carte garde les dernières bonnes données de la source lorsqu’elle ne peut pas s’actualiser, en secondes.
La source écrit ses documents pour qu’ils expirent aussi longtemps après la dernière bonne actualisation : si elle continue d’échouer, ils se vident sur chaque écran (y compris hors ligne) et les pages dont la visibilité dépend des données basculent sur les pages suivantes; une source qui n’échoue pas renouvelle l’échéance à mesure qu’elle s’actualise.
Au moins le double de refresh_seconds. null garde les dernières bonnes données jusqu’à la prochaine actualisation de la source (valeur par défaut de tous les types sauf momentus, dont la valeur par défaut est 1800 lorsque le membre est omis à la création). Une source en échec qui dépasse la période est périmée (status.stale) et ajoute source.stale.
SourceStatus — obligatoires: state, last_attempt_at, last_success_at, last_change_at, next_run_at, failures, stale, data_expires_at, error, warnings, stats
Ce que les dernières exécutions ont fait. state vaut pending (pas encore exécutée), ok (la dernière récupération a réussi et la carte a accepté le document), error (la dernière exécution a échoué et la carte a gardé son dernier bon document) ou disabled. ok ne juge pas si les données en amont sont exactes ou à jour, ni si un écran affiche la carte.
SourceTarget — obligatoires: card_id
SourceTestRequest — obligatoires: none
SourceTestResult — obligatoires: document, valid, warnings, stats, fetched_at
SourceUpdate — obligatoires: none
StackLevel — obligatoires: id, source, playlist_id
Un niveau de la pile d’un écran (packages/schedule-contract SEMANTICS.md, Levels and the stack). id est takeover, campaign:ID, schedule:ENTRY_ID, default ou folder:FOLDER_ID ; record_id désigne la campagne, l’entrée ou le dossier, name le nom de la campagne ou du dossier. Sans rule, le niveau est toujours en vigueur.
StackLevelRule — obligatoires: none
StreamSource — obligatoires: none
StreamSourceWrite — obligatoires: none
Une source de flux. Une source peut ne donner que son url et laisser le schéma nommer le protocole : https est hls, rtsp et rtsps sont rtsp.
SupportConversation — obligatoires: id, subject, created_at, updated_at, last_sequence, human_requested, unread_staff, closed
SupportConversationList — obligatoires: items, next, unread_staff_total
SupportHours — obligatoires: timezone, start, end, weekdays, excludes_bc_holidays
SupportMessage — obligatoires: id, conversation_id, sequence, role, author, body, created_at
SupportMessageList — obligatoires: items
SupportRead — obligatoires: sequence
SupportStatus — obligatoires: chat_allowed, available, staffed, human_available, hours, human_wait_seconds, docs_url
SupportSubmission — obligatoires: conversation, message
SupportWrite — obligatoires: body
TabShare — obligatoires: id, until, screens, skipped, warnings
TabShareCookie — obligatoires: name, value, domain
Un témoin au format de l’API de témoins du navigateur. Sa valeur est secrète.
TabShareScreen — obligatoires: id, label
TabShareSkip — obligatoires: id, label, code, detail
Une cible non reprise. code est le code de problème qu’aurait renvoyé la reprise de cet écran seul.
TabShareState — obligatoires: id, until, screens
TabShareStopped — obligatoires: id, screens
TabShareWarning — obligatoires: code, url, detail
TabShareWrite — obligatoires: tabs
Les onglets à afficher et leurs écrans cibles. Au moins un de screen_ids, folder_ids et tags.
Trigger — obligatoires: id, kind, label, target, default_for_seconds, url, username, revision, created_at, updated_at
Un déclencheur CAP ou un déclencheur de superposition. Son mot de passe n’est renvoyé que par la création et rotate-secret.
TriggerAlert — obligatoires: id, revision, state, status, msg_type, sender, identifier, until, screens, started_at, updated_at
La dernière alerte du déclencheur, issue des champs du message CAP.
TriggerAlertScreens — obligatoires: targeted, taken_over, cleared, skipped, failed, pending
Ce que le dernier changement de prise en charge a fait. Les comptes ignorent les écrans sans liste de lecture par défaut, archivés ou disparus, et, lors du nettoyage, les écrans qu’une autre prise en charge a remplacés depuis.
Un écran dans un dossier d’écrans protégé est laissé tel quel et compté dans protected, non ignoré ; mettre fin à une alerte (annulation, fin d’alerte, effacement par un opérateur) efface quand même ce que le déclencheur a défini sur un tel écran.
TriggerClear — obligatoires: none
TriggerDelivery — obligatoires: at, outcome, status, bytes, request_id
TriggerDeliveryList — obligatoires: items
TriggerList — obligatoires: items
TriggerOverlay — obligatoires : show, style, enabled, signing, alerts, screens, pending
Configuration et état d’un déclencheur de superposition.
TriggerOverlayAlert — obligatoires : id, until, started_at, updated_at, revision
TriggerOverlayReceipt — obligatoires : outcome, trigger_id, until, active
TriggerOverlayRequest — obligatoires: none
Un envoi à un déclencheur de superposition, tel que lu après le mapping du déclencheur (s’il y en a un). Un arrêt ignore tous les membres sauf alert_id, clear et state.
TriggerOverlayScreens — obligatoires : targeted, holding, taken_over, removed, edge_taken, skipped, failed
Ce que la dernière diffusion a fait aux écrans cibles. Un écran dans un dossier d’écrans protégé est laissé tel quel et compté dans protected, non ignoré ; mettre fin à l’alerte efface quand même ce que le déclencheur y a défini.
TriggerOverlayStyle — obligatoires: none
Les paramètres statiques de la carte de texte avec lesquels une superposition est dessinée. Le déclencheur choisit la disposition.
TriggerOverlayWrite — obligatoires : show
TriggerPatch — obligatoires: none
TriggerReceipt — obligatoires: outcome, trigger_id
TriggerSecretRotate — obligatoires: none
TriggerTarget — obligatoires: none
Exactement un de tag et screen_ids.
TriggerWithPassword — obligatoires: none
TriggerWithSecrets — obligatoires: none
TriggerWrite — obligatoires: label, target
UDPStreamSource — obligatoires: protocol, group, port
URLStreamSource — obligatoires: url
UploadScope — obligatoires: playlist_ids, folder_ids
Ce qu’un téléverseur peut utiliser (docs/uploaders.md) : les listes de lecture dont il modifie les pages et les dossiers de médias dans lesquels il téléverse. Les dossiers sont exactement ceux qui sont listés, jamais leurs sous-dossiers. Un id qui ne désigne aucun objet actif du projet à l’écriture donne invalid_request à sa position ; une suppression ultérieure laisse un id mort, qui ne donne aucun droit.
Le périmètre est lu à chaque requête, de sorte qu’un changement s’applique à la suivante.
UptimeDay — obligatoires: day, online_s, offline_s, availability, coverage
Un jour UTC. la disponibilité est online_s sur online_s plus offline_s, null quand rien n’a été enregistré. la couverture est la part de la journée (de chaque journée d’écran rapportée dans une ligne de projet) avec un état enregistré, de 0 à 1 : un trou réduit la couverture et n’est jamais du temps hors ligne. les intervalles (lignes d’écran) sont le nombre d’intervalles enregistrés touchant la journée ; les écrans (lignes de projet) sont le nombre d’écrans ayant un état enregistré ; live marque une journée d’écran incluant l’intervalle ouvert jusqu’à maintenant.
UsageFrame — obligatoires : page_id, primitive_id, rect
Une primitive image ou vidéo qui nomme le fichier média, avec son cadre et la façon dont le fichier le remplit.
UsageScreen — obligatoires : id, label, screen, playlist_ids, how
Un écran actif qui utilise au moins l’une des listes de lecture répertoriées.
UsageScreenHow — obligatoires : playlist_id, uses
UsageTagFilter — obligatoires : all, any, none
Le filtre d’un sélecteur d’étiquette. Un fichier correspond lorsqu’il possède chaque étiquette de all, au moins une étiquette de any si any en nomme, et aucune étiquette de none ; le sélecteur d’étiquette abrégé est all avec une seule étiquette.
UsageTrack — obligatoires : index, id
UserEmailChangeAccepted — obligatoires: none
UserEmailChangeRequest — obligatoires: email, proof
Demande un changement d’adresse courriel vérifiée avec une preuve récente. L’adresse courriel actuelle reste effective pendant la vérification. L’ancienne adresse reçoit un avertissement uniquement, sans lien d’annulation.
VerifiedOrganizationDomain — obligatoires: domain, organization_id, state, verified_at
VersionResponse — obligatoires: version, commit, api_version, protocol_version
Webhook — obligatoires: id, url, event_types, enabled, revision, status, created_at, updated_at
Un webhook de projet. Les enregistrements du journal du lecteur (runtime.reported) ne sont pas livrés.
Chaque événement de projet correspondant est POSTé à url comme le même objet JSON que GET /api/events retourne, avec les en-têtes ScreenRig-Webhook-Id, ScreenRig-Event-Id (le curseur d’événement, stable malgré les réessais), User-Agent, et ScreenRig-Signature t=<unix seconds>,v1=<hex HMAC-SHA256 over "<t>.<raw body>" clé avec la chaîne secrète>.
Une réponse 2xx dans les 10 secondes réussit ; tout autre statut, une redirection (jamais suivie), un délai d’attente ou une défaillance de connexion ou TLS est réessayé avec un retour exponentiel (30 secondes doublant jusqu’à une heure, avec aléa) pendant 24 heures, puis échoue. Après trois délais d’attente consécutifs, le délai d’attente de la tentative tombe à 5 secondes jusqu’à ce qu’une réponse arrive.
Un webhook a au plus une tentative en cours et un projet au plus deux, sur tous les serveurs. La livraison est au moins une fois et non ordonnée ; dédupliquez sur ScreenRig-Event-Id.
Chaque tentative est comptabilisée comme un événement du flux d’écoute (1 crédit après l’allocation mensuelle de 10 000 API/SSE), et les mêmes événements qui sont gratuits sur le flux d’écoute le sont ici : screen.*, runtime.*, alert_mute.*, application.event, playback.page_failed et agent.command.
Une tentative refusée avant tout envoi (url_rejected, dns_failed) n'est pas facturée. payment_required et secret_unavailable espacent les tentatives, mais ne comptent jamais pour failing ni pour la désactivation automatique. status vaut failing tant qu'aucune livraison n'a réussi depuis failing_since; après 72 heures d'échecs continus, le webhook est désactivé (disabled_reason delivery_failures) et notification.disabled est ajouté.
WebhookDelivery — obligatoires: id, webhook_id, event_id, event_type, state, attempts, created_at
WebhookDeliveryAttempt — obligatoires: attempt, at, status, error, duration_ms
WebhookDeliveryAttemptList — obligatoires: items
WebhookDeliveryList — obligatoires: items, next_cursor
WebhookEventTypes — obligatoires: none
Types d'événements exacts comme screen.online, ou préfixes se terminant par .* comme screen.* (tous les types commençant par screen.). notification.test n'est jamais diffusé par un abonnement; il n'est envoyé que par POST /api/webhooks/{id}/test.
WebhookHandshake — obligatoires: none
Une poignée de main de fournisseur à laquelle l’URL répond, pour un fournisseur sans schéma de signature ici. microsoft_graph répond à un POST qui porte un paramètre de requête validationToken en renvoyant le jeton décodé comme text/plain. monday répond à un POST JSON de {"challenge": "..."} par le même JSON. trello répond à sa vérification HEAD par 200. azure_event_grid répond à un SubscriptionValidationEvent (aeg-event-type: SubscriptionValidation) par {"validationResponse": "<validationCode>"}. verify.vendor slack répond au défi url_verification signé de Slack, et verify.vendor asana répond à la poignée de main X-Hook-Secret d’Asana et garde ce secret pour vérifier ses événements.
Une poignée de main n’est traitée que pour un webhook configuré pour ce fournisseur, n’écrit rien, n’est jamais facturée et ne consomme aucun budget de débit, et elle est consignée dans le journal de livraison avec le résultat handshake. Un webhook désactivé n’en traite aucune.
WebhookList — obligatoires: items
WebhookPatch — obligatoires: none
WebhookVerify — obligatoires: vendor, secret
La vérification du fournisseur d’un webhook ou d’un déclencheur, telle qu’une lecture la montre. Le secret n’est jamais qu’un indice.
WebhookVerifyVendor — obligatoires: none
WebhookVerifyWrite — obligatoires: vendor
Un fournisseur dont la propre signature authentifie un envoi à la place du secret, parce que ces fournisseurs ne peuvent pas envoyer le nôtre.
L’en-tête et le schéma de chacun sont ceux du fournisseur et sont fixes : github envoie X-Hub-Signature-256, sha256= et le HMAC-SHA256 hexadécimal du corps ; stripe envoie Stripe-Signature, t=<unix seconds>,v1=<hex HMAC-SHA256 of "<t>.<body>"> (plusieurs v1 pendant la rotation d’un secret, t à moins de cinq minutes) ; shopify envoie X-Shopify-Hmac-Sha256, le HMAC-SHA256 du corps en base64 ; slack envoie X-Slack-Signature, v0= et le HMAC-SHA256 hexadécimal de "v0:<X-Slack-Request-Timestamp>:<body>" (à moins de cinq minutes) ; linear envoie Linear-Signature, le HMAC-SHA256 hexadécimal du corps, et le membre webhookTimestamp du corps (millisecondes Unix) doit se situer à une minute près ; vercel envoie x-vercel-signature, le HMAC-SHA1 hexadécimal du corps ; asana envoie X-Hook-Signature, le HMAC-SHA256 hexadécimal du corps avec pour clé le X-Hook-Secret de la poignée de main d’Asana ; generic_hmac désigne tout expéditeur qui signe en HMAC-SHA256 dans l’en-tête que vous nommez.
Un envoi qui porte une signature valide est accepté sans le secret, et le secret continue de fonctionner à côté. verify ne peut pas être combiné avec signing. Un envoi est jugé sur le corps tel qu’il est arrivé, avant de consommer du budget de débit. Slack et Asana répondent aussi à leurs poignées de main (voir WebhookHandshake).
WebhookWithSecret — obligatoires: id, url, event_types, enabled, revision, status, created_at, updated_at, secret
Un Webhook plus son secret de signature. Rendu uniquement par create et rotate-secret.
WebhookWrite — obligatoires: url, event_types
WebsiteSetupCode — obligatoires: code, expires_at