@orchestraworks/cli 0.5.4 → 0.5.7

package/node_modules/@orchestraworks/client/dist/esm/apis/{GroupsApi.js → TeamMembershipsApi.js}

@@ -21,21 +21,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import * as runtime from '../runtime';
-import { CreateGroupRequestToJSON, } from '../models/CreateGroupRequest';
-import { GroupFromJSON, } from '../models/Group';
-import { PageGroupSummaryFromJSON, } from '../models/PageGroupSummary';
-import { UpdateGroupRequestToJSON, } from '../models/UpdateGroupRequest';
+import { CreateTeamMembershipRequestToJSON, } from '../models/CreateTeamMembershipRequest';
+import { PageTeamMembershipFromJSON, } from '../models/PageTeamMembership';
+import { TeamMembershipFromJSON, } from '../models/TeamMembership';
+import { UpdateTeamMembershipRequestToJSON, } from '../models/UpdateTeamMembershipRequest';
 /**
  *
  */
-export class GroupsApi extends runtime.BaseAPI {
+export class TeamMembershipsApi extends runtime.BaseAPI {
     /**
-     * Creates request options for createGroup without sending the request
+     * Creates request options for createTeamMembership without sending the request
      */
-    createGroupRequestOpts(requestParameters) {
+    createTeamMembershipRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (requestParameters['createGroupRequest'] == null) {
-                throw new runtime.RequiredError('createGroupRequest', 'Required parameter "createGroupRequest" was null or undefined when calling createGroup().');
+            if (requestParameters['createTeamMembershipRequest'] == null) {
+                throw new runtime.RequiredError('createTeamMembershipRequest', 'Required parameter "createTeamMembershipRequest" was null or undefined when calling createTeamMembership().');
             }
             const queryParameters = {};
             const headerParameters = {};
@@ -50,40 +50,40 @@ export class GroupsApi extends runtime.BaseAPI {
                     headerParameters["Authorization"] = `Bearer ${tokenString}`;
                 }
             }
-            let urlPath = `/groups`;
+            let urlPath = `/team-memberships`;
             return {
                 path: urlPath,
                 method: 'POST',
                 headers: headerParameters,
                 query: queryParameters,
-                body: CreateGroupRequestToJSON(requestParameters['createGroupRequest']),
+                body: CreateTeamMembershipRequestToJSON(requestParameters['createTeamMembershipRequest']),
             };
         });
     }
     /**
      */
-    createGroupRaw(requestParameters, initOverrides) {
+    createTeamMembershipRaw(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const requestOptions = yield this.createGroupRequestOpts(requestParameters);
+            const requestOptions = yield this.createTeamMembershipRequestOpts(requestParameters);
             const response = yield this.request(requestOptions, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => GroupFromJSON(jsonValue));
+            return new runtime.JSONApiResponse(response, (jsonValue) => TeamMembershipFromJSON(jsonValue));
         });
     }
     /**
      */
-    createGroup(requestParameters, initOverrides) {
+    createTeamMembership(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.createGroupRaw(requestParameters, initOverrides);
+            const response = yield this.createTeamMembershipRaw(requestParameters, initOverrides);
             return yield response.value();
         });
     }
     /**
-     * Creates request options for deleteGroup without sending the request
+     * Creates request options for deleteTeamMembership without sending the request
      */
-    deleteGroupRequestOpts(requestParameters) {
+    deleteTeamMembershipRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['id'] == null) {
-                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteGroup().');
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteTeamMembership().');
             }
             const queryParameters = {};
             const headerParameters = {};
@@ -97,7 +97,7 @@ export class GroupsApi extends runtime.BaseAPI {
                     headerParameters["Authorization"] = `Bearer ${tokenString}`;
                 }
             }
-            let urlPath = `/groups/{id}`;
+            let urlPath = `/team-memberships/{id}`;
             urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
             return {
                 path: urlPath,
@@ -109,27 +109,27 @@ export class GroupsApi extends runtime.BaseAPI {
     }
     /**
      */
-    deleteGroupRaw(requestParameters, initOverrides) {
+    deleteTeamMembershipRaw(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const requestOptions = yield this.deleteGroupRequestOpts(requestParameters);
+            const requestOptions = yield this.deleteTeamMembershipRequestOpts(requestParameters);
             const response = yield this.request(requestOptions, initOverrides);
             return new runtime.VoidApiResponse(response);
         });
     }
     /**
      */
-    deleteGroup(requestParameters, initOverrides) {
+    deleteTeamMembership(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.deleteGroupRaw(requestParameters, initOverrides);
+            yield this.deleteTeamMembershipRaw(requestParameters, initOverrides);
         });
     }
     /**
-     * Creates request options for getGroup without sending the request
+     * Creates request options for getTeamMembership without sending the request
      */
-    getGroupRequestOpts(requestParameters) {
+    getTeamMembershipRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['id'] == null) {
-                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getGroup().');
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getTeamMembership().');
             }
             const queryParameters = {};
             const headerParameters = {};
@@ -143,7 +143,7 @@ export class GroupsApi extends runtime.BaseAPI {
                     headerParameters["Authorization"] = `Bearer ${tokenString}`;
                 }
             }
-            let urlPath = `/groups/{id}`;
+            let urlPath = `/team-memberships/{id}`;
             urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
             return {
                 path: urlPath,
@@ -155,32 +155,35 @@ export class GroupsApi extends runtime.BaseAPI {
     }
     /**
      */
-    getGroupRaw(requestParameters, initOverrides) {
+    getTeamMembershipRaw(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const requestOptions = yield this.getGroupRequestOpts(requestParameters);
+            const requestOptions = yield this.getTeamMembershipRequestOpts(requestParameters);
             const response = yield this.request(requestOptions, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => GroupFromJSON(jsonValue));
+            return new runtime.JSONApiResponse(response, (jsonValue) => TeamMembershipFromJSON(jsonValue));
         });
     }
     /**
      */
-    getGroup(requestParameters, initOverrides) {
+    getTeamMembership(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.getGroupRaw(requestParameters, initOverrides);
+            const response = yield this.getTeamMembershipRaw(requestParameters, initOverrides);
             return yield response.value();
         });
     }
     /**
-     * Creates request options for listGroups without sending the request
+     * Creates request options for listTeamMemberships without sending the request
      */
-    listGroupsRequestOpts(requestParameters) {
+    listTeamMembershipsRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             const queryParameters = {};
-            if (requestParameters['q'] != null) {
-                queryParameters['q'] = requestParameters['q'];
+            if (requestParameters['teamId'] != null) {
+                queryParameters['teamId'] = requestParameters['teamId'];
             }
-            if (requestParameters['member'] != null) {
-                queryParameters['member'] = requestParameters['member'];
+            if (requestParameters['membershipId'] != null) {
+                queryParameters['membershipId'] = requestParameters['membershipId'];
+            }
+            if (requestParameters['allTeams'] != null) {
+                queryParameters['allTeams'] = requestParameters['allTeams'];
             }
             if (requestParameters['page'] != null) {
                 queryParameters['page'] = requestParameters['page'];
@@ -199,7 +202,7 @@ export class GroupsApi extends runtime.BaseAPI {
                     headerParameters["Authorization"] = `Bearer ${tokenString}`;
                 }
             }
-            let urlPath = `/groups`;
+            let urlPath = `/team-memberships`;
             return {
                 path: urlPath,
                 method: 'GET',
@@ -210,31 +213,31 @@ export class GroupsApi extends runtime.BaseAPI {
     }
     /**
      */
-    listGroupsRaw(requestParameters, initOverrides) {
+    listTeamMembershipsRaw(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const requestOptions = yield this.listGroupsRequestOpts(requestParameters);
+            const requestOptions = yield this.listTeamMembershipsRequestOpts(requestParameters);
             const response = yield this.request(requestOptions, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => PageGroupSummaryFromJSON(jsonValue));
+            return new runtime.JSONApiResponse(response, (jsonValue) => PageTeamMembershipFromJSON(jsonValue));
         });
     }
     /**
      */
-    listGroups() {
+    listTeamMemberships() {
         return __awaiter(this, arguments, void 0, function* (requestParameters = {}, initOverrides) {
-            const response = yield this.listGroupsRaw(requestParameters, initOverrides);
+            const response = yield this.listTeamMembershipsRaw(requestParameters, initOverrides);
             return yield response.value();
         });
     }
     /**
-     * Creates request options for updateGroup without sending the request
+     * Creates request options for updateTeamMembership without sending the request
      */
-    updateGroupRequestOpts(requestParameters) {
+    updateTeamMembershipRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['id'] == null) {
-                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling updateGroup().');
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling updateTeamMembership().');
             }
-            if (requestParameters['updateGroupRequest'] == null) {
-                throw new runtime.RequiredError('updateGroupRequest', 'Required parameter "updateGroupRequest" was null or undefined when calling updateGroup().');
+            if (requestParameters['updateTeamMembershipRequest'] == null) {
+                throw new runtime.RequiredError('updateTeamMembershipRequest', 'Required parameter "updateTeamMembershipRequest" was null or undefined when calling updateTeamMembership().');
             }
             const queryParameters = {};
             const headerParameters = {};
@@ -249,31 +252,31 @@ export class GroupsApi extends runtime.BaseAPI {
                     headerParameters["Authorization"] = `Bearer ${tokenString}`;
                 }
             }
-            let urlPath = `/groups/{id}`;
+            let urlPath = `/team-memberships/{id}`;
             urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
             return {
                 path: urlPath,
                 method: 'PATCH',
                 headers: headerParameters,
                 query: queryParameters,
-                body: UpdateGroupRequestToJSON(requestParameters['updateGroupRequest']),
+                body: UpdateTeamMembershipRequestToJSON(requestParameters['updateTeamMembershipRequest']),
             };
         });
     }
     /**
      */
-    updateGroupRaw(requestParameters, initOverrides) {
+    updateTeamMembershipRaw(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const requestOptions = yield this.updateGroupRequestOpts(requestParameters);
+            const requestOptions = yield this.updateTeamMembershipRequestOpts(requestParameters);
             const response = yield this.request(requestOptions, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => GroupFromJSON(jsonValue));
+            return new runtime.JSONApiResponse(response, (jsonValue) => TeamMembershipFromJSON(jsonValue));
         });
     }
     /**
      */
-    updateGroup(requestParameters, initOverrides) {
+    updateTeamMembership(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.updateGroupRaw(requestParameters, initOverrides);
+            const response = yield this.updateTeamMembershipRaw(requestParameters, initOverrides);
             return yield response.value();
         });
     }

package/node_modules/@orchestraworks/client/dist/esm/apis/TeamsApi.d.ts

@@ -0,0 +1,93 @@
+/**
+ * Orchestra platform API
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: 0.1.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+import * as runtime from '../runtime';
+import { type CreateTeamRequest } from '../models/CreateTeamRequest';
+import { type PageTeam } from '../models/PageTeam';
+import { type Team } from '../models/Team';
+import { type UpdateTeamRequest } from '../models/UpdateTeamRequest';
+export interface CreateTeamOperationRequest {
+    createTeamRequest: CreateTeamRequest;
+    xOrganizationId?: string;
+}
+export interface DeleteTeamRequest {
+    id: string;
+    xOrganizationId?: string;
+}
+export interface GetTeamRequest {
+    id: string;
+    xOrganizationId?: string;
+}
+export interface ListTeamsRequest {
+    page?: number;
+    limit?: number;
+    xOrganizationId?: string;
+}
+export interface UpdateTeamOperationRequest {
+    id: string;
+    updateTeamRequest: UpdateTeamRequest;
+    xOrganizationId?: string;
+}
+/**
+ *
+ */
+export declare class TeamsApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for createTeam without sending the request
+     */
+    createTeamRequestOpts(requestParameters: CreateTeamOperationRequest): Promise<runtime.RequestOpts>;
+    /**
+     */
+    createTeamRaw(requestParameters: CreateTeamOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Team>>;
+    /**
+     */
+    createTeam(requestParameters: CreateTeamOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Team>;
+    /**
+     * Creates request options for deleteTeam without sending the request
+     */
+    deleteTeamRequestOpts(requestParameters: DeleteTeamRequest): Promise<runtime.RequestOpts>;
+    /**
+     */
+    deleteTeamRaw(requestParameters: DeleteTeamRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    /**
+     */
+    deleteTeam(requestParameters: DeleteTeamRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    /**
+     * Creates request options for getTeam without sending the request
+     */
+    getTeamRequestOpts(requestParameters: GetTeamRequest): Promise<runtime.RequestOpts>;
+    /**
+     */
+    getTeamRaw(requestParameters: GetTeamRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Team>>;
+    /**
+     */
+    getTeam(requestParameters: GetTeamRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Team>;
+    /**
+     * Creates request options for listTeams without sending the request
+     */
+    listTeamsRequestOpts(requestParameters: ListTeamsRequest): Promise<runtime.RequestOpts>;
+    /**
+     */
+    listTeamsRaw(requestParameters: ListTeamsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PageTeam>>;
+    /**
+     */
+    listTeams(requestParameters?: ListTeamsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PageTeam>;
+    /**
+     * Creates request options for updateTeam without sending the request
+     */
+    updateTeamRequestOpts(requestParameters: UpdateTeamOperationRequest): Promise<runtime.RequestOpts>;
+    /**
+     */
+    updateTeamRaw(requestParameters: UpdateTeamOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Team>>;
+    /**
+     */
+    updateTeam(requestParameters: UpdateTeamOperationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Team>;
+}

package/node_modules/@orchestraworks/client/dist/esm/apis/{ProjectsApi.js → TeamsApi.js}

@@ -21,21 +21,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import * as runtime from '../runtime';
-import { CreateProjectRequestToJSON, } from '../models/CreateProjectRequest';
-import { PageProjectFromJSON, } from '../models/PageProject';
-import { ProjectFromJSON, } from '../models/Project';
-import { UpdateProjectRequestToJSON, } from '../models/UpdateProjectRequest';
+import { CreateTeamRequestToJSON, } from '../models/CreateTeamRequest';
+import { PageTeamFromJSON, } from '../models/PageTeam';
+import { TeamFromJSON, } from '../models/Team';
+import { UpdateTeamRequestToJSON, } from '../models/UpdateTeamRequest';
 /**
  *
  */
-export class ProjectsApi extends runtime.BaseAPI {
+export class TeamsApi extends runtime.BaseAPI {
     /**
-     * Creates request options for createProject without sending the request
+     * Creates request options for createTeam without sending the request
      */
-    createProjectRequestOpts(requestParameters) {
+    createTeamRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (requestParameters['createProjectRequest'] == null) {
-                throw new runtime.RequiredError('createProjectRequest', 'Required parameter "createProjectRequest" was null or undefined when calling createProject().');
+            if (requestParameters['createTeamRequest'] == null) {
+                throw new runtime.RequiredError('createTeamRequest', 'Required parameter "createTeamRequest" was null or undefined when calling createTeam().');
             }
             const queryParameters = {};
             const headerParameters = {};
@@ -50,40 +50,40 @@ export class ProjectsApi extends runtime.BaseAPI {
                     headerParameters["Authorization"] = `Bearer ${tokenString}`;
                 }
             }
-            let urlPath = `/projects`;
+            let urlPath = `/teams`;
             return {
                 path: urlPath,
                 method: 'POST',
                 headers: headerParameters,
                 query: queryParameters,
-                body: CreateProjectRequestToJSON(requestParameters['createProjectRequest']),
+                body: CreateTeamRequestToJSON(requestParameters['createTeamRequest']),
             };
         });
     }
     /**
      */
-    createProjectRaw(requestParameters, initOverrides) {
+    createTeamRaw(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const requestOptions = yield this.createProjectRequestOpts(requestParameters);
+            const requestOptions = yield this.createTeamRequestOpts(requestParameters);
             const response = yield this.request(requestOptions, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => ProjectFromJSON(jsonValue));
+            return new runtime.JSONApiResponse(response, (jsonValue) => TeamFromJSON(jsonValue));
         });
     }
     /**
      */
-    createProject(requestParameters, initOverrides) {
+    createTeam(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.createProjectRaw(requestParameters, initOverrides);
+            const response = yield this.createTeamRaw(requestParameters, initOverrides);
             return yield response.value();
         });
     }
     /**
-     * Creates request options for deleteProject without sending the request
+     * Creates request options for deleteTeam without sending the request
      */
-    deleteProjectRequestOpts(requestParameters) {
+    deleteTeamRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['id'] == null) {
-                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteProject().');
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteTeam().');
             }
             const queryParameters = {};
             const headerParameters = {};
@@ -97,7 +97,7 @@ export class ProjectsApi extends runtime.BaseAPI {
                     headerParameters["Authorization"] = `Bearer ${tokenString}`;
                 }
             }
-            let urlPath = `/projects/{id}`;
+            let urlPath = `/teams/{id}`;
             urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
             return {
                 path: urlPath,
@@ -109,27 +109,27 @@ export class ProjectsApi extends runtime.BaseAPI {
     }
     /**
      */
-    deleteProjectRaw(requestParameters, initOverrides) {
+    deleteTeamRaw(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const requestOptions = yield this.deleteProjectRequestOpts(requestParameters);
+            const requestOptions = yield this.deleteTeamRequestOpts(requestParameters);
             const response = yield this.request(requestOptions, initOverrides);
             return new runtime.VoidApiResponse(response);
         });
     }
     /**
      */
-    deleteProject(requestParameters, initOverrides) {
+    deleteTeam(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.deleteProjectRaw(requestParameters, initOverrides);
+            yield this.deleteTeamRaw(requestParameters, initOverrides);
         });
     }
     /**
-     * Creates request options for getProject without sending the request
+     * Creates request options for getTeam without sending the request
      */
-    getProjectRequestOpts(requestParameters) {
+    getTeamRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['id'] == null) {
-                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getProject().');
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getTeam().');
             }
             const queryParameters = {};
             const headerParameters = {};
@@ -143,7 +143,7 @@ export class ProjectsApi extends runtime.BaseAPI {
                     headerParameters["Authorization"] = `Bearer ${tokenString}`;
                 }
             }
-            let urlPath = `/projects/{id}`;
+            let urlPath = `/teams/{id}`;
             urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
             return {
                 path: urlPath,
@@ -155,25 +155,25 @@ export class ProjectsApi extends runtime.BaseAPI {
     }
     /**
      */
-    getProjectRaw(requestParameters, initOverrides) {
+    getTeamRaw(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const requestOptions = yield this.getProjectRequestOpts(requestParameters);
+            const requestOptions = yield this.getTeamRequestOpts(requestParameters);
             const response = yield this.request(requestOptions, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => ProjectFromJSON(jsonValue));
+            return new runtime.JSONApiResponse(response, (jsonValue) => TeamFromJSON(jsonValue));
         });
     }
     /**
      */
-    getProject(requestParameters, initOverrides) {
+    getTeam(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.getProjectRaw(requestParameters, initOverrides);
+            const response = yield this.getTeamRaw(requestParameters, initOverrides);
             return yield response.value();
         });
     }
     /**
-     * Creates request options for listProjects without sending the request
+     * Creates request options for listTeams without sending the request
      */
-    listProjectsRequestOpts(requestParameters) {
+    listTeamsRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             const queryParameters = {};
             if (requestParameters['page'] != null) {
@@ -193,7 +193,7 @@ export class ProjectsApi extends runtime.BaseAPI {
                     headerParameters["Authorization"] = `Bearer ${tokenString}`;
                 }
             }
-            let urlPath = `/projects`;
+            let urlPath = `/teams`;
             return {
                 path: urlPath,
                 method: 'GET',
@@ -204,31 +204,31 @@ export class ProjectsApi extends runtime.BaseAPI {
     }
     /**
      */
-    listProjectsRaw(requestParameters, initOverrides) {
+    listTeamsRaw(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const requestOptions = yield this.listProjectsRequestOpts(requestParameters);
+            const requestOptions = yield this.listTeamsRequestOpts(requestParameters);
             const response = yield this.request(requestOptions, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => PageProjectFromJSON(jsonValue));
+            return new runtime.JSONApiResponse(response, (jsonValue) => PageTeamFromJSON(jsonValue));
         });
     }
     /**
      */
-    listProjects() {
+    listTeams() {
         return __awaiter(this, arguments, void 0, function* (requestParameters = {}, initOverrides) {
-            const response = yield this.listProjectsRaw(requestParameters, initOverrides);
+            const response = yield this.listTeamsRaw(requestParameters, initOverrides);
             return yield response.value();
         });
     }
     /**
-     * Creates request options for updateProject without sending the request
+     * Creates request options for updateTeam without sending the request
      */
-    updateProjectRequestOpts(requestParameters) {
+    updateTeamRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
             if (requestParameters['id'] == null) {
-                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling updateProject().');
+                throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling updateTeam().');
             }
-            if (requestParameters['updateProjectRequest'] == null) {
-                throw new runtime.RequiredError('updateProjectRequest', 'Required parameter "updateProjectRequest" was null or undefined when calling updateProject().');
+            if (requestParameters['updateTeamRequest'] == null) {
+                throw new runtime.RequiredError('updateTeamRequest', 'Required parameter "updateTeamRequest" was null or undefined when calling updateTeam().');
             }
             const queryParameters = {};
             const headerParameters = {};
@@ -243,31 +243,31 @@ export class ProjectsApi extends runtime.BaseAPI {
                     headerParameters["Authorization"] = `Bearer ${tokenString}`;
                 }
             }
-            let urlPath = `/projects/{id}`;
+            let urlPath = `/teams/{id}`;
             urlPath = urlPath.replace('{id}', encodeURIComponent(String(requestParameters['id'])));
             return {
                 path: urlPath,
                 method: 'PATCH',
                 headers: headerParameters,
                 query: queryParameters,
-                body: UpdateProjectRequestToJSON(requestParameters['updateProjectRequest']),
+                body: UpdateTeamRequestToJSON(requestParameters['updateTeamRequest']),
             };
         });
     }
     /**
      */
-    updateProjectRaw(requestParameters, initOverrides) {
+    updateTeamRaw(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const requestOptions = yield this.updateProjectRequestOpts(requestParameters);
+            const requestOptions = yield this.updateTeamRequestOpts(requestParameters);
             const response = yield this.request(requestOptions, initOverrides);
-            return new runtime.JSONApiResponse(response, (jsonValue) => ProjectFromJSON(jsonValue));
+            return new runtime.JSONApiResponse(response, (jsonValue) => TeamFromJSON(jsonValue));
         });
     }
     /**
      */
-    updateProject(requestParameters, initOverrides) {
+    updateTeam(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const response = yield this.updateProjectRaw(requestParameters, initOverrides);
+            const response = yield this.updateTeamRaw(requestParameters, initOverrides);
             return yield response.value();
         });
     }

package/node_modules/@orchestraworks/client/dist/esm/apis/TriggersApi.d.ts

@@ -31,7 +31,7 @@ export interface ListTriggersRequest {
     limit?: number;
     status?: ListTriggersStatusEnum;
     receiverKind?: ListTriggersReceiverKindEnum;
-    projectId?: string;
+    teamId?: string;
     connection?: string;
     event?: string;
     target?: string;

package/node_modules/@orchestraworks/client/dist/esm/apis/TriggersApi.js

@@ -188,8 +188,8 @@ export class TriggersApi extends runtime.BaseAPI {
             if (requestParameters['receiverKind'] != null) {
                 queryParameters['receiverKind'] = requestParameters['receiverKind'];
             }
-            if (requestParameters['projectId'] != null) {
-                queryParameters['projectId'] = requestParameters['projectId'];
+            if (requestParameters['teamId'] != null) {
+                queryParameters['teamId'] = requestParameters['teamId'];
             }
             if (requestParameters['connection'] != null) {
                 queryParameters['connection'] = requestParameters['connection'];