// Fan Housing
// The plastic housing that contains the fan and the motor

// Set units
@settings(defaultLengthUnit = mm)

// Import parameters
import * from "parameters.kcl"

// Model the housing which holds the motor, the fan, and the mounting provisions
// Bottom mounting face
bottomFaceSketch = startSketchOn(YZ)
  |> startProfile(at = [-fanSize / 2, -fanSize / 2])
  |> angledLine(angle = 0, length = fanSize, tag = $rectangleSegmentA001)
  |> angledLine(angle = segAng(rectangleSegmentA001) + 90deg, length = fanSize, tag = $rectangleSegmentB001)
  |> angledLine(angle = segAng(rectangleSegmentA001), length = -segLen(rectangleSegmentA001), tag = $rectangleSegmentC001)
  |> line(endAbsolute = [profileStartX(%), profileStartY(%)], tag = $rectangleSegmentD001)
  |> close()
  |> subtract2d(tool = circle(center = [0, 0], radius = 4))
  |> subtract2d(tool = circle(
       center = [
         mountingHoleSpacing / 2,
         mountingHoleSpacing / 2
       ],
       radius = mountingHoleSize / 2,
     ))
  |> subtract2d(tool = circle(
       center = [
         -mountingHoleSpacing / 2,
         mountingHoleSpacing / 2
       ],
       radius = mountingHoleSize / 2,
     ))
  |> subtract2d(tool = circle(
       center = [
         mountingHoleSpacing / 2,
         -mountingHoleSpacing / 2
       ],
       radius = mountingHoleSize / 2,
     ))
  |> subtract2d(tool = circle(
       center = [
         -mountingHoleSpacing / 2,
         -mountingHoleSpacing / 2
       ],
       radius = mountingHoleSize / 2,
     ))
  |> extrude(length = 4)

// Add large openings to the bottom face to allow airflow through the fan
airflowPattern = startSketchOn(bottomFaceSketch, face = END)
  |> startProfile(at = [fanSize * 7 / 25, -fanSize * 9 / 25])
  |> angledLine(angle = 140deg, length = fanSize * 12 / 25, tag = $seg01)
  |> tangentialArc(radius = fanSize * 1 / 50, angle = 90deg)
  |> angledLine(angle = -130deg, length = fanSize * 8 / 25)
  |> tangentialArc(radius = fanSize * 1 / 50, angle = 90deg)
  |> angledLine(angle = segAng(seg01) + 180deg, length = fanSize * 2 / 25)
  |> tangentialArc(radius = fanSize * 8 / 25, angle = 40deg)
  |> xLine(length = fanSize * 3 / 25)
  |> tangentialArc(endAbsolute = [profileStartX(%), profileStartY(%)])
  |> close()
  |> patternCircular2d(
       instances = 4,
       center = [0, 0],
       arcDegrees = 360,
       rotateDuplicates = true,
     )
  |> extrude(length = -4)

// Create the middle segment of the fan housing body
housingMiddleLength = fanSize / 3
housingMiddleRadius = fanSize / 3 - 1
bodyMiddle = startSketchOn(bottomFaceSketch, face = END)
  |> startProfile(at = [
       housingMiddleLength / 2,
       -housingMiddleLength / 2 - housingMiddleRadius
     ])
  |> tangentialArc(radius = housingMiddleRadius, angle = 90deg)
  |> yLine(length = housingMiddleLength)
  |> tangentialArc(radius = housingMiddleRadius, angle = 90deg)
  |> xLine(length = -housingMiddleLength)
  |> tangentialArc(radius = housingMiddleRadius, angle = 90deg)
  |> yLine(length = -housingMiddleLength)
  |> tangentialArc(radius = housingMiddleRadius, angle = 90deg)
  |> line(endAbsolute = [profileStartX(%), profileStartY(%)])
  |> extrude(length = fanHeight - 4 - 4)

// Cut a hole in the body to accommodate the fan
bodyFanHole = startSketchOn(bodyMiddle, face = END)
  |> circle(center = [0, 0], radius = fanSize * 23 / 50)
  |> extrude(length = -(fanHeight - 4 - 4))

// Top mounting face. Cut a hole in the face to accommodate the fan
topFaceSketch = startSketchOn(bodyMiddle, face = END)
topHoles = startProfile(topFaceSketch, at = [-fanSize / 2, -fanSize / 2])
  |> angledLine(angle = 0, length = fanSize, tag = $rectangleSegmentA002)
  |> angledLine(angle = segAng(rectangleSegmentA002) + 90, length = fanSize, tag = $rectangleSegmentB002)
  |> angledLine(angle = segAng(rectangleSegmentA002), length = -segLen(rectangleSegmentA002), tag = $rectangleSegmentC002)
  |> line(endAbsolute = [profileStartX(%), profileStartY(%)], tag = $rectangleSegmentD002)
  |> close()
  |> subtract2d(tool = circle(center = [0, 0], radius = fanSize * 23 / 50))
  |> subtract2d(tool = circle(
       center = [
         mountingHoleSpacing / 2,
         mountingHoleSpacing / 2
       ],
       radius = mountingHoleSize / 2,
     ))
  |> subtract2d(tool = circle(
       center = [
         -mountingHoleSpacing / 2,
         mountingHoleSpacing / 2
       ],
       radius = mountingHoleSize / 2,
     ))
  |> subtract2d(tool = circle(
       center = [
         mountingHoleSpacing / 2,
         -mountingHoleSpacing / 2
       ],
       radius = mountingHoleSize / 2,
     ))
  |> subtract2d(tool = circle(
       center = [
         -mountingHoleSpacing / 2,
         -mountingHoleSpacing / 2
       ],
       radius = mountingHoleSize / 2,
     ))
  |> extrude(length = 4)

// Create a housing for the electric motor to sit
motorHousing = startSketchOn(bottomFaceSketch, face = END)
  |> circle(center = [0, 0], radius = 11.2)
  |> extrude(length = 16)

startSketchOn(motorHousing, face = END)
  |> circle(center = [0, 0], radius = 10)
  |> extrude(length = -16)
  |> appearance(color = "#a55e2c")
  |> fillet(
       radius = abs(fanSize - mountingHoleSpacing) / 2,
       tags = [
         getNextAdjacentEdge(rectangleSegmentA001),
         getNextAdjacentEdge(rectangleSegmentB001),
         getNextAdjacentEdge(rectangleSegmentC001),
         getNextAdjacentEdge(rectangleSegmentD001),
         getNextAdjacentEdge(rectangleSegmentA002),
         getNextAdjacentEdge(rectangleSegmentB002),
         getNextAdjacentEdge(rectangleSegmentC002),
         getNextAdjacentEdge(rectangleSegmentD002)
       ],
     )


fan-housing

// Fan
// Spinning axial fan that moves airflow

// Set units
@settings(defaultLengthUnit = mm)

// Import parameters
import * from "parameters.kcl"

// Model the center of the fan
fanCenter = startSketchOn(YZ)
  |> circle(center = [0, 0], radius = fanHeight / 2, tag = $centerBend)
  |> extrude(length = fanHeight)
  |> fillet(radius = 1.5, tags = [getOppositeEdge(centerBend)])

// Create a function for a lofted fan blade cross section that rotates about the center hub of the fan
fn fanBlade(offsetHeight, startAngle) {
  fanBlade = startSketchOn(offsetPlane(YZ, offset = offsetHeight))
    |> startProfile(at = [
         15 * cos(startAngle),
         15 * sin(startAngle)
       ])
    |> arc(angleStart = startAngle, angleEnd = startAngle + 14deg, radius = 15)
    |> arc(
         endAbsolute = [
           fanSize * 22 / 50 * cos(startAngle - 20deg),
           fanSize * 22 / 50 * sin(startAngle - 20deg)
         ],
         interiorAbsolute = [
           fanSize * 11 / 50 * cos(startAngle + 3deg),
           fanSize * 11 / 50 * sin(startAngle + 3deg)
         ],
       )
    |> arc(
         endAbsolute = [
           fanSize * 22 / 50 * cos(startAngle - 24deg),
           fanSize * 22 / 50 * sin(startAngle - 24deg)
         ],
         interiorAbsolute = [
           fanSize * 22 / 50 * cos(startAngle - 22deg),
           fanSize * 22 / 50 * sin(startAngle - 22deg)
         ],
       )
    |> arc(
         endAbsolute = [profileStartX(%), profileStartY(%)],
         interiorAbsolute = [
           fanSize * 11 / 50 * cos(startAngle - 5deg),
           fanSize * 11 / 50 * sin(startAngle - 5deg)
         ],
       )
    |> close()
  return fanBlade
}

// Loft the fan blade cross sections into a single blade, then pattern them about the fan center
crossSections = [
  fanBlade(offsetHeight = 4.5, startAngle = 50deg),
  fanBlade(offsetHeight = (fanHeight - 2 - 4) / 2, startAngle = 30deg),
  fanBlade(offsetHeight = fanHeight - 2, startAngle = 0)
]
bladeLoft = loft(crossSections)
  |> patternCircular3d(
       instances = 9,
       axis = [1, 0, 0],
       center = [0, 0, 0],
       arcDegrees = 360deg,
       rotateDuplicates = true,
     )

[fanCenter, bladeLoft]
  |> appearance(color = "#110803")


// Heat Sink
// Conductive metal device made from brazed tubes and fins

// Set units
@settings(defaultLengthUnit = mm)

// Import parameters
import * from "parameters.kcl"

// Draw the sweep path for the outermost tubes
endTubePath = startSketchOn(offsetPlane(YZ, offset = -20))
  |> startProfile(at = [fanSize / 4, fanSize + 38])
  |> yLine(endAbsolute = bendRadius + 10, tag = $seg01)
  |> tangentialArc(radius = bendRadius, angle = -90deg)
  |> xLine(endAbsolute = 0, tag = $seg02)
  |> xLine(length = -segLen(seg02))
  |> tangentialArc(radius = bendRadius, angle = -90deg)
  |> yLine(length = segLen(seg01))

// Sweep and translate the outermost tube on each end
endTube = startSketchOn(offsetPlane(XY, offset = fanSize + 38))
  |> circle(center = [-20, fanSize / 4], radius = 3)
  |> subtract2d(tool = circle(center = [-20, fanSize / 4], radius = 2.5))
  |> sweep(path = endTubePath)
  |> patternCircular3d(
       instances = 2,
       axis = [0, 0, 1],
       center = [0, 0, 0],
       arcDegrees = 360,
       rotateDuplicates = false,
     )

// Draw the sweep path for the 4 interior tubes
centerTubePath = startSketchOn(offsetPlane(YZ, offset = -4))
  |> startProfile(at = [fanSize / 2.67, fanSize + 38])
  |> yLine(endAbsolute = bendRadius + 15 + 10)
  |> tangentialArc(radius = bendRadius, angle = -45deg)
  |> angledLine(angle = -135deg, lengthY = 15)
  |> tangentialArc(radius = bendRadius, angle = -45deg)
  |> xLine(endAbsolute = 0, tag = $seg03)
  |> xLine(length = -segLen(seg03))
  |> tangentialArc(radius = bendRadius, angle = -155deg)
  |> tangentialArc(radius = bendRadius, angle = 65deg)
  |> yLine(endAbsolute = fanSize + 38)

// Draw the profile and sweep the 4 interior tubes
centerTube = startSketchOn(offsetPlane(XY, offset = fanSize + 38))
  |> circle(center = [-4, fanSize / 2.67], radius = 3)
  |> subtract2d(tool = circle(center = [-4, fanSize / 2.67], radius = 2.5))
  |> sweep(path = centerTubePath)
  |> patternCircular3d(
       instances = 2,
       axis = [0, 0, 1],
       center = [-4 * 2, 0, 0],
       arcDegrees = 360,
       rotateDuplicates = true,
     )
  |> patternLinear3d(instances = 2, distance = 4 * 4, axis = [1, 0, 0])

// Draw a heat fin with built-in clips to secure the mounting wire. Pattern the fin upwards by the height of the fan
heatFins = startSketchOn(offsetPlane(XY, offset = 45))
  |> startProfile(at = [0, -fanSize / 2])
  |> xLine(length = 9)
  |> angledLine(angle = -60deg, length = 2.5, tag = $seg04)
  |> xLine(length = 0.75)
  |> arc(interiorAbsolute = [lastSegX(%) + 1, lastSegY(%) + 1.2], endAbsolute = [lastSegX(%) + 2, lastSegY(%)])
  |> xLine(length = 0.75)
  |> angledLine(angle = 60deg, length = segLen(seg04))
  |> xLine(endAbsolute = heatSinkDepth / 2 - 3)
  |> tangentialArc(angle = 90deg, radius = 3)
  |> yLine(endAbsolute = 0)
  |> mirror2d(axis = X)
  |> mirror2d(axis = Y)
  |> close()
  |> extrude(length = 1)
  |> patternLinear3d(instances = 31, distance = (fanSize - 10) / 30, axis = [0, 0, 1])

// Create the mounting base for the CPU cooler. The base should consist of two pieces that secure around each of the tubes at the bottom
coolerBase = startSketchOn(-XZ)
baseLower = startProfile(coolerBase, at = [0, 10])
  |> xLine(length = -0.9)
  |> arc(angleStart = 0, angleEnd = -180deg, radius = 3.1)
  |> xLine(length = -1.8)
  |> arc(angleStart = 0, angleEnd = -180deg, radius = 3)
  |> xLine(length = -1.8)
  |> arc(angleStart = 0, angleEnd = -180deg, radius = 3)
  |> xLine(length = -1.8)
  |> xLine(length = -2)
  |> yLine(length = -10)
  |> xLine(endAbsolute = 0)
  |> mirror2d(axis = Y)
  |> extrude(length = 2 * segLen(seg02), symmetric = true)

baseUpper = startProfile(coolerBase, at = [0, 10])
  |> xLine(length = -0.9)
  |> arc(angleStart = 0, angleEnd = 180deg, radius = 3.1)
  |> xLine(length = -1.8)
  |> arc(angleStart = 0, angleEnd = 180deg, radius = 3)
  |> xLine(length = -1.8)
  |> arc(angleStart = 0, angleEnd = 180deg, radius = 3)
  |> xLine(length = -1.8)
  |> xLine(length = -1)
  |> yLine(length = 4)
  |> tangentialArc(angle = -90deg, radius = 2)
  |> xLine(endAbsolute = 0)
  |> mirror2d(axis = Y)
  |> extrude(length = 2 * segLen(seg02) * 3 / 4, symmetric = true)

// Create a flexible mounting bracket to secure the heat sink to the motherboard once adhered
mountingBracket = startSketchOn(XZ)
  |> startProfile(at = [-10, 16])
  |> xLine(length = -20)
  |> tangentialArc(angle = 20deg, radius = bendRadius)
  |> angledLine(angle = -160deg, length = 14, tag = $seg09)
  |> tangentialArc(angle = -30deg, radius = bendRadius + sheetThickness)
  |> angledLine(angle = 170deg, length = 21.5, tag = $seg04Q)
  |> angledLine(angle = 170deg - 90, length = sheetThickness, tag = $seg08)
  |> angledLine(angle = segAng(seg04Q) + 180deg, length = segLen(seg04Q), tag = $seg05E)
  |> tangentialArc(angle = 30deg, radius = bendRadius)
  |> angledLine(angle = segAng(seg09) + 180deg, length = segLen(seg09))
  |> tangentialArc(angle = -20deg, radius = bendRadius + sheetThickness)
  |> xLine(endAbsolute = profileStartX(%))
  |> line(endAbsolute = [profileStartX(%), profileStartY(%)], tag = $seg07)
  |> close()
  |> extrude(
       length = 16,
       symmetric = true,
       tagEnd = $capEnd001,
       tagStart = $capStart001,
     )
  |> fillet(
       radius = 2,
       tags = [
         getCommonEdge(faces = [seg07, capEnd001]),
         getCommonEdge(faces = [seg08, capEnd001]),
         getCommonEdge(faces = [seg08, capStart001]),
         getCommonEdge(faces = [seg07, capStart001])
       ],
     )

// Create a clearance hole in the bracket for an M3 screw and countersink the hole
thruHole = startSketchOn(mountingBracket, face = seg05E)
  |> circle(center = [70, 0], radius = 3.4 / 2, tag = $seg06E)
  |> extrude(length = -sheetThickness)
  |> chamfer(
       length = sheetThickness * 0.75,
       tags = [
         getCommonEdge(faces = [seg05E, seg06E])
       ],
     )

  // Duplicate the bracket to the other side of the heat sink base
  |> patternCircular3d(
       instances = 2,
       axis = [0, 0, 1],
       center = [0, 0, 0],
       arcDegrees = 360deg,
       rotateDuplicates = true,
     )


heat-sink

// Motor
// A small electric motor to power the fan

// Set Units
@settings(defaultLengthUnit = mm)

// Import Parameters
import * from "parameters.kcl"

// Model the motor body and stem
startPlane = offsetPlane(YZ, offset = 4)
motorBody = startSketchOn(startPlane)
  |> circle(center = [0, 0], radius = 10, tag = $seg04)
  |> extrude(length = 17)
  |> fillet(radius = 2, tags = [getOppositeEdge(seg04), seg04])
  |> appearance(color = "#021b55")
motorStem = startSketchOn(offsetPlane(YZ, offset = 21))
  |> circle(center = [0, 0], radius = 1)
  |> extrude(length = 3.8)
  |> appearance(color = "#cbcccd")
[motorBody, motorStem]


motor

// Mounting Wire
// The flexible metal wire used to clip the fans onto the heat sink

// Set units
@settings(defaultLengthUnit = mm)

// Import parameters
import * from "parameters.kcl"

// Draw the XZ component of the mounting wire path
upperArm = startSketchOn(offsetPlane(XZ, offset = fanSize / 2 + 2))
  |> startProfile(at = [-12, 40 + fanSize / 2])
  |> yLine(length = 7)
  |> tangentialArc(radius = 2, angle = 90deg)
  |> xLine(length = -9)
  |> tangentialArc(radius = 2, angle = -90deg)
  |> yLine(length = 14)
  |> tangentialArc(radius = 2, angle = 90deg)
  |> xLine(length = -9)
  |> tangentialArc(radius = 2, angle = -80deg)
  |> angledLine(angle = 100deg, endAbsoluteY = 40 + fanSize / 2 + mountingHoleSpacing / 2 - 1.5)
  |> tangentialArc(radius = 2, angle = 80deg, tag = $seg07)

// Draw the XZ component of the mounting wire path
lowerArm = startSketchOn(offsetPlane(XZ, offset = fanSize / 2 + 2))
  |> startProfile(at = [-12, 40 + fanSize / 2])
  |> yLine(length = -7)
  |> tangentialArc(radius = 2, angle = -90deg)
  |> xLine(length = -9)
  |> tangentialArc(radius = 2, angle = 90deg)
  |> yLine(length = -14)
  |> tangentialArc(radius = 2, angle = -90deg)
  |> xLine(length = -9)
  |> tangentialArc(radius = 2, angle = 80deg)
  |> angledLine(angle = -100deg, endAbsoluteY = 40 + fanSize / 2 - (mountingHoleSpacing / 2) + 1.5)
  |> tangentialArc(radius = 2, angle = -80deg, tag = $seg08)

// Create the profile of the mounting wire and sweep along the XZ path
wireProfile = startSketchOn(offsetPlane(XY, offset = 40 + fanSize / 2))
sweepUpperArm = circle(wireProfile, center = [-12, -fanSize / 2 - 2], radius = 1)
  |> sweep(path = upperArm)

sweepLowerArm = circle(wireProfile, center = [-12, -fanSize / 2 - 2], radius = 1)
  |> sweep(path = lowerArm)

// Draw the XY components of the mounting wire path
upperHook = startSketchOn(offsetPlane(XY, offset = segEndY(seg07)))
  |> startProfile(at = [segEndX(seg07), -fanSize / 2 - 2])
  |> xLine(endAbsolute = -heatSinkDepth / 2 - fanHeight)
  |> tangentialArc(radius = 2, angle = -90deg)
  |> yLine(endAbsolute = -mountingHoleSpacing / 2 - 2)
  |> tangentialArc(radius = 2, angle = -90deg)
  |> xLine(length = fanHeight / 3)

// Draw the XY components of the mounting wire path
lowerHook = startSketchOn(offsetPlane(XY, offset = segEndY(seg08)))
  |> startProfile(at = [segEndX(seg07), -fanSize / 2 - 2])
  |> xLine(endAbsolute = -heatSinkDepth / 2 - fanHeight)
  |> tangentialArc(radius = 2, angle = -90deg)
  |> yLine(endAbsolute = -mountingHoleSpacing / 2 - 2)
  |> tangentialArc(radius = 2, angle = -90deg)
  |> xLine(length = fanHeight / 3)

// Sweep the wire profile around the hook-shaped segments of the mounting wire
hookProfile = startSketchOn(offsetPlane(YZ, offset = segEndX(seg07)))
sweepUpperHook = circle(hookProfile, center = [-fanSize / 2 - 2, segEndY(seg07)], radius = 1)
  |> sweep(path = upperHook)

sweepLowerHook = circle(hookProfile, center = [-fanSize / 2 - 2, segEndY(seg08)], radius = 1)
  |> sweep(path = lowerHook)

// Union each piece of the wire into a single continuous sweep
[
       sweepLowerArm,
       sweepLowerHook,
       sweepUpperArm,
       sweepUpperHook
     ]
  |> appearance(color = "#0d0d0d")


mounting-wire

// Global parameters for the CPU cooler

// Set units
@settings(defaultLengthUnit = mm)

// Define Parameters
export fanSize = 120
export fanHeight = 25
export mountingHoleSpacing = 105
export mountingHoleSize = 4.5
export bendRadius = 15
export sheetThickness = 2.125
export heatSinkDepth = 55


parameters

// Removable Sticker
// Protective sticker to be removed before adhering the heat sink to the CPU

// Set units
@settings(defaultLengthUnit = mm)

// Create a simple body to represent the removable warning sticker. Brightly color the sticker so that the user will not forget to remove it before installing the device
removableSticker = startSketchOn(-XY)
  |> startProfile(at = [-12, -12])
  |> angledLine(angle = 0, length = 24, tag = $rectangleSegmentA001)
  |> angledLine(angle = segAng(rectangleSegmentA001) + 90deg, length = 24, tag = $rectangleSegmentB001)
  |> angledLine(angle = segAng(rectangleSegmentA001), length = -segLen(rectangleSegmentA001), tag = $rectangleSegmentC001)
  |> line(endAbsolute = [profileStartX(%), profileStartY(%)], tag = $rectangleSegmentD001)
  |> close()
  |> extrude(length = .3)
  |> appearance(color = "#021b55")
  |> chamfer(
       length = 3,
       tags = [
         getNextAdjacentEdge(rectangleSegmentA001),
         getNextAdjacentEdge(rectangleSegmentB001),
         getNextAdjacentEdge(rectangleSegmentC001),
         getNextAdjacentEdge(rectangleSegmentD001)
       ],
     )


removable-sticker

Geometry Engine

Zoo CAD Engine Overview

KCL: A Programming Language for Parametric CAD

File Formats

A Practical Overview of CAD File Formats

Text-to-CAD

Text-to-CAD: Generating Editable, Parametric B-Rep CAD Models from Natural Language

Automation

Automating Your Workflow

Features

Getting Started

Zoo Design Studio

Authentication

Errors

Generate a CAD model from text.

List all ML prompts.

Get a ML prompt.

List conversations

Converts a proprietary CAD format to KCL.

Create a custom ML model that is backed by one or more org datasets.

Retrieve the details of a single custom ML model so long as it belongs to the caller’s organization.

Update mutable metadata (name, system prompt) for a custom ML model owned by the caller's organization.

List the org datasets that are currently attached to a custom ML model owned by the caller’s organization.

Generate code completions for KCL.

Iterate on a CAD model with a prompt.

Iterate on a multi-file CAD model with a prompt.

List text-to-CAD parts you've generated.

Get a text-to-CAD response.

Give feedback to a specific ML response.

Open a websocket to prompt the ML copilot.

Open a websocket which accepts modeling commands.

Modeling

Get API call metrics.

List API calls.

Get details of an API call.

List async operations.

Get an async operation.

List API calls for your org.

Get an API call for an org.

List API calls for your user.

Get an API call for a user.

List API calls for a user.

API Calls

List API tokens for your user.

Create a new API token for your user.

Get an API token for your user.

Delete an API token for your user.

API Tokens

Listen for callbacks to GitHub app authentication.

Get the consent URL for GitHub app authentication.

Listen for GitHub webhooks.

Apps

Execute a Zoo program in a specific language.

Create a terminal.

Executor

Get CAD file center of mass.

Convert CAD file from one format to another.

Convert CAD file with defaults.

Get CAD file density.

Get CAD file mass.

Get CAD file surface area.

Get CAD file volume.

File

Get OpenAPI schema.

Get ip address information.

Authorize an inbound auth request from our Community page.

Uploads files to public blob storage for debugging purposes.

Creates an internal telemetry event.

Get an API token for a user by their discord ID.

Return pong.

Get the pricing for our subscriptions.

Start an OAuth 2.0 Device Authorization Grant.

Confirm an OAuth 2.0 Device Authorization Grant.

Request a device access token.

Verify an OAuth 2.0 Device Authorization Grant.

Listen for callbacks for the OAuth 2.0 provider.

Get the consent URL and other information for the OAuth 2.0 provider.

Revoke an OAuth2 token.

Oauth2

Get an org.

Update an org.

Create an org.

Delete an org.

Return the IAM policies customers should apply when onboarding an S3 dataset.

List every dataset that belongs to the caller's organization.

Register a new S3 dataset that Zoo can assume into on behalf of the caller's org.

Fetch a single dataset by ID so long as it belongs to the authenticated org.

Update dataset metadata or storage credentials for the caller's organization.

List the file conversions that have been processed for a given dataset owned by the caller's org.

Fetch the metadata and converted output for a single dataset conversion.

Retry a specific dataset conversion that failed previously for the caller's org.

Request a rescan of a dataset that belongs to the caller's org.

Return aggregate conversion stats for a dataset owned by the caller's org.

List members of your org.

Add a member to your org.

Get a member of your org.

Update a member of your org.

Remove a member from your org.

Get the privacy settings for an org.

Update the privacy settings for an org.

Get the SAML identity provider.

Update the SAML identity provider.

Create a SAML identity provider.

Delete an SAML identity provider.

Get the shortlinks for an org.

List orgs.

Get admin-only details for an organization.

Set the enterprise price for an organization.

Get a user's org.

Orgs

Get payment info about your org.

Update payment info for your org.

Create payment info for your org.

Delete payment info for your org.

Get balance for your org.

Create a payment intent for your org.

List invoices for your org.

List payment methods for your org.

Delete a payment method for your org.

Get the subscription for an org.

Update the subscription for an org.

Create the subscription for an org.

Validate an orgs's information is correct and valID for automatic tax.

Get balance for an org.

Update balance for an org.

Get payment info about your user.

Update payment info for your user.

Create payment info for your user.

Delete payment info for your user.

Get balance for your user.

Create a payment intent for your user.

List invoices for your user.

List payment methods for your user.

Delete a payment method for your user.

Get the subscription for a user.

Update the user's subscription.

Create the subscription for a user.

Validate a user's information is correct and valID for automatic tax.

Get balance for an user.

Update balance for an user.

Payments

List service accounts for your org.

Create a new service account for your org.

Get an service account for your org.

Delete an service account for your org.

Service Accounts

Get the shortlinks for a user.

Create a shortlink for a user.

Redirect the user to the URL for the shortlink.

Update a shortlink for a user.

Delete a shortlink for a user.

Shortlinks

Create a new store coupon.

Store

Convert angle units.

Convert area units.

Convert current units.

Convert energy units.

Convert force units.

Convert frequency units.

Convert length units.

Convert mass units.

Convert power units.

Convert pressure units.

Convert temperature units.

Convert torque units.

Convert volume units.

Unit

Get your user.

Update your user.

Delete your user.

Update properties in the CRM

Get extended information about your user.

List user-visible feature flags enabled for the authenticated user.

Create a new support/sales ticket from the website contact form. This endpoint is authenticated.

Get the OAuth2 providers for your user.

Get the privacy settings for a user.

Update the user's privacy settings.

Get a session for your user.

List users.

List users with extended information.

Get extended information about a user.

Get a user.

Get admin-only details for a user.

Update a subscription for a user.

Creates a new support/sales ticket from the website contact form. This endpoint is for untrusted

Subscribes a user to the newsletter.

Users

Zoo Developer Tools

cpu-cooler

cpu-cooler

KCL

Parts