Class PolygonSDK

Comprehensive SDK for Codeforces Polygon API. Provides type-safe methods for all Polygon operations including problem management, statements, tests, solutions, checkers, validators, and package building.

Features:

Automatic authentication with SHA-512 signature generation
Full TypeScript type safety
Support for all Polygon API endpoints (54+ methods)
PIN code support for protected problems
File upload/download with Buffer support
Comprehensive error handling

PolygonSDK

Example

// Initialize SDK
const sdk = new PolygonSDK({
  apiKey: process.env.POLYGON_API_KEY!,
  apiSecret: process.env.POLYGON_API_SECRET!
});

Example

// List and filter problems
const myProblems = await sdk.listProblems({ owner: 'username' });

Example

// Create and configure a problem
const problem = await sdk.createProblem('A+B Problem');
await sdk.updateWorkingCopy(problem.id);
await sdk.updateProblemInfo(problem.id, {
  timeLimit: 2000,
  memoryLimit: 256
});
await sdk.commitChanges(problem.id, { message: 'Initial setup' });

Example

// Upload files and solutions
import fs from 'fs';
const code = fs.readFileSync('main.cpp', 'utf-8');
await sdk.saveSolution(problem.id, 'main.cpp', code, 'MA');

Constructors

constructor

new PolygonSDK(config: PolygonConfig): PolygonSDK
Creates a new Polygon SDK instance.
Parameters
- config: PolygonConfig
  SDK configuration with API credentials
Returns PolygonSDK
Throws
If credentials are invalid or missing
Example
```
const sdk = new PolygonSDK({
  apiKey: 'your-api-key',
  apiSecret: 'your-api-secret'
});
```
- Defined in polygon.ts:148

Properties

`Private` `Internal`apiKey

apiKey: string

`Private` `Internal`apiSecret

apiSecret: string

`Private` `Internal`baseUrl

baseUrl: string

Methods

`Private`generateSignature

generateSignature(
methodName: string,
params: Record<string, string | number | boolean>,
): string
Internal
Generates cryptographic signature for API request authentication. Implements Polygon's SHA-512 based signature scheme with random salt.
Parameters
- methodName: string
  API method name (e.g., 'problems.list')
- params: Record<string, string | number | boolean>
  Request parameters
Returns string
Signature string (6-char random prefix + SHA-512 hash)
- Defined in polygon.ts:164

`Private`request

request<T>(
    methodName: string,
    params?: Record<string, string | number | boolean>,
    returnRaw?: boolean,
): Promise<T>
Internal
Executes an authenticated API request to Polygon. Handles parameter encoding, signature generation, and response parsing.
Type Parameters
- T
  Expected response type
Parameters
- methodName: string
  API method to call
- params: Record<string, string | number | boolean> = {}
  Request parameters
- returnRaw: boolean = false
  If true, return raw text instead of parsed JSON
Returns Promise<T>
Parsed response data

Throws
If API returns FAILED status or network error occurs
- Defined in polygon.ts:206

listProblems

listProblems(
    options?: {
        showDeleted?: boolean;
        id?: number;
        name?: string;
        owner?: string;
    },
): Promise<Problem[]>
Retrieves list of problems accessible to the authenticated user. Can filter by various criteria including owner, name, and deletion status.
Parameters
- Optionaloptions: { showDeleted?: boolean; id?: number; name?: string; owner?: string }
  Optional filter parameters
  - OptionalshowDeleted?: boolean
    Include deleted problems (default: false)
  - Optionalid?: number
    Filter by specific problem ID
  - Optionalname?: string
    Filter by problem name
  - Optionalowner?: string
    Filter by owner username
Returns Promise<Problem[]>
Array of problems matching filters
Example
```
// List all accessible problems
const allProblems = await sdk.listProblems();
```
Example
```
// List only your own problems
const myProblems = await sdk.listProblems({ owner: 'username' });
```
Example
```
// Include deleted problems
const withDeleted = await sdk.listProblems({ showDeleted: true });
```
- Defined in polygon.ts:275

createProblem

createProblem(name: string): Promise<Problem>
Creates a new empty problem with given name. After creation, you must call updateWorkingCopy to start editing.
Parameters
- name: string
  Name/title for the new problem
Returns Promise<Problem>
Newly created problem object with ID
Throws
If problem creation fails
Example
```
const problem = await sdk.createProblem('A+B Problem');
console.log('Created problem ID:', problem.id);
await sdk.updateWorkingCopy(problem.id);
```
- Defined in polygon.ts:297

getProblemInfo

getProblemInfo(problemId: number, pin?: string): Promise<ProblemInfo>
Retrieves problem configuration including I/O files, limits, and interactive flag.
Parameters
- problemId: number
  Problem identifier
- Optionalpin: string
  Optional PIN code for protected problems
Returns Promise<ProblemInfo>
Problem configuration details
Example
```
const info = await sdk.getProblemInfo(12345);
console.log(`Time: ${info.timeLimit}ms, Memory: ${info.memoryLimit}MB`);
```
- Defined in polygon.ts:314

updateProblemInfo

updateProblemInfo(
    problemId: number,
    info: Partial<ProblemInfo>,
    pin?: string,
): Promise<void>
Updates problem configuration settings. Only specified fields will be updated; others remain unchanged.
Parameters
- problemId: number
  Problem identifier
- info: Partial<ProblemInfo>
  Fields to update
- Optionalpin: string
  Optional PIN code
Returns Promise<void>
Example
```
// Update only time and memory limits
await sdk.updateProblemInfo(12345, {
  timeLimit: 2000,
  memoryLimit: 256
});
```
Example
```
// Mark as interactive problem
await sdk.updateProblemInfo(12345, { interactive: true });
```
- Defined in polygon.ts:340

updateWorkingCopy

updateWorkingCopy(problemId: number, pin?: string): Promise<void>
Updates working copy to latest committed version. Required before making changes to a problem.
Parameters
- problemId: number
  Problem identifier
- Optionalpin: string
  Optional PIN code
Returns Promise<void>
Example
```
await sdk.updateWorkingCopy(12345);
// Now you can modify the problem
```
- Defined in polygon.ts:365

discardWorkingCopy

discardWorkingCopy(problemId: number, pin?: string): Promise<void>
Discards all uncommitted changes in working copy. Reverts to last committed version.
Parameters
- problemId: number
  Problem identifier
- Optionalpin: string
  Optional PIN code
Returns Promise<void>
Example
```
// Discard changes if something went wrong
await sdk.discardWorkingCopy(12345);
```
- Defined in polygon.ts:383

commitChanges

commitChanges(
    problemId: number,
    options?: { minorChanges?: boolean; message?: string },
    pin?: string,
): Promise<void>
Commits changes from working copy, creating a new revision. Optionally sends email notification to watchers.
Parameters
- problemId: number
  Problem identifier
- Optionaloptions: { minorChanges?: boolean; message?: string }
  Commit options
  - OptionalminorChanges?: boolean
    Don't send email if true
  - Optionalmessage?: string
    Commit message
- Optionalpin: string
  Optional PIN code
Returns Promise<void>
Example
```
// Commit with message
await sdk.commitChanges(12345, {
  message: 'Updated time limits and added test cases'
});
```
Example
```
// Minor commit without notification
await sdk.commitChanges(12345, {
  minorChanges: true,
  message: 'Fixed typo'
});
```
- Defined in polygon.ts:413

getStatements

getStatements(
problemId: number,
pin?: string,
): Promise<Record<string, Statement>>
Retrieves problem statements in all available languages.
Parameters
- problemId: number
  Problem identifier
- Optionalpin: string
  Optional PIN code
Returns Promise<Record<string, Statement>>
Map of language code to statement
Example
```
const statements = await sdk.getStatements(12345);
console.log('Available languages:', Object.keys(statements));
console.log('English legend:', statements['english'].legend);
```
- Defined in polygon.ts:440

saveStatement

saveStatement(
    problemId: number,
    lang: string,
    statement: Partial<Omit<Statement, "encoding">>,
    pin?: string,
): Promise<void>
Creates or updates problem statement for a specific language. Only provided fields will be updated; others remain unchanged.
Parameters
- problemId: number
  Problem identifier
- lang: string
  Language code (e.g., 'english', 'russian')
- statement: Partial<Omit<Statement, "encoding">>
  Statement sections to save
- Optionalpin: string
  Optional PIN code
Returns Promise<void>
Example
```
// Save English statement
await sdk.saveStatement(12345, 'english', {
  name: 'Sum of Two Numbers',
  legend: 'Calculate the sum of two integers a and b.',
  input: 'Two integers a and b (1 ≤ a, b ≤ 10^9)',
  output: 'Print a single integer — the sum of a and b.',
  notes: 'This is a straightforward addition problem.'
});
```
Example
```
// Update only the tutorial
await sdk.saveStatement(12345, 'english', {
  tutorial: 'Simply add the two numbers together.'
});
```
- Defined in polygon.ts:478

getStatementResources

getStatementResources(problemId: number, pin?: string): Promise<File[]>
Retrieves list of statement resource files (images, PDFs, etc.). Resources can be referenced in problem statements.
Parameters
- problemId: number
  Problem identifier
- Optionalpin: string
  Optional PIN code
Returns Promise<File[]>
Array of resource files
Example
```
const resources = await sdk.getStatementResources(12345);
resources.forEach(r => {
  console.log(`Resource: ${r.name} (${r.length} bytes)`);
});
```
- Defined in polygon.ts:507

saveStatementResource

saveStatementResource(
    problemId: number,
    name: string,
    file: string | Buffer<ArrayBufferLike>,
    checkExisting?: boolean,
    pin?: string,
): Promise<void>
Uploads or updates a statement resource file (e.g., image, diagram). Files are automatically converted to base64 if provided as Buffer.
Parameters
- problemId: number
  Problem identifier
- name: string
  Resource file name
- file: string | Buffer<ArrayBufferLike>
  File content (string or Buffer)
- OptionalcheckExisting: boolean
  If true, only allows adding new files
- Optionalpin: string
  Optional PIN code
Returns Promise<void>
Example
```
import fs from 'fs';

// Upload an image
const image = fs.readFileSync('diagram.png');
await sdk.saveStatementResource(12345, 'diagram.png', image);
```
Example
```
// Upload text file
await sdk.saveStatementResource(12345, 'notes.txt', 'Additional notes');
```
- Defined in polygon.ts:538

getChecker

getChecker(problemId: number, pin?: string): Promise<string>
Gets the name of currently configured checker program.
Parameters
- problemId: number
  Problem identifier
- Optionalpin: string
  Optional PIN code
Returns Promise<string>
Checker file name
Example
```
const checker = await sdk.getChecker(12345);
console.log('Current checker:', checker); // e.g., 'wcmp.cpp'
```
- Defined in polygon.ts:568

setChecker

setChecker(problemId: number, checker: string, pin?: string): Promise<void>
Sets the checker (output validator) for the problem. Can use standard testlib checkers or custom checker from source files.
Parameters
- problemId: number
  Problem identifier
- checker: string
  Checker file name from source files
- Optionalpin: string
  Optional PIN code
Returns Promise<void>
Example
```
// Use standard token checker
await sdk.setChecker(12345, 'wcmp.cpp');
```
Example
```
// Use custom checker
await sdk.setChecker(12345, 'checker.cpp');
```
- Defined in polygon.ts:591

getValidator

getValidator(problemId: number, pin?: string): Promise<string>
Gets the name of currently configured validator program.
Parameters
- problemId: number
  Problem identifier
- Optionalpin: string
  Optional PIN code
Returns Promise<string>
Validator file name
Example
```
const validator = await sdk.getValidator(12345);
console.log('Current validator:', validator);
```
- Defined in polygon.ts:616

setValidator

setValidator(problemId: number, validator: string, pin?: string): Promise<void>
Sets the input validator for the problem. Validator checks if test inputs meet problem constraints.
Parameters
- problemId: number
  Problem identifier
- validator: string
  Validator file name from source files
- Optionalpin: string
  Optional PIN code
Returns Promise<void>
Example
```
// Set validator
await sdk.setValidator(12345, 'validator.cpp');
```
- Defined in polygon.ts:635

getExtraValidators

getExtraValidators(problemId: number, pin?: string): Promise<string[]>
Gets list of extra validators configured for the problem. Extra validators provide additional input validation beyond main validator.
Parameters
- problemId: number
  Problem identifier
- Optionalpin: string
  Optional PIN code
Returns Promise<string[]>
Array of extra validator names
Example
```
const extraVals = await sdk.getExtraValidators(12345);
console.log('Extra validators:', extraVals);
```
- Defined in polygon.ts:660

getInteractor

getInteractor(problemId: number, pin?: string): Promise<string>
Gets the name of currently configured interactor program. Interactors are used for interactive problems.
Parameters
- problemId: number
  Problem identifier
- Optionalpin: string
  Optional PIN code
Returns Promise<string>
Interactor file name
Example
```
const interactor = await sdk.getInteractor(12345);
console.log('Current interactor:', interactor);
```
- Defined in polygon.ts:678

setInteractor

setInteractor(
    problemId: number,
    interactor: string,
    pin?: string,
): Promise<void>
Sets the interactor for an interactive problem. Interactor manages communication between solution and judge.
Parameters
- problemId: number
  Problem identifier
- interactor: string
  Interactor file name from source files
- Optionalpin: string
  Optional PIN code
Returns Promise<void>
Example
```
// Set interactor for interactive problem
await sdk.setInteractor(12345, 'interactor.cpp');
```
- Defined in polygon.ts:697

getValidatorTests

getValidatorTests(problemId: number, pin?: string): Promise<ValidatorTest[]>
Retrieves all validator self-test cases. These tests verify that the validator correctly accepts/rejects inputs.
Parameters
- problemId: number
  Problem identifier
- Optionalpin: string
  Optional PIN code
Returns Promise<ValidatorTest[]>
Array of validator test cases
Example
```
const valTests = await sdk.getValidatorTests(12345);
valTests.forEach(t => {
  console.log(`Test ${t.index}: ${t.expectedVerdict}`);
});
```
- Defined in polygon.ts:726

saveValidatorTest

saveValidatorTest(
    problemId: number,
    testIndex: number,
    testInput: string,
    testVerdict: "VALID" | "INVALID",
    options?: { checkExisting?: boolean; testGroup?: string; testset?: string },
    pin?: string,
): Promise<void>
Adds or updates a validator self-test case. Used to verify validator correctly validates inputs.
Parameters
- problemId: number
  Problem identifier
- testIndex: number
  Test number
- testInput: string
  Input to validate
- testVerdict: "VALID" | "INVALID"
  Expected validation result
- Optionaloptions: { checkExisting?: boolean; testGroup?: string; testset?: string }
  Additional options
  - OptionalcheckExisting?: boolean
    If true, only adding is allowed
  - OptionaltestGroup?: string
    Test group name
  - Optionaltestset?: string
    Testset name
- Optionalpin: string
  Optional PIN code
Returns Promise<void>
Example
```
// Add valid input test
await sdk.saveValidatorTest(12345, 1, '5 10', 'VALID');
```
Example
```
// Add invalid input test (negative numbers)
await sdk.saveValidatorTest(12345, 2, '-1 5', 'INVALID');
```
- Defined in polygon.ts:758

getCheckerTests

getCheckerTests(problemId: number, pin?: string): Promise<CheckerTest[]>
Retrieves all checker self-test cases. These tests verify that the checker produces correct verdicts.
Parameters
- problemId: number
  Problem identifier
- Optionalpin: string
  Optional PIN code
Returns Promise<CheckerTest[]>
Array of checker test cases
Example
```
const checkTests = await sdk.getCheckerTests(12345);
checkTests.forEach(t => {
  console.log(`Test ${t.index}: ${t.expectedVerdict}`);
});
```
- Defined in polygon.ts:797

saveCheckerTest

saveCheckerTest(
    problemId: number,
    testIndex: number,
    testInput: string,
    testOutput: string,
    testAnswer: string,
    testVerdict: "OK" | "WRONG_ANSWER" | "PRESENTATION_ERROR" | "CRASHED",
    checkExisting?: boolean,
    pin?: string,
): Promise<void>
Adds or updates a checker self-test case. Verifies checker correctly judges contestant outputs.
Parameters
- problemId: number
  Problem identifier
- testIndex: number
  Test number
- testInput: string
  Test input data
- testOutput: string
  Contestant's output to check
- testAnswer: string
  Correct answer (jury's answer)
- testVerdict: "OK" | "WRONG_ANSWER" | "PRESENTATION_ERROR" | "CRASHED"
  Expected checker verdict
- OptionalcheckExisting: boolean
  If true, only adding is allowed
- Optionalpin: string
  Optional PIN code
Returns Promise<void>
Example
```
// Checker should accept correct answer
await sdk.saveCheckerTest(12345, 1, '5 10', '15', '15', 'OK');
```
Example
```
// Checker should reject wrong answer
await sdk.saveCheckerTest(12345, 2, '5 10', '16', '15', 'WRONG_ANSWER');
```
Example
```
// Checker should detect presentation error
await sdk.saveCheckerTest(12345, 3, '5 10', '15 ', '15', 'PRESENTATION_ERROR');
```
- Defined in polygon.ts:832

getFiles

getFiles(problemId: number, pin?: string): Promise<FilesResponse>

Retrieves all files associated with the problem. Returns files organized by type: resource, source, and auxiliary.

Parameters

problemId: number
Problem identifier
Optionalpin: string
Optional PIN code

Returns Promise<FilesResponse>

Object containing file lists by type

Example

const files = await sdk.getFiles(12345);
console.log(`Resource files: ${files.resourceFiles.length}`);
console.log(`Source files: ${files.sourceFiles.length}`);
console.log(`Aux files: ${files.auxFiles.length}`);

Example

// List all source files
const files = await sdk.getFiles(12345);
files.sourceFiles.forEach(f => {
  console.log(`${f.name} (${f.sourceType})`);
});

viewFile

viewFile(
    problemId: number,
    type: "resource" | "source" | "aux",
    name: string,
    pin?: string,
): Promise<string>
Retrieves content of a specific file. Returns raw file content as string.
Parameters
- problemId: number
  Problem identifier
- type: "resource" | "source" | "aux"
  File type
- name: string
  File name
- Optionalpin: string
  Optional PIN code
Returns Promise<string>
File content as string
Example
```
// View generator source code
const code = await sdk.viewFile(12345, 'source', 'gen.cpp');
console.log(code);
```
Example
```
// View resource file
const data = await sdk.viewFile(12345, 'resource', 'grader.h');
```
- Defined in polygon.ts:903

saveFile

saveFile(
    problemId: number,
    type: "resource" | "source" | "aux",
    name: string,
    file: string | Buffer<ArrayBufferLike>,
    options?: {
        checkExisting?: boolean;
        sourceType?: string;
        forTypes?: string;
        stages?: string;
        assets?: string;
    },
    pin?: string,
): Promise<void>
Uploads or updates a file in the problem package. Supports resource, source, and auxiliary files with automatic base64 conversion.
Parameters
- problemId: number
  Problem identifier
- type: "resource" | "source" | "aux"
  File type
- name: string
  File name
- file: string | Buffer<ArrayBufferLike>
  File content (string or Buffer)
- Optionaloptions: {
      checkExisting?: boolean;
      sourceType?: string;
      forTypes?: string;
      stages?: string;
      assets?: string;
  }
  Additional file options
  - OptionalcheckExisting?: boolean
    If true, only adding is allowed
  - OptionalsourceType?: string
    Source language/compiler (e.g., 'cpp.g++17')
  - OptionalforTypes?: string
    File types pattern for resources
  - Optionalstages?: string
    Compilation/runtime stages for resources
  - Optionalassets?: string
    Asset types for resources
- Optionalpin: string
  Optional PIN code
Returns Promise<void>
Example
```
import fs from 'fs';

// Upload generator source file
const genCode = fs.readFileSync('gen.cpp', 'utf-8');
await sdk.saveFile(12345, 'source', 'gen.cpp', genCode, {
  sourceType: 'cpp.g++17'
});
```
Example
```
// Upload resource file (grader)
const grader = fs.readFileSync('grader.cpp', 'utf-8');
await sdk.saveFile(12345, 'resource', 'grader.cpp', grader, {
  forTypes: 'cpp.*',
  stages: 'COMPILE',
  assets: 'SOLUTION'
});
```
- Defined in polygon.ts:953

getSolutions

getSolutions(problemId: number, pin?: string): Promise<Solution[]>
Retrieves all solutions for the problem. Solutions include main, correct, and incorrect solutions with various tags.
Parameters
- problemId: number
  Problem identifier
- Optionalpin: string
  Optional PIN code
Returns Promise<Solution[]>
Array of solution objects
Example
```
const solutions = await sdk.getSolutions(12345);
const mainSol = solutions.find(s => s.tag === 'MA');
console.log(`Main solution: ${mainSol?.name}`);
```
Example
```
// List all solutions with their tags
const solutions = await sdk.getSolutions(12345);
solutions.forEach(s => {
  console.log(`${s.name} (${s.tag})`);
});
```
- Defined in polygon.ts:1000

viewSolution

viewSolution(problemId: number, name: string, pin?: string): Promise<string>
Retrieves source code of a specific solution. Returns raw solution code as string.
Parameters
- problemId: number
  Problem identifier
- name: string
  Solution file name
- Optionalpin: string
  Optional PIN code
Returns Promise<string>
Solution source code
Example
```
// View main solution code
const code = await sdk.viewSolution(12345, 'main.cpp');
console.log(code);
```
- Defined in polygon.ts:1020

saveSolution

saveSolution(
    problemId: number,
    name: string,
    file: string | Buffer<ArrayBufferLike>,
    tag: "OK" | "MA" | "RJ" | "TL" | "TO" | "WA" | "PE" | "ML" | "RE",
    options?: { checkExisting?: boolean; sourceType?: string },
    pin?: string,
): Promise<void>
Uploads or updates a solution with specified tag. Tag indicates expected behavior (correct, wrong answer, TLE, etc.).
Parameters
- problemId: number
  Problem identifier
- name: string
  Solution file name
- file: string | Buffer<ArrayBufferLike>
  Solution source code
- tag: "OK" | "MA" | "RJ" | "TL" | "TO" | "WA" | "PE" | "ML" | "RE"
  Expected behavior tag
- Optionaloptions: { checkExisting?: boolean; sourceType?: string }
  Additional options
  - OptionalcheckExisting?: boolean
    If true, only adding is allowed
  - OptionalsourceType?: string
    Language/compiler (e.g., 'cpp.g++17')
- Optionalpin: string
  Optional PIN code
Returns Promise<void>
Example
```
import fs from 'fs';

// Upload main correct solution
const code = fs.readFileSync('main.cpp', 'utf-8');
await sdk.saveSolution(12345, 'main.cpp', code, 'MA', {
  sourceType: 'cpp.g++17'
});
```
Example
```
// Upload TLE solution
const tleSol = fs.readFileSync('slow.cpp', 'utf-8');
await sdk.saveSolution(12345, 'slow.cpp', tleSol, 'TL');
```
Example
```
// Upload wrong answer solution
const waSol = fs.readFileSync('wrong.cpp', 'utf-8');
await sdk.saveSolution(12345, 'wrong.cpp', waSol, 'WA');
```
- Defined in polygon.ts:1066

editSolutionExtraTags

editSolutionExtraTags(
    problemId: number,
    name: string,
    remove: boolean,
    options: {
        testset?: string;
        testGroup?: string;
        tag?: "OK" | "RJ" | "TL" | "TO" | "WA" | "PE" | "ML" | "RE";
    },
    pin?: string,
): Promise<void>
Adds or removes extra tags for solution on specific testset or test group. Extra tags allow different expected behaviors for different test groups.
Parameters
- problemId: number
  Problem identifier
- name: string
  Solution name
- remove: boolean
  If true, removes tag; if false, adds tag
- options: {
      testset?: string;
      testGroup?: string;
      tag?: "OK" | "RJ" | "TL" | "TO" | "WA" | "PE" | "ML" | "RE";
  }
  Tag options (must specify testset OR testGroup)
  - Optionaltestset?: string
    Testset name
  - OptionaltestGroup?: string
    Test group name
  - Optionaltag?: "OK" | "RJ" | "TL" | "TO" | "WA" | "PE" | "ML" | "RE"
    Extra tag (required when adding)
- Optionalpin: string
  Optional PIN code
Returns Promise<void>
Example
```
// Add TL tag for specific test group
await sdk.editSolutionExtraTags(12345, 'slow.cpp', false, {
  testGroup: 'large',
  tag: 'TL'
});
```
Example
```
// Remove extra tag from testset
await sdk.editSolutionExtraTags(12345, 'solution.cpp', true, {
  testset: 'tests'
});
```
- Defined in polygon.ts:1115

getScript

getScript(problemId: number, testset: string, pin?: string): Promise<string>
Retrieves test generation script for specified testset. Script contains commands for generating tests using generators.
Parameters
- problemId: number
  Problem identifier
- testset: string
  Testset name (usually 'tests')
- Optionalpin: string
  Optional PIN code
Returns Promise<string>
Generation script content
Example
```
const script = await sdk.getScript(12345, 'tests');
console.log('Generation script:', script);
```
- Defined in polygon.ts:1151

saveScript

saveScript(
    problemId: number,
    testset: string,
    source: string,
    pin?: string,
): Promise<void>
Saves test generation script for specified testset. Script defines how tests are generated using generator programs.
Parameters
- problemId: number
  Problem identifier
- testset: string
  Testset name
- source: string
  Script content with generation commands
- Optionalpin: string
  Optional PIN code
Returns Promise<void>
Example
```
// Save generation script
const script = `
gen 1 10 > $
gen 11 100 > $
gen 101 1000 > $
`;
await sdk.saveScript(12345, 'tests', script);
```
- Defined in polygon.ts:1183

getTests

getTests(
    problemId: number,
    testset: string,
    noInputs?: boolean,
    pin?: string,
): Promise<Test[]>
Retrieves all tests for specified testset. Can optionally exclude input data to reduce response size.
Parameters
- problemId: number
  Problem identifier
- testset: string
  Testset name (usually 'tests')
- OptionalnoInputs: boolean
  If true, excludes input data from response
- Optionalpin: string
  Optional PIN code
Returns Promise<Test[]>
Array of test cases
Example
```
// Get all tests with input data
const tests = await sdk.getTests(12345, 'tests');
tests.forEach(t => {
  console.log(`Test ${t.index}: ${t.manual ? 'manual' : 'generated'}`);
});
```
Example
```
// Get tests without input data (faster)
const testsInfo = await sdk.getTests(12345, 'tests', true);
```
- Defined in polygon.ts:1221

getTestInput

getTestInput(
    problemId: number,
    testset: string,
    testIndex: number,
    pin?: string,
): Promise<string>
Retrieves input data for a specific test. Returns raw input content as string.
Parameters
- problemId: number
  Problem identifier
- testset: string
  Testset name
- testIndex: number
  Test number (1-indexed)
- Optionalpin: string
  Optional PIN code
Returns Promise<string>
Test input data
Example
```
const input = await sdk.getTestInput(12345, 'tests', 1);
console.log('Test 1 input:', input);
```
- Defined in polygon.ts:1250

getTestAnswer

getTestAnswer(
    problemId: number,
    testset: string,
    testIndex: number,
    pin?: string,
): Promise<string>
Retrieves expected answer for a specific test. Answer is generated by running main solution on test input.
Parameters
- problemId: number
  Problem identifier
- testset: string
  Testset name
- testIndex: number
  Test number (1-indexed)
- Optionalpin: string
  Optional PIN code
Returns Promise<string>
Test answer data
Example
```
const answer = await sdk.getTestAnswer(12345, 'tests', 1);
console.log('Expected answer:', answer);
```
Example
```
// Compare input and answer
const input = await sdk.getTestInput(12345, 'tests', 1);
const answer = await sdk.getTestAnswer(12345, 'tests', 1);
console.log(`Input: ${input}, Answer: ${answer}`);
```
- Defined in polygon.ts:1285

saveTest

saveTest(
    problemId: number,
    testset: string,
    testIndex: number,
    testInput: string,
    options?: TestOptions,
    pin?: string,
): Promise<void>
Adds a new test or updates existing test. For manual tests, provide testInput. For generated tests, use script.
Parameters
- problemId: number
  Problem identifier
- testset: string
  Testset name
- testIndex: number
  Test number (1-indexed)
- testInput: string
  Test input data
- Optionaloptions: TestOptions
  Additional test properties
  
  Options for adding or updating a test via the Polygon API. TestOptions
  - OptionalcheckExisting?: boolean
    Whether to check if test already exists
  - OptionaltestGroup?: string
    Name of the test group
  - OptionaltestPoints?: number
    Points assigned to the test
  - OptionaltestDescription?: string
    Description of the test
  - OptionaltestUseInStatements?: boolean
    Whether to use test in statements
  - OptionaltestInputForStatements?: string
    Input to show in statements
  - OptionaltestOutputForStatements?: string
    Output to show in statements
  - OptionalverifyInputOutputForStatements?: boolean
    Verify I/O for statements
- Optionalpin: string
  Optional PIN code
Returns Promise<void>
Example
```
// Add simple manual test
await sdk.saveTest(12345, 'tests', 1, '5 10');
```
Example
```
// Add test with description and group
await sdk.saveTest(12345, 'tests', 2, '1000000 2000000', {
  testDescription: 'Large numbers test',
  testGroup: 'large',
  testPoints: 10
});
```
Example
```
// Add sample test for statement
await sdk.saveTest(12345, 'tests', 1, '1 2', {
  testUseInStatements: true,
  testInputForStatements: '1 2',
  testOutputForStatements: '3'
});
```
- Defined in polygon.ts:1340

setTestGroup

setTestGroup(
    problemId: number,
    testset: string,
    testGroup: string,
    testIndices: number[],
    pin?: string,
): Promise<void>
Assigns one or more tests to a specific test group. Groups must be enabled for the testset before using this method.
Parameters
- problemId: number
  Problem identifier
- testset: string
  Testset name
- testGroup: string
  Group name to assign tests to
- testIndices: number[]
  Array of test numbers to assign
- Optionalpin: string
  Optional PIN code
Returns Promise<void>
Example
```
// Assign tests 1-5 to 'small' group
await sdk.setTestGroup(12345, 'tests', 'small', [1, 2, 3, 4, 5]);
```
Example
```
// Assign specific tests to 'large' group
await sdk.setTestGroup(12345, 'tests', 'large', [10, 11, 12]);
```
- Defined in polygon.ts:1378

enableGroups

enableGroups(
    problemId: number,
    testset: string,
    enable: boolean,
    pin?: string,
): Promise<void>
Enables or disables test groups for a testset. When enabled, tests can be organized into groups for partial scoring.
Parameters
- problemId: number
  Problem identifier
- testset: string
  Testset name
- enable: boolean
  True to enable, false to disable
- Optionalpin: string
  Optional PIN code
Returns Promise<void>
Example
```
// Enable test groups
await sdk.enableGroups(12345, 'tests', true);
```
Example
```
// Disable test groups
await sdk.enableGroups(12345, 'tests', false);
```
- Defined in polygon.ts:1413

enablePoints

enablePoints(problemId: number, enable: boolean, pin?: string): Promise<void>
Enables or disables point scoring for the problem. When enabled, individual tests can be assigned point values.
Parameters
- problemId: number
  Problem identifier
- enable: boolean
  True to enable, false to disable
- Optionalpin: string
  Optional PIN code
Returns Promise<void>
Example
```
// Enable point scoring
await sdk.enablePoints(12345, true);
```
Example
```
// Disable point scoring
await sdk.enablePoints(12345, false);
```
- Defined in polygon.ts:1445

viewTestGroup

viewTestGroup(
    problemId: number,
    testset: string,
    group?: string,
    pin?: string,
): Promise<TestGroup[]>
Retrieves configuration for one or all test groups. Returns group settings including points policy, feedback policy, and dependencies.
Parameters
- problemId: number
  Problem identifier
- testset: string
  Testset name
- Optionalgroup: string
  Specific group name (omit to get all groups)
- Optionalpin: string
  Optional PIN code
Returns Promise<TestGroup[]>
Array of test group configurations
Example
```
// Get all test groups
const groups = await sdk.viewTestGroup(12345, 'tests');
groups.forEach(g => {
  console.log(`${g.name}: ${g.pointsPolicy}, ${g.feedbackPolicy}`);
});
```
Example
```
// Get specific group
const [group] = await sdk.viewTestGroup(12345, 'tests', 'large');
console.log('Dependencies:', group.dependencies);
```
- Defined in polygon.ts:1480

saveTestGroup

saveTestGroup(
    problemId: number,
    testset: string,
    group: string,
    options?: {
        pointsPolicy?: "COMPLETE_GROUP" | "EACH_TEST";
        feedbackPolicy?: "NONE" | "POINTS" | "ICPC" | "COMPLETE";
        dependencies?: string;
    },
    pin?: string,
): Promise<void>
Configures settings for a test group. Sets points policy, feedback policy, and group dependencies.
Parameters
- problemId: number
  Problem identifier
- testset: string
  Testset name
- group: string
  Group name
- Optionaloptions: {
      pointsPolicy?: "COMPLETE_GROUP" | "EACH_TEST";
      feedbackPolicy?: "NONE" | "POINTS" | "ICPC" | "COMPLETE";
      dependencies?: string;
  }
  Group configuration options
  - OptionalpointsPolicy?: "COMPLETE_GROUP" | "EACH_TEST"
    How points are awarded
  - OptionalfeedbackPolicy?: "NONE" | "POINTS" | "ICPC" | "COMPLETE"
    Feedback level
  - Optionaldependencies?: string
    Comma-separated list of groups that must pass first
- Optionalpin: string
  Optional PIN code
Returns Promise<void>
Example
```
// Configure group with ICPC feedback
await sdk.saveTestGroup(12345, 'tests', 'group1', {
  pointsPolicy: 'COMPLETE_GROUP',
  feedbackPolicy: 'ICPC'
});
```
Example
```
// Set group dependencies
await sdk.saveTestGroup(12345, 'tests', 'hard', {
  dependencies: 'easy,medium'
});
```
- Defined in polygon.ts:1522

viewTags

viewTags(problemId: number, pin?: string): Promise<string[]>
Retrieves all tags associated with the problem. Tags categorize problems (e.g., 'dp', 'graphs', 'math').
Parameters
- problemId: number
  Problem identifier
- Optionalpin: string
  Optional PIN code
Returns Promise<string[]>
Array of tag strings
Example
```
const tags = await sdk.viewTags(12345);
console.log('Problem tags:', tags.join(', '));
```
- Defined in polygon.ts:1557

saveTags

saveTags(problemId: number, tags: string[], pin?: string): Promise<void>
Saves tags for the problem, replacing all existing tags. Tags help categorize and search for problems.
Parameters
- problemId: number
  Problem identifier
- tags: string[]
  Array of tag strings
- Optionalpin: string
  Optional PIN code
Returns Promise<void>
Example
```
// Set problem tags
await sdk.saveTags(12345, ['dp', 'greedy', 'implementation']);
```
Example
```
// Clear all tags
await sdk.saveTags(12345, []);
```
- Defined in polygon.ts:1580

viewGeneralDescription

viewGeneralDescription(problemId: number, pin?: string): Promise<string>
Retrieves general description of the problem. Description provides overview and context for the problem.
Parameters
- problemId: number
  Problem identifier
- Optionalpin: string
  Optional PIN code
Returns Promise<string>
Problem description text
Example
```
const desc = await sdk.viewGeneralDescription(12345);
console.log('Description:', desc);
```
- Defined in polygon.ts:1605

saveGeneralDescription

saveGeneralDescription(
    problemId: number,
    description: string,
    pin?: string,
): Promise<void>
Saves general description for the problem. Can be empty string to clear description.
Parameters
- problemId: number
  Problem identifier
- description: string
  Description text (can be empty)
- Optionalpin: string
  Optional PIN code
Returns Promise<void>
Example
```
await sdk.saveGeneralDescription(12345,
  'This problem tests understanding of dynamic programming.'
);
```
Example
```
// Clear description
await sdk.saveGeneralDescription(12345, '');
```
- Defined in polygon.ts:1632

viewGeneralTutorial

viewGeneralTutorial(problemId: number, pin?: string): Promise<string>
Retrieves general tutorial for the problem. Tutorial provides solution approach and explanation.
Parameters
- problemId: number
  Problem identifier
- Optionalpin: string
  Optional PIN code
Returns Promise<string>
Tutorial text
Example
```
const tutorial = await sdk.viewGeneralTutorial(12345);
console.log('Tutorial:', tutorial);
```
- Defined in polygon.ts:1657

saveGeneralTutorial

saveGeneralTutorial(
    problemId: number,
    tutorial: string,
    pin?: string,
): Promise<void>
Saves general tutorial for the problem. Can be empty string to clear tutorial.
Parameters
- problemId: number
  Problem identifier
- tutorial: string
  Tutorial text (can be empty)
- Optionalpin: string
  Optional PIN code
Returns Promise<void>
Example
```
await sdk.saveGeneralTutorial(12345,
  'Use dynamic programming with O(n^2) complexity.'
);
```
Example
```
// Clear tutorial
await sdk.saveGeneralTutorial(12345, '');
```
- Defined in polygon.ts:1681

listPackages

listPackages(problemId: number, pin?: string): Promise<Package[]>
Lists all built packages for the problem. Shows package state, type, and revision information.
Parameters
- problemId: number
  Problem identifier
- Optionalpin: string
  Optional PIN code
Returns Promise<Package[]>
Array of package objects
Example
```
const packages = await sdk.listPackages(12345);
packages.forEach(pkg => {
  console.log(`Package ${pkg.id}: ${pkg.state} (rev ${pkg.revision})`);
});
```
Example
```
// Find latest ready package
const ready = packages.filter(p => p.state === 'READY');
const latest = ready.sort((a, b) => b.id - a.id)[0];
```
- Defined in polygon.ts:1715

downloadPackage

downloadPackage(
    problemId: number,
    packageId: number,
    type?: "standard" | "linux" | "windows",
    pin?: string,
): Promise<Buffer<ArrayBufferLike>>
Downloads a built package as a zip archive.
Parameters
- problemId: number
  Problem identifier
- packageId: number
  Package ID from listPackages
- Optionaltype: "standard" | "linux" | "windows"
  Package type (default: 'standard')
- Optionalpin: string
  Optional PIN code
Returns Promise<Buffer<ArrayBufferLike>>
Package zip file as Buffer
Example
```
import fs from 'fs';

// Download linux package
const zipData = await sdk.downloadPackage(12345, 456, 'linux');
fs.writeFileSync('problem-package.zip', zipData);
```
Example
```
// Download standard package
const pkg = await sdk.downloadPackage(12345, 456);
fs.writeFileSync('problem.zip', pkg);
```
- Defined in polygon.ts:1742

buildPackage

buildPackage(
    problemId: number,
    full: boolean,
    verify: boolean,
    pin?: string,
): Promise<void>
Starts building a new package for the problem. Package will be built asynchronously; use listPackages to check status.
Parameters
- problemId: number
  Problem identifier
- full: boolean
  If true, build full package (standard + linux + windows)
- verify: boolean
  If true, run all solutions on all tests for verification
- Optionalpin: string
  Optional PIN code
Returns Promise<void>
Example
```
// Build full verified package
await sdk.buildPackage(12345, true, true);
console.log('Package building started');
```
Example
```
// Build standard package without verification (faster)
await sdk.buildPackage(12345, false, false);
```
- Defined in polygon.ts:1777

getContestProblems

getContestProblems(contestId: number, pin?: string): Promise<Problem[]>
Retrieves list of problems in a contest. Returns basic problem information for all contest problems.
Parameters
- contestId: number
  Contest identifier
- Optionalpin: string
  Optional PIN code for protected contests
Returns Promise<Problem[]>
Array of problem objects
Example
```
const problems = await sdk.getContestProblems(789);
problems.forEach(p => {
  console.log(`${p.name} (ID: ${p.id})`);
});
```
- Defined in polygon.ts:1808

Class PolygonSDK

Example

Example

Example

Example

Index

Constructors

Properties

Methods

Constructors

constructor

Parameters

Returns PolygonSDK

Throws

Example

Properties

Private InternalapiKey

Private InternalapiSecret

Private InternalbaseUrl

Methods

PrivategenerateSignature

Parameters

Returns string

Privaterequest

Type Parameters

Parameters

Returns Promise<T>

Throws

listProblems

Parameters

OptionalshowDeleted?: boolean

Optionalid?: number

Optionalname?: string

Optionalowner?: string

Returns Promise<Problem[]>

Example

Example

Example

createProblem

Parameters

Returns Promise<Problem>

Throws

Example

getProblemInfo

Parameters

Returns Promise<ProblemInfo>

Example

updateProblemInfo

Parameters

Returns Promise<void>

Example

Example

updateWorkingCopy

Parameters

Returns Promise<void>

Example

discardWorkingCopy

Parameters

Returns Promise<void>

Example

commitChanges

Parameters

OptionalminorChanges?: boolean

Optionalmessage?: string

Returns Promise<void>

Example

Example

getStatements

Parameters

Returns Promise<Record<string, Statement>>

Example

saveStatement

Parameters

Returns Promise<void>

Example

Example

getStatementResources

Parameters

Returns Promise<File[]>

Example

`Private` `Internal`apiKey

`Private` `Internal`apiSecret

`Private` `Internal`baseUrl

`Private`generateSignature

`Private`request

`Optional`showDeleted?: boolean

`Optional`id?: number

`Optional`name?: string

`Optional`owner?: string

`Optional`minorChanges?: boolean

`Optional`message?: string

`Optional`checkExisting?: boolean

`Optional`testGroup?: string

`Optional`testset?: string

`Optional`checkExisting?: boolean

`Optional`sourceType?: string