Skip to main content
Summer Content: a game’s kit, trending references, finished pieces and the team’s library. 28 operations. How to call them, and what the answers mean: Operations reference.
Generated from the summer-engine npm package 4.8.0: its public operation catalog (registry/operations/public-catalog.json) and its engine and local operations. If something here is wrong, the operation’s definition is wrong.

​
add_feedback

content.add_feedback: Review a piece Ask for changes on a piece (say what), approve it or reject it; words alone are a note. A Change note becomes a learning in the game’s kit and asks for a revised version (a make request the maker picks up). Use it when the person reviews through you. Returns the piece, the learning and the make. Inputs:
Example: Ask for a change.
content.add_link: Add a link to the content library Save a web link (a video, a post, a board) in a team’s Content library as a reference, with what it shows and tags. Returns the item. Next: content.search_library. Inputs:
Example: A style reference.

​
add_reference

content.add_reference: Add a reference to the team feed Add or replace (same id) trending videos in a team’s Content feed, to remake with the game’s characters. The team’s owners and admins only. A video in the library can be its clip (clipItemId). Inputs:
Example: A trend for the team.

​
claim_make

content.claim_make: Claim a make request For the maker (summer content make): take the request you name (requestId), else the team’s oldest open one (one game’s, when given); null when there is nothing to make. The claim lasts 30 minutes; every content.update_make renews it. Inputs:
Example: Anything to make?

​
create_game

content.create_game: Add a game to Content Add a game to a team’s Summer Content with its first kit (its name is required; the rest can come later with content.update_kit). Returns the kit and the team’s games. Inputs:
Example: A new Content game.

​
delete_item

content.delete_item: Delete a content library item Delete an item and its file from a team’s Content library for good. Runs when the person allows Delete for good (off by default); otherwise answers needs_approval with a link. Inputs:
Example: Delete a clip.

​
delete_learning

content.delete_learning: Remove a learning from a kit Remove one thing the maker learned from the team’s notes (content.get_kit learnings), when the person says it no longer holds. Returns the kit’s learnings. Inputs:
Example: They changed their mind about a note.

​
get_item

content.get_item: Read a content library item One item of a team’s Content library, with a short signed link to open the file and one to download it. Next: content.update_item. Inputs:
Example: Open a clip.

​
get_kit

content.get_kit: Read a game’s kit Read a Content game’s kit: name, logo, characters with pictures, colours, type, voice, style, do and don’t rules, reference items, sections, niches, and its revision. Next: content.update_kit to change sections. Inputs:
Example: The kit of a game.

​
get_make

content.get_make: Read a make request One make request: its state, the stage it is on, every stage so far, and at the end the piece it made or the one thing it was missing. jobs.wait with make:<requestId> follows it too. Inputs:
Example: Is the piece ready?

​
get_piece

content.get_piece: Read a piece One finished piece: each platform’s render and cover as a short signed link, captions, notes, status and every piece of the team’s feedback. Next: content.update_piece to revise it. Inputs:
Example: Read the feedback on a piece.

​
get_reference

content.get_reference: Read one reference One reference of a Content game: the original post, why it performs, its hook, the idea for this game, and its videos with their current state. Changes nothing. Next: content.make_video, or make your own piece. Inputs:
Example: Is the video for this one ready?

​
list_games

content.list_games: List the team’s games A team’s games: its Content games, its Studio projects and the Summer Games games linked to them (all of the person’s in a personal workspace), each with its Content id (null until it has a kit), store page, project and code link. Next: content.get_kit, or content.create_game. Inputs:
Example: Which games have Content set up?

​
list_pieces

content.list_pieces: List a team’s pieces A team’s finished pieces, newest change first: all, one game’s, or one status’s, with the team’s feedback. needsWork marks the ones the team wants changed and whatToChange says what: revise those first. Next: content.get_piece. Inputs:
Example: What did the team ask me to change? Check at the start of every session.

​
list_references

content.list_references: List references for a game What is trending that fits a Content game, best fit first: each with why it performs, its hook, the idea for this game and any videos made from it. Reads what is stored; changes nothing. Next: content.get_reference. Inputs:
Example: What is trending that fits our game?

​
make

content.make: Ask for a piece of content Ask Summer to make a finished piece for a Content game (the daily run, or “clip what we just built”). The maker on the person’s computer claims it and the piece lands on Today. One request per game, UTC day, reference and note. Answers a job: jobs.wait follows it. Inputs:
Example: The daily run.

​
make_video

content.make_video: Make a video from a reference Remake one reference of a Content game with the game’s character swapped in. Spends the person’s credits. Takes a few minutes. Returns the video. Next: content.get_reference until it is ready. Inputs:
Example: Make this reference’s video.

​
mark_posted

content.mark_posted: Mark content as posted Record that the team posted something, when they say so: a piece on one platform (pieceId, platform, postUrl), or a video made from a reference (contentGameId, videoId). Returns what was marked. Inputs:
Example: They posted the TikTok.

​
save_piece

content.save_piece: Save a finished piece for review Save a finished piece for a Content game: one render per platform (library videos) with captions, plus why (the reference it copies, why it fits today), the measured checks, the side by side and the learnings it applied. It waits on Today unless status is draft. Returns it with reviewUrl. Inputs:
Example: Hand a finished TikTok to the team.

​
search_library

content.search_library: Search the team content library A team’s private Content library: raw clips, pictures, sound, references and finished renders, each with what happens in it, tags and a folder. Search by words; filter by kind, tag or folder. Files come with short signed links. Next: content.get_item. Inputs:
Example: Find the clip of the shrine spin.

​
skip

content.skip: Skip a piece Skip a piece the person does not want (Today’s Skip): it leaves Today and the next waiting piece shows. A reason becomes a learning in the game’s kit. Returns the piece and the learning. Inputs:
Example: Skip it, and say why.

​
today

content.today: Read Today for a game What the team sees on Today for a Content game: state (ready, making, stuck, empty), the best waiting piece with why, checks and the learnings it applied, the other waiting pieces, today’s make with its stages or the missing thing, what comes next, the history. Inputs:
Example: What is waiting today?

​
update_item

content.update_item: Edit a content library item Change an item in a team’s Content library: title, description (what happens in it), tags or folder (move it). Only what is given changes. Returns the item. Inputs:
Example: Describe a clip.

​
update_kit

content.update_kit: Change sections of a kit Replace some sections of a Content game’s kit (characters, colours, voice, rules, references…) and keep the rest. Pass expectedRevision from content.get_kit. Returns the kit. Inputs:
Example: Change the voice only.

​
update_make

content.update_make: Report on a make request For the maker: a stage (pick, study, footage, plan, voice, render, checks, compare, upload) running, done or failed, with one plain line; Today shows it live. Done on upload carries the pieceId and finishes the job; failed says what was missing. Inputs:
Example: A stage.

​
update_piece

content.update_piece: Revise a piece Change a piece after feedback: only what is given (renders, captions, title, notes…). status in_review sends it back to Today; draft takes it out. Pass expectedRevision from content.get_piece. Returns it. Inputs:
Example: Send the revised piece back for review.

​
upload_begin

content.upload_begin: Start a content library upload Start putting a file in a team’s Content library: a video up to 2 GB, or a picture, sound or PDF up to 200 MB. Returns a link that takes one PUT of the file with its content type, for an hour. Next: content.upload_complete. Inputs:
Example: Upload a finished render.

​
upload_complete

content.upload_complete: Finish a content library upload Finish an upload after the PUT: the file is checked and saved as a library item with what happens in it, tags and a folder. Finishing twice answers the same item. Returns the item. Next: content.save_piece for a finished render. Inputs:
Example: Finish the upload.