@managespace/sdk 0.0.106 → 0.0.108

package/src/generated/models/{task-response.ts → task.ts}

@@ -13,41 +13,48 @@
  */
 
 import { mapValues } from '../runtime';
-import type { UserResponse } from './user-response';
+import type { Site } from './site';
 import {
-    UserResponseFromJSON,
-    UserResponseFromJSONTyped,
-    UserResponseToJSON,
-    UserResponseToJSONTyped,
-} from './user-response';
-import type { TaskTemplateResponse } from './task-template-response';
+    SiteFromJSON,
+    SiteFromJSONTyped,
+    SiteToJSON,
+    SiteToJSONTyped,
+} from './site';
+import type { TaskTemplate } from './task-template';
 import {
-    TaskTemplateResponseFromJSON,
-    TaskTemplateResponseFromJSONTyped,
-    TaskTemplateResponseToJSON,
-    TaskTemplateResponseToJSONTyped,
-} from './task-template-response';
-import type { OrgResponse } from './org-response';
+    TaskTemplateFromJSON,
+    TaskTemplateFromJSONTyped,
+    TaskTemplateToJSON,
+    TaskTemplateToJSONTyped,
+} from './task-template';
+import type { User } from './user';
 import {
-    OrgResponseFromJSON,
-    OrgResponseFromJSONTyped,
-    OrgResponseToJSON,
-    OrgResponseToJSONTyped,
-} from './org-response';
-import type { ChecklistResponse } from './checklist-response';
+    UserFromJSON,
+    UserFromJSONTyped,
+    UserToJSON,
+    UserToJSONTyped,
+} from './user';
+import type { ExtensibilityFunctionInstance } from './extensibility-function-instance';
 import {
-    ChecklistResponseFromJSON,
-    ChecklistResponseFromJSONTyped,
-    ChecklistResponseToJSON,
-    ChecklistResponseToJSONTyped,
-} from './checklist-response';
-import type { SiteResponse } from './site-response';
+    ExtensibilityFunctionInstanceFromJSON,
+    ExtensibilityFunctionInstanceFromJSONTyped,
+    ExtensibilityFunctionInstanceToJSON,
+    ExtensibilityFunctionInstanceToJSONTyped,
+} from './extensibility-function-instance';
+import type { Org } from './org';
 import {
-    SiteResponseFromJSON,
-    SiteResponseFromJSONTyped,
-    SiteResponseToJSON,
-    SiteResponseToJSONTyped,
-} from './site-response';
+    OrgFromJSON,
+    OrgFromJSONTyped,
+    OrgToJSON,
+    OrgToJSONTyped,
+} from './org';
+import type { Checklist } from './checklist';
+import {
+    ChecklistFromJSON,
+    ChecklistFromJSONTyped,
+    ChecklistToJSON,
+    ChecklistToJSONTyped,
+} from './checklist';
 import type { TaskCompletionStatus } from './task-completion-status';
 import {
     TaskCompletionStatusFromJSON,
@@ -55,144 +62,137 @@ import {
     TaskCompletionStatusToJSON,
     TaskCompletionStatusToJSONTyped,
 } from './task-completion-status';
-import type { ExtensibilityFunctionInstanceResponse } from './extensibility-function-instance-response';
-import {
-    ExtensibilityFunctionInstanceResponseFromJSON,
-    ExtensibilityFunctionInstanceResponseFromJSONTyped,
-    ExtensibilityFunctionInstanceResponseToJSON,
-    ExtensibilityFunctionInstanceResponseToJSONTyped,
-} from './extensibility-function-instance-response';
 
 /**
  * 
  * @export
- * @interface TaskResponse
+ * @interface Task
  */
-export interface TaskResponse {
+export interface Task {
     /**
      * Task ID
      * @type {string}
-     * @memberof TaskResponse
+     * @memberof Task
      */
     id: string;
     /**
      * 
-     * @type {OrgResponse}
-     * @memberof TaskResponse
+     * @type {Org}
+     * @memberof Task
      */
-    org?: OrgResponse;
+    org?: Org;
     /**
      * 
      * @type {string}
-     * @memberof TaskResponse
+     * @memberof Task
      */
     orgId: string;
     /**
      * 
-     * @type {SiteResponse}
-     * @memberof TaskResponse
+     * @type {Site}
+     * @memberof Task
      */
-    site?: SiteResponse;
+    site?: Site;
     /**
      * 
      * @type {string}
-     * @memberof TaskResponse
+     * @memberof Task
      */
     siteId: string;
     /**
      * Who created the note
-     * @type {UserResponse}
-     * @memberof TaskResponse
+     * @type {User}
+     * @memberof Task
      */
-    createdBy?: UserResponse;
+    createdBy?: User;
     /**
      * 
      * @type {string}
-     * @memberof TaskResponse
+     * @memberof Task
      */
     createdById: string;
     /**
      * 
-     * @type {ExtensibilityFunctionInstanceResponse}
-     * @memberof TaskResponse
+     * @type {ExtensibilityFunctionInstance}
+     * @memberof Task
      */
-    createdByExtensibilityFunctionInstance?: ExtensibilityFunctionInstanceResponse | null;
+    createdByExtensibilityFunctionInstance?: ExtensibilityFunctionInstance | null;
     /**
      * 
      * @type {string}
-     * @memberof TaskResponse
+     * @memberof Task
      */
     createdByExtensibilityFunctionInstanceId: string | null;
     /**
      * 
-     * @type {UserResponse}
-     * @memberof TaskResponse
+     * @type {User}
+     * @memberof Task
      */
-    assignedToUser?: UserResponse;
+    assignedToUser?: User;
     /**
      * 
      * @type {string}
-     * @memberof TaskResponse
+     * @memberof Task
      */
     assignedToUserId: string;
     /**
      * Name of Task
      * @type {string}
-     * @memberof TaskResponse
+     * @memberof Task
      */
     name: string;
     /**
      * Any relevant information for the task
      * @type {string}
-     * @memberof TaskResponse
+     * @memberof Task
      */
     description: string | null;
     /**
      * When the notification should be shown
      * @type {Date}
-     * @memberof TaskResponse
+     * @memberof Task
      */
     dueBy: Date;
     /**
      * 
      * @type {TaskCompletionStatus}
-     * @memberof TaskResponse
+     * @memberof Task
      */
     status: TaskCompletionStatus;
     /**
      * 
-     * @type {ChecklistResponse}
-     * @memberof TaskResponse
+     * @type {Checklist}
+     * @memberof Task
      */
-    checklist?: ChecklistResponse | null;
+    checklist?: Checklist | null;
     /**
      * 
      * @type {string}
-     * @memberof TaskResponse
+     * @memberof Task
      */
     checklistId: string | null;
     /**
      * 
-     * @type {TaskTemplateResponse}
-     * @memberof TaskResponse
+     * @type {TaskTemplate}
+     * @memberof Task
      */
-    taskTemplate?: TaskTemplateResponse | null;
+    taskTemplate?: TaskTemplate | null;
     /**
      * 
      * @type {string}
-     * @memberof TaskResponse
+     * @memberof Task
      */
     taskTemplateId: string | null;
     /**
      * 
-     * @type {UserResponse}
-     * @memberof TaskResponse
+     * @type {User}
+     * @memberof Task
      */
-    user?: UserResponse | null;
+    user?: User | null;
     /**
      * 
      * @type {string}
-     * @memberof TaskResponse
+     * @memberof Task
      */
     userId: string | null;
 }
@@ -200,9 +200,9 @@ export interface TaskResponse {
 
 
 /**
- * Check if a given object implements the TaskResponse interface.
+ * Check if a given object implements the Task interface.
  */
-export function instanceOfTaskResponse(value: object): value is TaskResponse {
+export function instanceOfTask(value: object): value is Task {
     if (!('id' in value) || value['id'] === undefined) return false;
     if (!('orgId' in value) || value['orgId'] === undefined) return false;
     if (!('siteId' in value) || value['siteId'] === undefined) return false;
@@ -219,45 +219,45 @@ export function instanceOfTaskResponse(value: object): value is TaskResponse {
     return true;
 }
 
-export function TaskResponseFromJSON(json: any): TaskResponse {
-    return TaskResponseFromJSONTyped(json, false);
+export function TaskFromJSON(json: any): Task {
+    return TaskFromJSONTyped(json, false);
 }
 
-export function TaskResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): TaskResponse {
+export function TaskFromJSONTyped(json: any, ignoreDiscriminator: boolean): Task {
     if (json == null) {
         return json;
     }
     return {
         
         'id': json['id'],
-        'org': json['org'] == null ? undefined : OrgResponseFromJSON(json['org']),
+        'org': json['org'] == null ? undefined : OrgFromJSON(json['org']),
         'orgId': json['orgId'],
-        'site': json['site'] == null ? undefined : SiteResponseFromJSON(json['site']),
+        'site': json['site'] == null ? undefined : SiteFromJSON(json['site']),
         'siteId': json['siteId'],
-        'createdBy': json['createdBy'] == null ? undefined : UserResponseFromJSON(json['createdBy']),
+        'createdBy': json['createdBy'] == null ? undefined : UserFromJSON(json['createdBy']),
         'createdById': json['createdById'],
-        'createdByExtensibilityFunctionInstance': json['createdByExtensibilityFunctionInstance'] == null ? undefined : ExtensibilityFunctionInstanceResponseFromJSON(json['createdByExtensibilityFunctionInstance']),
+        'createdByExtensibilityFunctionInstance': json['createdByExtensibilityFunctionInstance'] == null ? undefined : ExtensibilityFunctionInstanceFromJSON(json['createdByExtensibilityFunctionInstance']),
         'createdByExtensibilityFunctionInstanceId': json['createdByExtensibilityFunctionInstanceId'],
-        'assignedToUser': json['assignedToUser'] == null ? undefined : UserResponseFromJSON(json['assignedToUser']),
+        'assignedToUser': json['assignedToUser'] == null ? undefined : UserFromJSON(json['assignedToUser']),
         'assignedToUserId': json['assignedToUserId'],
         'name': json['name'],
         'description': json['description'],
         'dueBy': (new Date(json['dueBy'])),
         'status': TaskCompletionStatusFromJSON(json['status']),
-        'checklist': json['checklist'] == null ? undefined : ChecklistResponseFromJSON(json['checklist']),
+        'checklist': json['checklist'] == null ? undefined : ChecklistFromJSON(json['checklist']),
         'checklistId': json['checklistId'],
-        'taskTemplate': json['taskTemplate'] == null ? undefined : TaskTemplateResponseFromJSON(json['taskTemplate']),
+        'taskTemplate': json['taskTemplate'] == null ? undefined : TaskTemplateFromJSON(json['taskTemplate']),
         'taskTemplateId': json['taskTemplateId'],
-        'user': json['User'] == null ? undefined : UserResponseFromJSON(json['User']),
+        'user': json['User'] == null ? undefined : UserFromJSON(json['User']),
         'userId': json['userId'],
     };
 }
 
-export function TaskResponseToJSON(json: any): TaskResponse {
-    return TaskResponseToJSONTyped(json, false);
+export function TaskToJSON(json: any): Task {
+    return TaskToJSONTyped(json, false);
 }
 
-export function TaskResponseToJSONTyped(value?: TaskResponse | null, ignoreDiscriminator: boolean = false): any {
+export function TaskToJSONTyped(value?: Task | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }
@@ -265,25 +265,25 @@ export function TaskResponseToJSONTyped(value?: TaskResponse | null, ignoreDiscr
     return {
         
         'id': value['id'],
-        'org': OrgResponseToJSON(value['org']),
+        'org': OrgToJSON(value['org']),
         'orgId': value['orgId'],
-        'site': SiteResponseToJSON(value['site']),
+        'site': SiteToJSON(value['site']),
         'siteId': value['siteId'],
-        'createdBy': UserResponseToJSON(value['createdBy']),
+        'createdBy': UserToJSON(value['createdBy']),
         'createdById': value['createdById'],
-        'createdByExtensibilityFunctionInstance': ExtensibilityFunctionInstanceResponseToJSON(value['createdByExtensibilityFunctionInstance']),
+        'createdByExtensibilityFunctionInstance': ExtensibilityFunctionInstanceToJSON(value['createdByExtensibilityFunctionInstance']),
         'createdByExtensibilityFunctionInstanceId': value['createdByExtensibilityFunctionInstanceId'],
-        'assignedToUser': UserResponseToJSON(value['assignedToUser']),
+        'assignedToUser': UserToJSON(value['assignedToUser']),
         'assignedToUserId': value['assignedToUserId'],
         'name': value['name'],
         'description': value['description'],
         'dueBy': ((value['dueBy']).toISOString()),
         'status': TaskCompletionStatusToJSON(value['status']),
-        'checklist': ChecklistResponseToJSON(value['checklist']),
+        'checklist': ChecklistToJSON(value['checklist']),
         'checklistId': value['checklistId'],
-        'taskTemplate': TaskTemplateResponseToJSON(value['taskTemplate']),
+        'taskTemplate': TaskTemplateToJSON(value['taskTemplate']),
         'taskTemplateId': value['taskTemplateId'],
-        'User': UserResponseToJSON(value['user']),
+        'User': UserToJSON(value['user']),
         'userId': value['userId'],
     };
 }

package/src/generated/models/{tax-line-response.ts → tax-line.ts}

@@ -16,37 +16,37 @@ import { mapValues } from '../runtime';
 /**
  * 
  * @export
- * @interface TaxLineResponse
+ * @interface TaxLine
  */
-export interface TaxLineResponse {
+export interface TaxLine {
     /**
      * The name of the tax
      * @type {string}
-     * @memberof TaxLineResponse
+     * @memberof TaxLine
      */
     name: string;
     /**
      * The value of the tax
      * @type {string}
-     * @memberof TaxLineResponse
+     * @memberof TaxLine
      */
     value: string;
 }
 
 /**
- * Check if a given object implements the TaxLineResponse interface.
+ * Check if a given object implements the TaxLine interface.
  */
-export function instanceOfTaxLineResponse(value: object): value is TaxLineResponse {
+export function instanceOfTaxLine(value: object): value is TaxLine {
     if (!('name' in value) || value['name'] === undefined) return false;
     if (!('value' in value) || value['value'] === undefined) return false;
     return true;
 }
 
-export function TaxLineResponseFromJSON(json: any): TaxLineResponse {
-    return TaxLineResponseFromJSONTyped(json, false);
+export function TaxLineFromJSON(json: any): TaxLine {
+    return TaxLineFromJSONTyped(json, false);
 }
 
-export function TaxLineResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): TaxLineResponse {
+export function TaxLineFromJSONTyped(json: any, ignoreDiscriminator: boolean): TaxLine {
     if (json == null) {
         return json;
     }
@@ -57,11 +57,11 @@ export function TaxLineResponseFromJSONTyped(json: any, ignoreDiscriminator: boo
     };
 }
 
-export function TaxLineResponseToJSON(json: any): TaxLineResponse {
-    return TaxLineResponseToJSONTyped(json, false);
+export function TaxLineToJSON(json: any): TaxLine {
+    return TaxLineToJSONTyped(json, false);
 }
 
-export function TaxLineResponseToJSONTyped(value?: TaxLineResponse | null, ignoreDiscriminator: boolean = false): any {
+export function TaxLineToJSONTyped(value?: TaxLine | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }

package/src/generated/models/{template-response.ts → template.ts}

@@ -31,56 +31,56 @@ import {
 /**
  * 
  * @export
- * @interface TemplateResponse
+ * @interface Template
  */
-export interface TemplateResponse {
+export interface Template {
     /**
      * Name of your template.
      * @type {string}
-     * @memberof TemplateResponse
+     * @memberof Template
      */
     name: string;
     /**
      * The signers of the template
      * @type {Array<TemplateSigner>}
-     * @memberof TemplateResponse
+     * @memberof Template
      */
     signers?: Array<TemplateSigner>;
     /**
      * The fields of the template
      * @type {Array<TemplateField>}
-     * @memberof TemplateResponse
+     * @memberof Template
      */
     fields?: Array<TemplateField>;
     /**
      * Template ID
      * @type {string}
-     * @memberof TemplateResponse
+     * @memberof Template
      */
     id: string;
     /**
      * Template URL
      * @type {string}
-     * @memberof TemplateResponse
+     * @memberof Template
      */
     url: string;
 }
 
 /**
- * Check if a given object implements the TemplateResponse interface.
+ * Check if a given object implements the Template interface.
  */
-export function instanceOfTemplateResponse(value: object): value is TemplateResponse {
+export function instanceOfTemplate(value: object): value is Template {
     if (!('name' in value) || value['name'] === undefined) return false;
     if (!('id' in value) || value['id'] === undefined) return false;
     if (!('url' in value) || value['url'] === undefined) return false;
     return true;
 }
 
-export function TemplateResponseFromJSON(json: any): TemplateResponse {
-    return TemplateResponseFromJSONTyped(json, false);
+export function TemplateFromJSON(json: any): Template {
+    return TemplateFromJSONTyped(json, false);
 }
 
-export function TemplateResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): TemplateResponse {
+export function TemplateFromJSONTyped(json: any, ignoreDiscriminator: boolean): Template {
     if (json == null) {
         return json;
     }
@@ -94,11 +94,11 @@ export function TemplateResponseFromJSONTyped(json: any, ignoreDiscriminator: bo
     };
 }
 
-export function TemplateResponseToJSON(json: any): TemplateResponse {
-    return TemplateResponseToJSONTyped(json, false);
+export function TemplateToJSON(json: any): Template {
+    return TemplateToJSONTyped(json, false);
 }
 
-export function TemplateResponseToJSONTyped(value?: TemplateResponse | null, ignoreDiscriminator: boolean = false): any {
+export function TemplateToJSONTyped(value?: Template | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }

package/src/generated/models/{token-response.ts → token.ts}

@@ -16,30 +16,30 @@ import { mapValues } from '../runtime';
 /**
  * 
  * @export
- * @interface TokenResponse
+ * @interface Token
  */
-export interface TokenResponse {
+export interface Token {
     /**
      * Users token
      * @type {string}
-     * @memberof TokenResponse
+     * @memberof Token
      */
     token: string;
 }
 
 /**
- * Check if a given object implements the TokenResponse interface.
+ * Check if a given object implements the Token interface.
  */
-export function instanceOfTokenResponse(value: object): value is TokenResponse {
+export function instanceOfToken(value: object): value is Token {
     if (!('token' in value) || value['token'] === undefined) return false;
     return true;
 }
 
-export function TokenResponseFromJSON(json: any): TokenResponse {
-    return TokenResponseFromJSONTyped(json, false);
+export function TokenFromJSON(json: any): Token {
+    return TokenFromJSONTyped(json, false);
 }
 
-export function TokenResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): TokenResponse {
+export function TokenFromJSONTyped(json: any, ignoreDiscriminator: boolean): Token {
     if (json == null) {
         return json;
     }
@@ -49,11 +49,11 @@ export function TokenResponseFromJSONTyped(json: any, ignoreDiscriminator: boole
     };
 }
 
-export function TokenResponseToJSON(json: any): TokenResponse {
-    return TokenResponseToJSONTyped(json, false);
+export function TokenToJSON(json: any): Token {
+    return TokenToJSONTyped(json, false);
 }
 
-export function TokenResponseToJSONTyped(value?: TokenResponse | null, ignoreDiscriminator: boolean = false): any {
+export function TokenToJSONTyped(value?: Token | null, ignoreDiscriminator: boolean = false): any {
     if (value == null) {
         return value;
     }