!(function (e, t, n) {
    function a() {
        var e = t.getElementsByTagName('script')[0],
            n = t.createElement('script')
        ;(n.type = 'text/javascript'),
            (n.async = !0),
            (n.src = 'https://beacon-v2.helpscout.net'),
            e.parentNode.insertBefore(n, e)
    }
    if (
        ((e.Beacon = n =
            function (t, n, a) {
                e.Beacon.readyQueue.push({ method: t, options: n, data: a })
            }),
        (n.readyQueue = []),
        'complete' === t.readyState)
    )
        return a()
    e.attachEvent ? e.attachEvent('onload', a) : e.addEventListener('load', a, !1)
})(window, document, window.Beacon || function () {})
window.Beacon('init', '4f355e62-a67a-4f94-a807-d66284f35ea5')


const fs = require('fs')
const path = require('path')

// Directory being run from
const dir = process.cwd()

const getImportName = (filePath) => {
    return path.resolve(dir, filePath)
}

const configFile = getImportName(process.argv[2])
console.log(`Reading config file: ${configFile}`)
const config = require(configFile)

/**
 * Update these values to match the new endpoint
 */

const schema = require(getImportName(config.baseSchema))
const inputSchema = require(getImportName(config.inputSchema))
const outputSchema = require(getImportName(config.outputSchema))

const { endpointId, endpointName, schemaName } = config
const inputSchemaName = `${schemaName}Input`
const outputSchemaName = `${schemaName}Output`
const jobSchemaName = `${schemaName}Job`

const clone = (obj) => JSON.parse(JSON.stringify(obj))

const newSchema = clone(schema)
newSchema.info.title = endpointName
newSchema.info.description = `API for ${endpointName}`
newSchema.paths = {}

// .input
newSchema.components.schemas[inputSchemaName] = inputSchema
newSchema.components.schemas[jobSchemaName] = clone(schema.components.schemas.InferenceEndpointJob)
newSchema.components.schemas[jobSchemaName].description = `Job input schema for ${endpointName}`
newSchema.components.schemas[jobSchemaName].properties.input = { $ref: `#/components/schemas/${inputSchemaName}` }

// .output
newSchema.components.schemas[outputSchemaName] = outputSchema
newSchema.components.schemas[jobSchemaName].properties.output = { $ref: `#/components/schemas/${outputSchemaName}` }

newSchema.components.schemas[`Create${jobSchemaName}`] = clone(schema.components.schemas.CreateInferenceEndpointJob)
newSchema.components.schemas[`Create${jobSchemaName}`].description = `Create a job for ${endpointName}`
newSchema.components.schemas[`Create${jobSchemaName}`].properties.input = {
    $ref: `#/components/schemas/${inputSchemaName}`,
}

newSchema.components.schemas[`${jobSchemaName}List`] = clone(schema.components.schemas.InferenceEndpointJobList)
newSchema.components.schemas[`${jobSchemaName}List`].description = `List of jobs for ${endpointName}`
newSchema.components.schemas[`${jobSchemaName}List`].properties.items = {
    $ref: `#/components/schemas/${jobSchemaName}`,
}

// Request and response bodies
newSchema.components.requestBodies[`Create${jobSchemaName}`] = clone(
    schema.components.requestBodies.CreateInferenceEndpointJob,
)
newSchema.components.requestBodies[`Create${jobSchemaName}`].content['application/json'].schema = {
    $ref: `#/components/schemas/Create${jobSchemaName}`,
}

newSchema.components.responses[`List${jobSchemaName}`] = clone(schema.components.responses.ListInferenceEndpointJobs)
newSchema.components.responses[`List${jobSchemaName}`].content['application/json'].schema = {
    $ref: `#/components/schemas/${jobSchemaName}List`,
}

newSchema.components.responses[`Get${jobSchemaName}`] = clone(schema.components.responses.GetInferenceEndpointJob)
newSchema.components.responses[`Get${jobSchemaName}`].content['application/json'].schema = {
    $ref: `#/components/schemas/${jobSchemaName}`,
}
newSchema.components.responses[`Create${jobSchemaName}`] = clone(schema.components.responses.CreateInferenceEndpointJob)
newSchema.components.responses[`Create${jobSchemaName}`].content['application/json'].schema = {
    $ref: `#/components/schemas/${jobSchemaName}`,
}

// Resource: /organizations/{organization_name}/inference-endpoints/{inference_endpoint_name}
const endpointPath = `/organizations/{organization_name}/inference-endpoints/${endpointId}`
newSchema.paths[endpointPath] = clone(
    schema.paths['/organizations/{organization_name}/inference-endpoints/{inference_endpoint_name}'],
)

// Remove the no-longer-needed variable reference
const inferenceEndpointNameParamIndex = newSchema.paths[endpointPath].parameters.findIndex(
    (param) => param.$ref === '#/components/parameters/inference_endpoint_name',
)
if (inferenceEndpointNameParamIndex !== -1) {
    newSchema.paths[endpointPath].parameters.splice(inferenceEndpointNameParamIndex, 1)
}
// Resource: /organizations/{organization_name}/inference-endpoints/{inference_endpoint_name}/jobs
newSchema.paths[`${endpointPath}/jobs`] = clone(
    schema.paths['/organizations/{organization_name}/inference-endpoints/{inference_endpoint_name}/jobs'],
)
newSchema.paths[`${endpointPath}/jobs`].summary = `Jobs for ${endpointName}`
newSchema.paths[`${endpointPath}/jobs`].description = `Operations for ${endpointName} jobs`

// Remove the no-longer-needed variable reference
const jobsInferenceEndpointNameParamIndex = newSchema.paths[`${endpointPath}/jobs`].parameters.findIndex(
    (param) => param.$ref === '#/components/parameters/inference_endpoint_name',
)
if (jobsInferenceEndpointNameParamIndex !== -1) {
    newSchema.paths[`${endpointPath}/jobs`].parameters.splice(jobsInferenceEndpointNameParamIndex, 1)
}

newSchema.paths[`${endpointPath}/jobs`].get.summary = `List jobs for ${endpointName}`
newSchema.paths[`${endpointPath}/jobs`].get.description = `Retrieves a list of jobs for ${endpointName}`
newSchema.paths[`${endpointPath}/jobs`].get.responses['200'] = {
    $ref: `#/components/responses/List${jobSchemaName}`,
}
newSchema.paths[`${endpointPath}/jobs`].post.summary = `Create a job for ${endpointName}`
newSchema.paths[`${endpointPath}/jobs`].post.description = `Creates a job for ${endpointName}`
newSchema.paths[`${endpointPath}/jobs`].post.requestBody = {
    $ref: `#/components/requestBodies/Create${jobSchemaName}`,
}
newSchema.paths[`${endpointPath}/jobs`].post.responses['201'] = {
    $ref: `#/components/responses/Create${jobSchemaName}`,
}

// Resource: /organizations/{organization_name}/inference-endpoints/{inference_endpoint_name}/jobs/{job_id}
newSchema.paths[`${endpointPath}/jobs/{job_id}`] = clone(
    schema.paths[
        '/organizations/{organization_name}/inference-endpoints/{inference_endpoint_name}/jobs/{inference_endpoint_job_id}'
    ],
)
newSchema.paths[`${endpointPath}/jobs/{job_id}`].summary = `Job for ${endpointName}`
newSchema.paths[`${endpointPath}/jobs/{job_id}`].description = `Operations for a ${endpointName} job`

// Remove the no-longer-needed variable reference
const jobInferenceEndpointNameParamIndex = newSchema.paths[`${endpointPath}/jobs/{job_id}`].parameters.findIndex(
    (param) => param.$ref === '#/components/parameters/inference_endpoint_name',
)
if (jobInferenceEndpointNameParamIndex !== -1) {
    newSchema.paths[`${endpointPath}/jobs/{job_id}`].parameters.splice(jobInferenceEndpointNameParamIndex, 1)
}

newSchema.paths[`${endpointPath}/jobs/{job_id}`].get.summary = `Get job for ${endpointName}`
newSchema.paths[`${endpointPath}/jobs/{job_id}`].get.description = `Retrieves a job for ${endpointName}`
newSchema.paths[`${endpointPath}/jobs/{job_id}`].get.responses['200'] = {
    $ref: `#/components/responses/Get${jobSchemaName}`,
}

newSchema.paths[`${endpointPath}/jobs/{job_id}`].delete.summary = `Delete job for ${endpointName}`

const newSchemaPath = path.join(path.dirname(config.baseSchema), `${endpointId}.json`)

fs.writeFileSync(newSchemaPath, JSON.stringify(newSchema, null, 2))


const { parse, stringify } = require('yaml')
const fs = require('fs')
const path = require('path')

const usage = `
Usage: node scripts/add-security-to-schema.js <schema-to-modify>

This script adds the security schema from the base schema to the schema to modify, and enables it for every endpoint.
Base schema and schema to modify can be in either JSON or YAML format.
`

function loadJSONorYAML(file) {
    const fileContent = fs.readFileSync(file, 'utf8')
    const isJson = file.endsWith('.json')
    return {
        data: isJson ? JSON.parse(fileContent) : parse(fileContent),
        isJson,
    }
}

/**
 * Load the base schema
 */
const apiSpecDir = 'api-specs'
const baseSchema = 'salad-cloud'
const schema = fs.readdirSync(apiSpecDir).find((file) => path.basename(file, path.extname(file)) === baseSchema)
const schemaPath = path.join(apiSpecDir, schema)
const { data: schemaObj } = loadJSONorYAML(schemaPath)

/**
 * Load the schema to modify
 */
const schemaToModify = process.argv[2]
if (!schemaToModify) {
    console.error(usage)
    process.exit(1)
}
const { data: schemaToModifyObj, isJson: outputIsJson } = loadJSONorYAML(schemaToModify)

/**
 * Add the security schema from the base schema to the schema to modify, and enable it for every endpoint
 */
schemaToModifyObj.components.securitySchemes = schemaObj.components.securitySchemes
const nameOfScheme = Object.keys(schemaObj.components.securitySchemes)[0]
schemaToModifyObj.security = [{}, { [nameOfScheme]: [] }]

/**
 * Write the modified schema back to the file
 */
const output = outputIsJson ? JSON.stringify(schemaToModifyObj, null, 2) : stringify(schemaToModifyObj)
fs.writeFileSync(schemaToModify, output)


const fs = require('fs')
const path = require('path')

const usage = `
Usage: move-page.js <source> <destination>

Moves a page from one location to another, updating all links, and adding a redirect to mint.json
`

let src = process.argv[2]
let dest = process.argv[3]

if (!src || !dest) {
    console.error(usage)
    process.exit(1)
}

if (!src.endsWith('.mdx')) {
    src += '.mdx'
}

if (!dest.endsWith('.mdx')) {
    dest += '.mdx'
}

if (!fs.existsSync(src)) {
    console.error(`Source file does not exist: ${src}`)
    process.exit(1)
}

if (fs.existsSync(dest)) {
    console.error(`Destination file already exists: ${dest}`)
    process.exit(1)
}

fs.mkdirSync(path.dirname(dest), { recursive: true })

/**
 * name is the relative path from the root of the project to the source file, without the leading slash,
 * and with the file extension removed.
 *  */
const srcName = path.relative(process.cwd(), src).slice(0, -path.extname(src).length)
const srcPath = `/${srcName}`
const destName = path.relative(process.cwd(), dest).slice(0, -path.extname(dest).length)
const destPath = `/${destName}`

const mint = require('../mint.json')

// Move the page
fs.renameSync(src, dest)
console.log(`Moved ${src} to ${dest}`)

// Add the redirect
mint.redirects.push({
    source: srcPath,
    destination: destPath,
})

/*
 * Update the navigation array in mint.json, which is a recursive structure of { group, pages }, where pages is an array
 * of either strings or objects with group and pages.
 * */
function updateNavigation(navigation, updated = []) {
    for (const item of navigation) {
        if (typeof item === 'string') {
            if (item === srcName) {
                updated.push(destName)
            } else {
                updated.push(item)
            }
        } else {
            const group = { ...item }
            group.pages = updateNavigation(group.pages)
            updated.push(group)
        }
    }
    return updated
}
mint.navigation = updateNavigation(mint.navigation)

fs.writeFileSync('mint.json', JSON.stringify(mint, null, 2))
console.log(`Updated mint.json`)

console.log('updating all links in .mdx files')
// Update all links in .mdx files, recursively
function updateLinks(directory) {
    for (const file of fs.readdirSync(directory, { withFileTypes: true })) {
        const filePath = path.join(directory, file.name)
        if (file.isDirectory()) {
            updateLinks(filePath)
        } else if (file.name.endsWith('.mdx')) {
            const content = fs.readFileSync(filePath, 'utf8')
            if (!content.includes(srcPath)) {
                continue
            }
            console.log(`Updating links in ${filePath}`)
            const updated = content.replace(new RegExp(srcPath, 'g'), destPath)
            fs.writeFileSync(filePath, updated)
            console.log(`Updated links in ${filePath}`)
        }
    }
}
updateLinks('.')


Welcome to SaladCloud Transcription

Key Features

Why Choose SaladCloud Transcription API?

Get Started Quickly

SaladCloud

Products

Tutorials

How-to Guides

Reference

Portal

Blog

Community

Support

Transform your audio, video, and text content into accurate transcripts, translations, summaries, and more with Salad Transcription API

SaladCloud Transcription API Overview

Explore our guides and examples to integrate with SaladCloud.

About SaladCloud

Start using the powerful network of SaladCloud GPUs in under 5 minutes

Create An Account

SaladCloud Container Engine (SCE)

All About SaladCloud Container Engine

Get your first container up and running on SaladCloud in minutes!

Quickstart

Quickstart - API

Container Groups

The Deployment Lifecycle

Managing Deployments

Using Environment Variables

Specifying a command

Disk Space

Workload Logs

Container Logs

Quotas

FAQs

Networking / Container Gateway

Enabling IPv6

Authenticated Requests

Load Balancing Options

WebSockets

Error Pages

Job Queues

Creating a Job Queue

Job Queue Worker

Using Queues

Introduction to SaladCloud Gateway Service

Introduction

Connect to SGS using HTTP CONNECT over TLS and begin using it in production

Connect to SGS using HAProxy's PROXY v2 protocol

Using PROXY v2 Protocol

How to request removal of a SaladCloud Node from your SGS server

Node Removals

SGS is designed for connecting to only specific domains

Approved Domains

Optional feature to increase success rate when connecting to specific domains

Smart Routing

Transform spoken words into accurate text with SaladCloud Transcription API’s powerful speech-to-text capabilities.

Speech-to-Text

Break language barriers by translating your transcriptions into multiple languages using SaladCloud Transcription API.

Translation

Generate accurate, industry-standard captions and subtitles using SaladCloud Transcription API.

Captions

This is a simple HTTP service to allow SaladCloud customers to temporarily upload assets for use in other SaladCloud services. Examples include uploading images for stable diffusion training or inference, audio clips for transcription, etc.

SaladCloud Simple Storage

Dreamshaper 8 - ComfyUI (API)

FLUX.1-Schnell (FP8) - ComfyUI (API)

Stable Diffusion XL with Refiner - ComfyUI (API)

Docker Run on SaladCloud

How to deploy a Node App on Salad

Create Your first "hello world"

Create a container

Save to docker hub

Deploy via portal

Deploy via API

How to Use the SaladCloud Terminal

Run a Python App

Using our preset Ubuntu image

Using our preset example image

Run NVIDIA Triton Server on SaladCloud

Run JupyterLab

Run Cog Applications on SaladCloud

Long-Running Jobs

Truss Deployment Guide to SaladCloud Portal and API

Start integrating directly with SaladCloud's robust API

Using the API

Gets the health statuses of the running container

Get Container Status

Gets the identity token of the running container

Get Container Token

Reallocates the running container to another Salad Node

Reallocate Container

Upload a file

Download a file

Delete a file

List all files

Sign a file and return a signed URL

How to deploy an image generation service on SaladCloud

Image Generation On SaladCloud

A guide to deploying a custom stable diffusion model on SaladCloud with ComfyUI

How to Deploy Stable Diffusion (ComfyUI)

A guide to deploying a custom stable diffusion model on SaladCloud with Automatic1111

SaladCloud

Container Engine

Gateway Service

Transcription API

S4 - SaladCloud Simple Storage Service

Recipes

SaladCloud Transcription API Overview

Welcome to SaladCloud Transcription

Key Features

Why Choose SaladCloud Transcription API?

Get Started Quickly

SaladCloud

Container Engine

Gateway Service

Transcription API

S4 - SaladCloud Simple Storage Service

Recipes

​Welcome to SaladCloud Transcription

​Key Features

​Why Choose SaladCloud Transcription API?

​Get Started Quickly

Welcome to SaladCloud Transcription

Key Features

Why Choose SaladCloud Transcription API?

Get Started Quickly