@testcollab/sdk 3.1.1

package/dist/esm/runtime.js

@@ -0,0 +1,390 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * TC API
+ * TestCollab is a test management tool that helps development teams carry out testing effectively and avoid failures. # Introduction This is an API documentation for TestCollab 2.   # Authentication TestCollab supports two forms of authentication:   - An <b>API token</b> is required to make API calls. The token can be generated from user\'s profile; to obtain it login to your TestCollab account and go to [\'My Profile Settings\'](https://testcollab.io/my_profile) and switch to API Token tab. Click on \"Generate new API token\", Once the token is generated it can be sent as a query parameter for the API calls made - https://api.testcollab.io/projects?token=<generated-API-token>    - <b>Bearer authentication</b> (also called token authentication) is an HTTP authentication scheme that involves security tokens called bearer tokens. You can generate bearer auth token using [Login](#operation/login) API.     Send this token as the Authorization header while making requests to protected resources:     `Authorization: Bearer <token>`    For making API calls, we recommend using the <b>API token</b> generated from user profile page as it won\'t affect the on-going user session and will be available until it is revoked by the user who generated it.      # Error Handling Error responses   - `Not Found` - Error is sent when requested resource is not available.   - `Unauthorized - invalid token` - Error is sent when API token sent with the request is invalid or revoked. Error contains status code 401        - `Forbidden` - Error is sent when logged in user is not part of the company, project or his role does not allow to complete given action. Response consist of 403 status code and more information is given in error message.
+ *
+ * The version of the OpenAPI document: 2.3.1
+ * Contact: support@testcollab.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+export const BASE_PATH = "https://api.testcollab.io".replace(/\/+$/, "");
+export class Configuration {
+    constructor(configuration = {}) {
+        this.configuration = configuration;
+    }
+    set config(configuration) {
+        this.configuration = configuration;
+    }
+    get basePath() {
+        return this.configuration.basePath != null ? this.configuration.basePath : BASE_PATH;
+    }
+    get fetchApi() {
+        return this.configuration.fetchApi;
+    }
+    get middleware() {
+        return this.configuration.middleware || [];
+    }
+    get queryParamsStringify() {
+        return this.configuration.queryParamsStringify || querystring;
+    }
+    get username() {
+        return this.configuration.username;
+    }
+    get password() {
+        return this.configuration.password;
+    }
+    get apiKey() {
+        const apiKey = this.configuration.apiKey;
+        if (apiKey) {
+            return typeof apiKey === 'function' ? apiKey : () => apiKey;
+        }
+        return undefined;
+    }
+    get accessToken() {
+        const accessToken = this.configuration.accessToken;
+        if (accessToken) {
+            return typeof accessToken === 'function' ? accessToken : () => __awaiter(this, void 0, void 0, function* () { return accessToken; });
+        }
+        return undefined;
+    }
+    get headers() {
+        return this.configuration.headers;
+    }
+    get credentials() {
+        return this.configuration.credentials;
+    }
+}
+export const DefaultConfig = new Configuration();
+/**
+ * This is the base class for all generated API classes.
+ */
+export class BaseAPI {
+    constructor(configuration = DefaultConfig) {
+        this.configuration = configuration;
+        this.fetchApi = (url, init) => __awaiter(this, void 0, void 0, function* () {
+            let fetchParams = { url, init };
+            for (const middleware of this.middleware) {
+                if (middleware.pre) {
+                    fetchParams = (yield middleware.pre(Object.assign({ fetch: this.fetchApi }, fetchParams))) || fetchParams;
+                }
+            }
+            let response = undefined;
+            try {
+                response = yield (this.configuration.fetchApi || fetch)(fetchParams.url, fetchParams.init);
+            }
+            catch (e) {
+                for (const middleware of this.middleware) {
+                    if (middleware.onError) {
+                        response = (yield middleware.onError({
+                            fetch: this.fetchApi,
+                            url: fetchParams.url,
+                            init: fetchParams.init,
+                            error: e,
+                            response: response ? response.clone() : undefined,
+                        })) || response;
+                    }
+                }
+                if (response === undefined) {
+                    if (e instanceof Error) {
+                        throw new FetchError(e, 'The request failed and the interceptors did not return an alternative response');
+                    }
+                    else {
+                        throw e;
+                    }
+                }
+            }
+            for (const middleware of this.middleware) {
+                if (middleware.post) {
+                    response = (yield middleware.post({
+                        fetch: this.fetchApi,
+                        url: fetchParams.url,
+                        init: fetchParams.init,
+                        response: response.clone(),
+                    })) || response;
+                }
+            }
+            return response;
+        });
+        this.middleware = configuration.middleware;
+    }
+    withMiddleware(...middlewares) {
+        const next = this.clone();
+        next.middleware = next.middleware.concat(...middlewares);
+        return next;
+    }
+    withPreMiddleware(...preMiddlewares) {
+        const middlewares = preMiddlewares.map((pre) => ({ pre }));
+        return this.withMiddleware(...middlewares);
+    }
+    withPostMiddleware(...postMiddlewares) {
+        const middlewares = postMiddlewares.map((post) => ({ post }));
+        return this.withMiddleware(...middlewares);
+    }
+    /**
+     * Check if the given MIME is a JSON MIME.
+     * JSON MIME examples:
+     *   application/json
+     *   application/json; charset=UTF8
+     *   APPLICATION/JSON
+     *   application/vnd.company+json
+     * @param mime - MIME (Multipurpose Internet Mail Extensions)
+     * @return True if the given MIME is JSON, false otherwise.
+     */
+    isJsonMime(mime) {
+        if (!mime) {
+            return false;
+        }
+        return BaseAPI.jsonRegex.test(mime);
+    }
+    request(context, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { url, init } = yield this.createFetchParams(context, initOverrides);
+            const response = yield this.fetchApi(url, init);
+            if (response && (response.status >= 200 && response.status < 300)) {
+                return response;
+            }
+            throw new ResponseError(response, 'Response returned an error code');
+        });
+    }
+    createFetchParams(context, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (context.query && context.query["_filter"] != null) {
+                const parsedFilter = JSON.parse(String(context.query["_filter"]));
+                const targetQuery = context.query;
+                for (const key in parsedFilter) {
+                    if (Object.prototype.hasOwnProperty.call(parsedFilter, key)) {
+                        targetQuery[key] = parsedFilter[key];
+                    }
+                }
+                delete targetQuery["_filter"];
+            }
+            let url = this.configuration.basePath + context.path;
+            if (context.query !== undefined && Object.keys(context.query).length !== 0) {
+                // only add the querystring to the URL if there are query parameters.
+                // this is done to avoid urls ending with a "?" character which buggy webservers
+                // do not handle correctly sometimes.
+                url += '?' + this.configuration.queryParamsStringify(context.query);
+            }
+            const headers = Object.assign({}, this.configuration.headers, context.headers);
+            Object.keys(headers).forEach(key => headers[key] === undefined ? delete headers[key] : {});
+            const initOverrideFn = typeof initOverrides === "function"
+                ? initOverrides
+                : () => __awaiter(this, void 0, void 0, function* () { return initOverrides; });
+            const initParams = {
+                method: context.method,
+                headers,
+                body: context.body,
+                credentials: this.configuration.credentials,
+            };
+            const overriddenInit = Object.assign(Object.assign({}, initParams), (yield initOverrideFn({
+                init: initParams,
+                context,
+            })));
+            let body;
+            if (isFormData(overriddenInit.body)
+                || (overriddenInit.body instanceof URLSearchParams)
+                || isBlob(overriddenInit.body)) {
+                body = overriddenInit.body;
+            }
+            else if (this.isJsonMime(headers['Content-Type'])) {
+                body = JSON.stringify(overriddenInit.body);
+            }
+            else {
+                body = overriddenInit.body;
+            }
+            const init = Object.assign(Object.assign({}, overriddenInit), { body });
+            return { url, init };
+        });
+    }
+    /**
+     * Create a shallow clone of `this` by constructing a new instance
+     * and then shallow cloning data members.
+     */
+    clone() {
+        const constructor = this.constructor;
+        const next = new constructor(this.configuration);
+        next.middleware = this.middleware.slice();
+        return next;
+    }
+}
+BaseAPI.jsonRegex = new RegExp('^(:?application\/json|[^;/ \t]+\/[^;/ \t]+[+]json)[ \t]*(:?;.*)?$', 'i');
+;
+function isBlob(value) {
+    return typeof Blob !== 'undefined' && value instanceof Blob;
+}
+function isFormData(value) {
+    return typeof FormData !== "undefined" && value instanceof FormData;
+}
+export class ResponseError extends Error {
+    constructor(response, msg) {
+        super(msg);
+        this.response = response;
+        this.name = "ResponseError";
+    }
+}
+export class FetchError extends Error {
+    constructor(cause, msg) {
+        super(msg);
+        this.cause = cause;
+        this.name = "FetchError";
+    }
+}
+export class RequiredError extends Error {
+    constructor(field, msg) {
+        super(msg);
+        this.field = field;
+        this.name = "RequiredError";
+    }
+}
+export const COLLECTION_FORMATS = {
+    csv: ",",
+    ssv: " ",
+    tsv: "\t",
+    pipes: "|",
+};
+export function querystring(params, prefix = '') {
+    return Object.keys(params)
+        .map(key => querystringSingleKey(key, params[key], prefix))
+        .filter(part => part.length > 0)
+        .join('&');
+}
+function querystringSingleKey(key, value, keyPrefix = '') {
+    const fullKey = keyPrefix + (keyPrefix.length ? `[${key}]` : key);
+    if (value instanceof Array) {
+        const multiValue = value.map(singleValue => encodeURIComponent(String(singleValue)))
+            .join(`&${encodeURIComponent(fullKey)}=`);
+        return `${encodeURIComponent(fullKey)}=${multiValue}`;
+    }
+    if (value instanceof Set) {
+        const valueAsArray = Array.from(value);
+        return querystringSingleKey(key, valueAsArray, keyPrefix);
+    }
+    if (value instanceof Date) {
+        return `${encodeURIComponent(fullKey)}=${encodeURIComponent(value.toISOString())}`;
+    }
+    if (value instanceof Object) {
+        return querystring(value, fullKey);
+    }
+    return `${encodeURIComponent(fullKey)}=${encodeURIComponent(String(value))}`;
+}
+export function exists(json, key) {
+    const value = json[key];
+    return value !== null && value !== undefined;
+}
+export function mapValues(data, fn) {
+    const result = {};
+    for (const key of Object.keys(data)) {
+        result[key] = fn(data[key]);
+    }
+    return result;
+}
+export function canConsumeForm(consumes) {
+    for (const consume of consumes) {
+        if ('multipart/form-data' === consume.contentType) {
+            return true;
+        }
+    }
+    return false;
+}
+export class JSONApiResponse {
+    constructor(raw, transformer = (jsonValue) => jsonValue) {
+        this.raw = raw;
+        this.transformer = transformer;
+    }
+    value() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.transformer(yield this.raw.json());
+        });
+    }
+}
+export class VoidApiResponse {
+    constructor(raw) {
+        this.raw = raw;
+    }
+    value() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return undefined;
+        });
+    }
+}
+export class BlobApiResponse {
+    constructor(raw) {
+        this.raw = raw;
+    }
+    value() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.raw.blob();
+        });
+    }
+    ;
+}
+export class TextApiResponse {
+    constructor(raw) {
+        this.raw = raw;
+    }
+    value() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.raw.text();
+        });
+    }
+    ;
+}
+// PATCH: SDK helper(s) appended to the generated runtime.ts file.
+// This file is read by sdk-enhancements/patch-runtime.mjs and should only
+// contain the additional helpers we want to append post generation.
+const TOKEN_QUERY_KEY = 'token';
+const toUrlString = (input) => {
+    if (typeof input === 'string') {
+        return input;
+    }
+    if (typeof URL !== 'undefined' && input instanceof URL) {
+        return input.toString();
+    }
+    if (typeof input === 'object' && input !== null) {
+        const maybeRequest = input;
+        if (typeof maybeRequest.url === 'string') {
+            return maybeRequest.url;
+        }
+        const maybeHref = input.href;
+        if (typeof maybeHref === 'string') {
+            return maybeHref;
+        }
+    }
+    return String(input);
+};
+/**
+ * Lightweight helper that creates a Configuration pre-configured to append
+ * the Test Collab API token to every request. All existing configuration
+ * options are preserved via the optional baseConfig parameter.
+ */
+export function createConfiguration(apiKey, baseConfig = {}) {
+    var _a;
+    if (!apiKey) {
+        throw new Error('`apiKey` is required when calling createConfiguration.');
+    }
+    const globalFetch = typeof fetch === 'function' ? fetch.bind(globalThis) : undefined;
+    const resolvedFetch = ((_a = baseConfig.fetchApi) !== null && _a !== void 0 ? _a : globalFetch);
+    if (!resolvedFetch) {
+        throw new Error('No fetch implementation available. Provide one via baseConfig.fetchApi or ensure fetch is globally available.');
+    }
+    const fetchWithToken = (url, init) => {
+        const urlString = toUrlString(url);
+        const separator = urlString.includes('?') ? '&' : '?';
+        const tokenizedUrl = `${urlString}${separator}${TOKEN_QUERY_KEY}=${encodeURIComponent(apiKey)}`;
+        return resolvedFetch(tokenizedUrl, init);
+    };
+    return new Configuration(Object.assign(Object.assign({}, baseConfig), { fetchApi: fetchWithToken }));
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './runtime';
+export * from './apis/index';
+export * from './models/index';

package/dist/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* tslint:disable */
+/* eslint-disable */
+__exportStar(require("./runtime"), exports);
+__exportStar(require("./apis/index"), exports);
+__exportStar(require("./models/index"), exports);

package/dist/models/Activity.d.ts

@@ -0,0 +1,106 @@
+/**
+ * TC API
+ * TestCollab is a test management tool that helps development teams carry out testing effectively and avoid failures. # Introduction This is an API documentation for TestCollab 2.   # Authentication TestCollab supports two forms of authentication:   - An <b>API token</b> is required to make API calls. The token can be generated from user\'s profile; to obtain it login to your TestCollab account and go to [\'My Profile Settings\'](https://testcollab.io/my_profile) and switch to API Token tab. Click on \"Generate new API token\", Once the token is generated it can be sent as a query parameter for the API calls made - https://api.testcollab.io/projects?token=<generated-API-token>    - <b>Bearer authentication</b> (also called token authentication) is an HTTP authentication scheme that involves security tokens called bearer tokens. You can generate bearer auth token using [Login](#operation/login) API.     Send this token as the Authorization header while making requests to protected resources:     `Authorization: Bearer <token>`    For making API calls, we recommend using the <b>API token</b> generated from user profile page as it won\'t affect the on-going user session and will be available until it is revoked by the user who generated it.      # Error Handling Error responses   - `Not Found` - Error is sent when requested resource is not available.   - `Unauthorized - invalid token` - Error is sent when API token sent with the request is invalid or revoked. Error contains status code 401        - `Forbidden` - Error is sent when logged in user is not part of the company, project or his role does not allow to complete given action. Response consist of 403 status code and more information is given in error message.
+ *
+ * The version of the OpenAPI document: 2.3.1
+ * Contact: support@testcollab.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import type { ProjectMini } from './ProjectMini';
+import type { User } from './User';
+/**
+ *
+ * @export
+ * @interface Activity
+ */
+export interface Activity {
+    /**
+     * Type of entity
+     * @type {string}
+     * @memberof Activity
+     */
+    entity: string;
+    /**
+     * Entity ID
+     * @type {number}
+     * @memberof Activity
+     */
+    entityId: number;
+    /**
+     * Entity show/display field
+     * @type {string}
+     * @memberof Activity
+     */
+    entityTitle: string;
+    /**
+     * Test case title
+     * @type {string}
+     * @memberof Activity
+     */
+    testCaseTitle?: string;
+    /**
+     * Test plan title
+     * @type {string}
+     * @memberof Activity
+     */
+    testPlanTitle?: string;
+    /**
+     *
+     * @type {ProjectMini}
+     * @memberof Activity
+     */
+    project?: ProjectMini;
+    /**
+     * Activity Type
+     * @type {string}
+     * @memberof Activity
+     */
+    activityType: ActivityActivityTypeEnum;
+    /**
+     *
+     * @type {User}
+     * @memberof Activity
+     */
+    user: User;
+    /**
+     * Time when the activity was performed
+     * @type {string}
+     * @memberof Activity
+     */
+    createdAt?: string;
+    /**
+     * Time when the activity was performed
+     * @type {string}
+     * @memberof Activity
+     */
+    updatedAt?: string;
+}
+/**
+ * @export
+ */
+export declare const ActivityActivityTypeEnum: {
+    readonly Add: "add";
+    readonly Edit: "edit";
+    readonly Delete: "delete";
+    readonly Publish: "publish";
+    readonly Run: "run";
+    readonly StatusChange: "status_change";
+    readonly TestcaseStatusChange: "testcase_status_change";
+    readonly Archive: "archive";
+    readonly Reopen: "reopen";
+    readonly FinishedRun: "finished_run";
+    readonly AssigneeChange: "assignee_change";
+    readonly Comment: "comment";
+};
+export type ActivityActivityTypeEnum = typeof ActivityActivityTypeEnum[keyof typeof ActivityActivityTypeEnum];
+/**
+ * Check if a given object implements the Activity interface.
+ */
+export declare function instanceOfActivity(value: object): value is Activity;
+export declare function ActivityFromJSON(json: any): Activity;
+export declare function ActivityFromJSONTyped(json: any, ignoreDiscriminator: boolean): Activity;
+export declare function ActivityToJSON(json: any): Activity;
+export declare function ActivityToJSONTyped(value?: Activity | null, ignoreDiscriminator?: boolean): any;

package/dist/models/Activity.js

@@ -0,0 +1,96 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * TC API
+ * TestCollab is a test management tool that helps development teams carry out testing effectively and avoid failures. # Introduction This is an API documentation for TestCollab 2.   # Authentication TestCollab supports two forms of authentication:   - An <b>API token</b> is required to make API calls. The token can be generated from user\'s profile; to obtain it login to your TestCollab account and go to [\'My Profile Settings\'](https://testcollab.io/my_profile) and switch to API Token tab. Click on \"Generate new API token\", Once the token is generated it can be sent as a query parameter for the API calls made - https://api.testcollab.io/projects?token=<generated-API-token>    - <b>Bearer authentication</b> (also called token authentication) is an HTTP authentication scheme that involves security tokens called bearer tokens. You can generate bearer auth token using [Login](#operation/login) API.     Send this token as the Authorization header while making requests to protected resources:     `Authorization: Bearer <token>`    For making API calls, we recommend using the <b>API token</b> generated from user profile page as it won\'t affect the on-going user session and will be available until it is revoked by the user who generated it.      # Error Handling Error responses   - `Not Found` - Error is sent when requested resource is not available.   - `Unauthorized - invalid token` - Error is sent when API token sent with the request is invalid or revoked. Error contains status code 401        - `Forbidden` - Error is sent when logged in user is not part of the company, project or his role does not allow to complete given action. Response consist of 403 status code and more information is given in error message.
+ *
+ * The version of the OpenAPI document: 2.3.1
+ * Contact: support@testcollab.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ActivityActivityTypeEnum = void 0;
+exports.instanceOfActivity = instanceOfActivity;
+exports.ActivityFromJSON = ActivityFromJSON;
+exports.ActivityFromJSONTyped = ActivityFromJSONTyped;
+exports.ActivityToJSON = ActivityToJSON;
+exports.ActivityToJSONTyped = ActivityToJSONTyped;
+const ProjectMini_1 = require("./ProjectMini");
+const User_1 = require("./User");
+/**
+ * @export
+ */
+exports.ActivityActivityTypeEnum = {
+    Add: 'add',
+    Edit: 'edit',
+    Delete: 'delete',
+    Publish: 'publish',
+    Run: 'run',
+    StatusChange: 'status_change',
+    TestcaseStatusChange: 'testcase_status_change',
+    Archive: 'archive',
+    Reopen: 'reopen',
+    FinishedRun: 'finished_run',
+    AssigneeChange: 'assignee_change',
+    Comment: 'comment'
+};
+/**
+ * Check if a given object implements the Activity interface.
+ */
+function instanceOfActivity(value) {
+    if (!('entity' in value) || value['entity'] === undefined)
+        return false;
+    if (!('entityId' in value) || value['entityId'] === undefined)
+        return false;
+    if (!('entityTitle' in value) || value['entityTitle'] === undefined)
+        return false;
+    if (!('activityType' in value) || value['activityType'] === undefined)
+        return false;
+    if (!('user' in value) || value['user'] === undefined)
+        return false;
+    return true;
+}
+function ActivityFromJSON(json) {
+    return ActivityFromJSONTyped(json, false);
+}
+function ActivityFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'entity': json['entity'],
+        'entityId': json['entity_id'],
+        'entityTitle': json['entity_title'],
+        'testCaseTitle': json['test_case_title'] == null ? undefined : json['test_case_title'],
+        'testPlanTitle': json['test_plan_title'] == null ? undefined : json['test_plan_title'],
+        'project': json['project'] == null ? undefined : (0, ProjectMini_1.ProjectMiniFromJSON)(json['project']),
+        'activityType': json['activity_type'],
+        'user': (0, User_1.UserFromJSON)(json['user']),
+        'createdAt': json['created_at'] == null ? undefined : json['created_at'],
+        'updatedAt': json['updated_at'] == null ? undefined : json['updated_at'],
+    };
+}
+function ActivityToJSON(json) {
+    return ActivityToJSONTyped(json, false);
+}
+function ActivityToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'entity': value['entity'],
+        'entity_id': value['entityId'],
+        'entity_title': value['entityTitle'],
+        'test_case_title': value['testCaseTitle'],
+        'test_plan_title': value['testPlanTitle'],
+        'project': (0, ProjectMini_1.ProjectMiniToJSON)(value['project']),
+        'activity_type': value['activityType'],
+        'user': (0, User_1.UserToJSON)(value['user']),
+        'created_at': value['createdAt'],
+        'updated_at': value['updatedAt'],
+    };
+}

package/dist/models/AddNewFolderPayload.d.ts

@@ -0,0 +1,38 @@
+/**
+ * TC API
+ * TestCollab is a test management tool that helps development teams carry out testing effectively and avoid failures. # Introduction This is an API documentation for TestCollab 2.   # Authentication TestCollab supports two forms of authentication:   - An <b>API token</b> is required to make API calls. The token can be generated from user\'s profile; to obtain it login to your TestCollab account and go to [\'My Profile Settings\'](https://testcollab.io/my_profile) and switch to API Token tab. Click on \"Generate new API token\", Once the token is generated it can be sent as a query parameter for the API calls made - https://api.testcollab.io/projects?token=<generated-API-token>    - <b>Bearer authentication</b> (also called token authentication) is an HTTP authentication scheme that involves security tokens called bearer tokens. You can generate bearer auth token using [Login](#operation/login) API.     Send this token as the Authorization header while making requests to protected resources:     `Authorization: Bearer <token>`    For making API calls, we recommend using the <b>API token</b> generated from user profile page as it won\'t affect the on-going user session and will be available until it is revoked by the user who generated it.      # Error Handling Error responses   - `Not Found` - Error is sent when requested resource is not available.   - `Unauthorized - invalid token` - Error is sent when API token sent with the request is invalid or revoked. Error contains status code 401        - `Forbidden` - Error is sent when logged in user is not part of the company, project or his role does not allow to complete given action. Response consist of 403 status code and more information is given in error message.
+ *
+ * The version of the OpenAPI document: 2.3.1
+ * Contact: support@testcollab.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ *
+ * @export
+ * @interface AddNewFolderPayload
+ */
+export interface AddNewFolderPayload {
+    /**
+     *
+     * @type {string}
+     * @memberof AddNewFolderPayload
+     */
+    title: string;
+    /**
+     *
+     * @type {number}
+     * @memberof AddNewFolderPayload
+     */
+    parentId: number;
+}
+/**
+ * Check if a given object implements the AddNewFolderPayload interface.
+ */
+export declare function instanceOfAddNewFolderPayload(value: object): value is AddNewFolderPayload;
+export declare function AddNewFolderPayloadFromJSON(json: any): AddNewFolderPayload;
+export declare function AddNewFolderPayloadFromJSONTyped(json: any, ignoreDiscriminator: boolean): AddNewFolderPayload;
+export declare function AddNewFolderPayloadToJSON(json: any): AddNewFolderPayload;
+export declare function AddNewFolderPayloadToJSONTyped(value?: AddNewFolderPayload | null, ignoreDiscriminator?: boolean): any;