@planet-a/affinity-node
Version:
API wrapper for the affinity.co API
472 lines (471 loc) • 29.9 kB
JavaScript
// TODO: better import syntax?
import { BaseAPIRequestFactory, RequiredError } from './baseapi.js';
import { HttpMethod, HttpInfo } from '../http/http.js';
import { ObjectSerializer } from '../models/ObjectSerializer.js';
import { ApiException } from './exception.js';
import { isCodeInRange } from '../util.js';
/**
* no description
*/
export class PersonsApiRequestFactory extends BaseAPIRequestFactory {
/**
* Returns metadata on non-list-specific Person Fields. Use the returned Field IDs to request field data from the GET `/v2/persons` and GET `/v2/persons/{id}` endpoints.
* Get metadata on Person Fields
* @param cursor Cursor for the next or previous page
* @param limit Number of items to include in the page
*/
async v2PersonsFieldsGET(cursor, limit, _options) {
let _config = _options || this.configuration;
// Path Params
const localVarPath = '/v2/persons/fields';
// Make Request Context
const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8");
// Query Params
if (cursor !== undefined) {
requestContext.setQueryParam("cursor", ObjectSerializer.serialize(cursor, "string", ""));
}
// Query Params
if (limit !== undefined) {
requestContext.setQueryParam("limit", ObjectSerializer.serialize(limit, "number", "int32"));
}
let authMethod;
// Apply auth methods
authMethod = _config.authMethods["bearerAuth"];
if (authMethod?.applySecurityAuthentication) {
await authMethod?.applySecurityAuthentication(requestContext);
}
const defaultAuth = _config?.authMethods?.default;
if (defaultAuth?.applySecurityAuthentication) {
await defaultAuth?.applySecurityAuthentication(requestContext);
}
return requestContext;
}
/**
* Paginate through Persons in Affinity. Returns basic information and non-list-specific field data on each Person. To retrieve field data, you must use either the `fieldIds` or the `fieldTypes` parameter to specify the Fields for which you want data returned. These Field IDs and Types can be found using the GET `/v2/persons/fields` endpoint. When no `fieldIds` or `fieldTypes` are provided, Persons will be returned without any field data attached. To supply multiple `fieldIds` or `fieldTypes` parameters, generate a query string that looks like this: `?fieldIds=field-1234&fieldIds=affinity-data-location` or `?fieldTypes=enriched&fieldTypes=global`. Requires the \"Export All People directory\" [permission](#section/Getting-Started/Permissions).
* Get all Persons
* @param cursor Cursor for the next or previous page
* @param limit Number of items to include in the page
* @param ids People IDs
* @param fieldIds Field IDs for which to return field data
* @param fieldTypes Field Types for which to return field data
*/
async v2PersonsGET(cursor, limit, ids, fieldIds, fieldTypes, _options) {
let _config = _options || this.configuration;
// Path Params
const localVarPath = '/v2/persons';
// Make Request Context
const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8");
// Query Params
if (cursor !== undefined) {
requestContext.setQueryParam("cursor", ObjectSerializer.serialize(cursor, "string", ""));
}
// Query Params
if (limit !== undefined) {
requestContext.setQueryParam("limit", ObjectSerializer.serialize(limit, "number", "int32"));
}
// Query Params
if (ids !== undefined) {
const serializedParams = ObjectSerializer.serialize(ids, "Array<number>", "int64");
for (const serializedParam of serializedParams) {
requestContext.appendQueryParam("ids", serializedParam);
}
}
// Query Params
if (fieldIds !== undefined) {
const serializedParams = ObjectSerializer.serialize(fieldIds, "Array<string>", "");
for (const serializedParam of serializedParams) {
requestContext.appendQueryParam("fieldIds", serializedParam);
}
}
// Query Params
if (fieldTypes !== undefined) {
const serializedParams = ObjectSerializer.serialize(fieldTypes, "Array<'enriched' | 'global' | 'relationship-intelligence'>", "");
for (const serializedParam of serializedParams) {
requestContext.appendQueryParam("fieldTypes", serializedParam);
}
}
let authMethod;
// Apply auth methods
authMethod = _config.authMethods["bearerAuth"];
if (authMethod?.applySecurityAuthentication) {
await authMethod?.applySecurityAuthentication(requestContext);
}
const defaultAuth = _config?.authMethods?.default;
if (defaultAuth?.applySecurityAuthentication) {
await defaultAuth?.applySecurityAuthentication(requestContext);
}
return requestContext;
}
/**
* Returns basic information and non-list-specific field data on the requested Person. To retrieve field data, you must use either the `fieldIds` or the `fieldTypes` parameter to specify the Fields for which you want data returned. These Field IDs and Types can be found using the GET `/v2/persons/fields` endpoint. When no `fieldIds` or `fieldTypes` are provided, Persons will be returned without any field data attached. To supply multiple `fieldIds` or `fieldTypes` parameters, generate a query string that looks like this: `?fieldIds=field-1234&fieldIds=affinity-data-location` or `?fieldTypes=enriched&fieldTypes=global`. Requires the \"Export All People directory\" [permission](#section/Getting-Started/Permissions).
* Get a single Person
* @param personId Person ID
* @param fieldIds Field IDs for which to return field data
* @param fieldTypes Field Types for which to return field data
*/
async v2PersonsPersonIdGET(personId, fieldIds, fieldTypes, _options) {
let _config = _options || this.configuration;
// verify required parameter 'personId' is not null or undefined
if (personId === null || personId === undefined) {
throw new RequiredError("PersonsApi", "v2PersonsPersonIdGET", "personId");
}
// Path Params
const localVarPath = '/v2/persons/{personId}'
.replace('{' + 'personId' + '}', encodeURIComponent(String(personId)));
// Make Request Context
const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8");
// Query Params
if (fieldIds !== undefined) {
const serializedParams = ObjectSerializer.serialize(fieldIds, "Array<string>", "");
for (const serializedParam of serializedParams) {
requestContext.appendQueryParam("fieldIds", serializedParam);
}
}
// Query Params
if (fieldTypes !== undefined) {
const serializedParams = ObjectSerializer.serialize(fieldTypes, "Array<'enriched' | 'global' | 'relationship-intelligence'>", "");
for (const serializedParam of serializedParams) {
requestContext.appendQueryParam("fieldTypes", serializedParam);
}
}
let authMethod;
// Apply auth methods
authMethod = _config.authMethods["bearerAuth"];
if (authMethod?.applySecurityAuthentication) {
await authMethod?.applySecurityAuthentication(requestContext);
}
const defaultAuth = _config?.authMethods?.default;
if (defaultAuth?.applySecurityAuthentication) {
await defaultAuth?.applySecurityAuthentication(requestContext);
}
return requestContext;
}
/**
* Paginate through the List Entries (AKA rows) for the given Person across all Lists. Each List Entry includes field data for the Person, including list-specific field data. Each List Entry also includes metadata about its creation, i.e., when it was added to the List and by whom. Requires the \"Export data from Lists\" [permission](#section/Getting-Started/Permissions).
* Get a Person\'s List Entries
* @param personId Persons ID
* @param cursor Cursor for the next or previous page
* @param limit Number of items to include in the page
*/
async v2PersonsPersonIdListEntriesGET(personId, cursor, limit, _options) {
let _config = _options || this.configuration;
// verify required parameter 'personId' is not null or undefined
if (personId === null || personId === undefined) {
throw new RequiredError("PersonsApi", "v2PersonsPersonIdListEntriesGET", "personId");
}
// Path Params
const localVarPath = '/v2/persons/{personId}/list-entries'
.replace('{' + 'personId' + '}', encodeURIComponent(String(personId)));
// Make Request Context
const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8");
// Query Params
if (cursor !== undefined) {
requestContext.setQueryParam("cursor", ObjectSerializer.serialize(cursor, "string", ""));
}
// Query Params
if (limit !== undefined) {
requestContext.setQueryParam("limit", ObjectSerializer.serialize(limit, "number", "int32"));
}
let authMethod;
// Apply auth methods
authMethod = _config.authMethods["bearerAuth"];
if (authMethod?.applySecurityAuthentication) {
await authMethod?.applySecurityAuthentication(requestContext);
}
const defaultAuth = _config?.authMethods?.default;
if (defaultAuth?.applySecurityAuthentication) {
await defaultAuth?.applySecurityAuthentication(requestContext);
}
return requestContext;
}
/**
* Paginate through all Lists where the given Person appears as an entry and that you have access to view. Returns basic List information for each List that contains this Person.
* Get a Person\'s Lists
* @param personId Persons ID
* @param cursor Cursor for the next or previous page
* @param limit Number of items to include in the page
*/
async v2PersonsPersonIdListsGET(personId, cursor, limit, _options) {
let _config = _options || this.configuration;
// verify required parameter 'personId' is not null or undefined
if (personId === null || personId === undefined) {
throw new RequiredError("PersonsApi", "v2PersonsPersonIdListsGET", "personId");
}
// Path Params
const localVarPath = '/v2/persons/{personId}/lists'
.replace('{' + 'personId' + '}', encodeURIComponent(String(personId)));
// Make Request Context
const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8");
// Query Params
if (cursor !== undefined) {
requestContext.setQueryParam("cursor", ObjectSerializer.serialize(cursor, "string", ""));
}
// Query Params
if (limit !== undefined) {
requestContext.setQueryParam("limit", ObjectSerializer.serialize(limit, "number", "int32"));
}
let authMethod;
// Apply auth methods
authMethod = _config.authMethods["bearerAuth"];
if (authMethod?.applySecurityAuthentication) {
await authMethod?.applySecurityAuthentication(requestContext);
}
const defaultAuth = _config?.authMethods?.default;
if (defaultAuth?.applySecurityAuthentication) {
await defaultAuth?.applySecurityAuthentication(requestContext);
}
return requestContext;
}
/**
* | ⚠️ This endpoint is currently in BETA | |--| Returns notes for a given person id which includes directly attached notes, notes on meetings this person attended, and notes where this person is mentioned. You can filter notes using the `filter` query parameter. The filter parameter is a string that you can specify conditions based on the following properties. | **Property Name** | **Description** | **Type** | **Allowed Operators** | **Examples** | |-----------------------------|-----------------------------------------------------------------|------------|--------------------------------------|---------------------------------| | `creator.id` | Filter notes by the creator of the note | `int32` | `=` | `creator.id=1` | | `createdAt` | Filter notes by when it was created | `datetime` | `>`, `<`, `>=`, `<=` | `createdAt<2025-02-04T10:48:24Z` | | `updatedAt` | Filter notes by when it was updated | `datetime` | `>`, `<`, `>=`, `<=` | `updatedAt>=2025-02-03T10:48:24Z`|
* Get Notes for a Person
* @param personId Persons ID
* @param filter Filter options
* @param cursor Cursor for the next or previous page
* @param limit Number of items to include in the page
* @param totalCount Include total count of the collection in the pagination response
*/
async v2PersonsPersonIdNotesGET(personId, filter, cursor, limit, totalCount, _options) {
let _config = _options || this.configuration;
// verify required parameter 'personId' is not null or undefined
if (personId === null || personId === undefined) {
throw new RequiredError("PersonsApi", "v2PersonsPersonIdNotesGET", "personId");
}
// Path Params
const localVarPath = '/v2/persons/{personId}/notes'
.replace('{' + 'personId' + '}', encodeURIComponent(String(personId)));
// Make Request Context
const requestContext = _config.baseServer.makeRequestContext(localVarPath, HttpMethod.GET);
requestContext.setHeaderParam("Accept", "application/json, */*;q=0.8");
// Query Params
if (filter !== undefined) {
requestContext.setQueryParam("filter", ObjectSerializer.serialize(filter, "string", ""));
}
// Query Params
if (cursor !== undefined) {
requestContext.setQueryParam("cursor", ObjectSerializer.serialize(cursor, "string", ""));
}
// Query Params
if (limit !== undefined) {
requestContext.setQueryParam("limit", ObjectSerializer.serialize(limit, "number", "int32"));
}
// Query Params
if (totalCount !== undefined) {
requestContext.setQueryParam("totalCount", ObjectSerializer.serialize(totalCount, "boolean", ""));
}
let authMethod;
// Apply auth methods
authMethod = _config.authMethods["bearerAuth"];
if (authMethod?.applySecurityAuthentication) {
await authMethod?.applySecurityAuthentication(requestContext);
}
const defaultAuth = _config?.authMethods?.default;
if (defaultAuth?.applySecurityAuthentication) {
await defaultAuth?.applySecurityAuthentication(requestContext);
}
return requestContext;
}
}
export class PersonsApiResponseProcessor {
/**
* Unwraps the actual response sent by the server from the response context and deserializes the response content
* to the expected objects
*
* @params response Response returned by the server for a request to v2PersonsFieldsGET
* @throws ApiException if the response code was not in [200, 299]
*/
async v2PersonsFieldsGETWithHttpInfo(response) {
const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
if (isCodeInRange("200", response.httpStatusCode)) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "FieldMetadataPaged", "");
return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
}
if (isCodeInRange("400", response.httpStatusCode)) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "Responses400", "");
throw new ApiException(response.httpStatusCode, "Bad Request", body, response.headers);
}
if (isCodeInRange("0", response.httpStatusCode)) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "Errors", "");
throw new ApiException(response.httpStatusCode, "Errors", body, response.headers);
}
// Work around for missing responses in specification, e.g. for petstore.yaml
if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "FieldMetadataPaged", "");
return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
}
throw new ApiException(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
}
/**
* Unwraps the actual response sent by the server from the response context and deserializes the response content
* to the expected objects
*
* @params response Response returned by the server for a request to v2PersonsGET
* @throws ApiException if the response code was not in [200, 299]
*/
async v2PersonsGETWithHttpInfo(response) {
const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
if (isCodeInRange("200", response.httpStatusCode)) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "PersonPaged", "");
return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
}
if (isCodeInRange("400", response.httpStatusCode)) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "Responses400", "");
throw new ApiException(response.httpStatusCode, "Bad Request", body, response.headers);
}
if (isCodeInRange("403", response.httpStatusCode)) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "AuthorizationErrors", "");
throw new ApiException(response.httpStatusCode, "Forbidden", body, response.headers);
}
if (isCodeInRange("0", response.httpStatusCode)) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "Errors", "");
throw new ApiException(response.httpStatusCode, "Errors", body, response.headers);
}
// Work around for missing responses in specification, e.g. for petstore.yaml
if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "PersonPaged", "");
return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
}
throw new ApiException(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
}
/**
* Unwraps the actual response sent by the server from the response context and deserializes the response content
* to the expected objects
*
* @params response Response returned by the server for a request to v2PersonsPersonIdGET
* @throws ApiException if the response code was not in [200, 299]
*/
async v2PersonsPersonIdGETWithHttpInfo(response) {
const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
if (isCodeInRange("200", response.httpStatusCode)) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "Person", "");
return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
}
if (isCodeInRange("400", response.httpStatusCode)) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "Responses400", "");
throw new ApiException(response.httpStatusCode, "Bad Request", body, response.headers);
}
if (isCodeInRange("403", response.httpStatusCode)) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "AuthorizationErrors", "");
throw new ApiException(response.httpStatusCode, "Forbidden", body, response.headers);
}
if (isCodeInRange("404", response.httpStatusCode)) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "NotFoundErrors", "");
throw new ApiException(response.httpStatusCode, "Not Found", body, response.headers);
}
if (isCodeInRange("0", response.httpStatusCode)) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "Errors", "");
throw new ApiException(response.httpStatusCode, "Errors", body, response.headers);
}
// Work around for missing responses in specification, e.g. for petstore.yaml
if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "Person", "");
return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
}
throw new ApiException(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
}
/**
* Unwraps the actual response sent by the server from the response context and deserializes the response content
* to the expected objects
*
* @params response Response returned by the server for a request to v2PersonsPersonIdListEntriesGET
* @throws ApiException if the response code was not in [200, 299]
*/
async v2PersonsPersonIdListEntriesGETWithHttpInfo(response) {
const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
if (isCodeInRange("200", response.httpStatusCode)) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "ListEntryPaged", "");
return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
}
if (isCodeInRange("400", response.httpStatusCode)) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "Responses400", "");
throw new ApiException(response.httpStatusCode, "Bad Request", body, response.headers);
}
if (isCodeInRange("403", response.httpStatusCode)) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "AuthorizationErrors", "");
throw new ApiException(response.httpStatusCode, "Forbidden", body, response.headers);
}
if (isCodeInRange("404", response.httpStatusCode)) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "NotFoundErrors", "");
throw new ApiException(response.httpStatusCode, "Not Found", body, response.headers);
}
if (isCodeInRange("0", response.httpStatusCode)) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "Errors", "");
throw new ApiException(response.httpStatusCode, "Errors", body, response.headers);
}
// Work around for missing responses in specification, e.g. for petstore.yaml
if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "ListEntryPaged", "");
return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
}
throw new ApiException(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
}
/**
* Unwraps the actual response sent by the server from the response context and deserializes the response content
* to the expected objects
*
* @params response Response returned by the server for a request to v2PersonsPersonIdListsGET
* @throws ApiException if the response code was not in [200, 299]
*/
async v2PersonsPersonIdListsGETWithHttpInfo(response) {
const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
if (isCodeInRange("200", response.httpStatusCode)) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "ListPaged", "");
return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
}
if (isCodeInRange("400", response.httpStatusCode)) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "Responses400", "");
throw new ApiException(response.httpStatusCode, "Bad Request", body, response.headers);
}
if (isCodeInRange("404", response.httpStatusCode)) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "NotFoundErrors", "");
throw new ApiException(response.httpStatusCode, "Not Found", body, response.headers);
}
if (isCodeInRange("0", response.httpStatusCode)) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "Errors", "");
throw new ApiException(response.httpStatusCode, "Errors", body, response.headers);
}
// Work around for missing responses in specification, e.g. for petstore.yaml
if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "ListPaged", "");
return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
}
throw new ApiException(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
}
/**
* Unwraps the actual response sent by the server from the response context and deserializes the response content
* to the expected objects
*
* @params response Response returned by the server for a request to v2PersonsPersonIdNotesGET
* @throws ApiException if the response code was not in [200, 299]
*/
async v2PersonsPersonIdNotesGETWithHttpInfo(response) {
const contentType = ObjectSerializer.normalizeMediaType(response.headers["content-type"]);
if (isCodeInRange("200", response.httpStatusCode)) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "NotesNotesPaged", "");
return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
}
if (isCodeInRange("400", response.httpStatusCode)) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "Responses400", "");
throw new ApiException(response.httpStatusCode, "Bad Request", body, response.headers);
}
if (isCodeInRange("404", response.httpStatusCode)) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "NotFoundErrors", "");
throw new ApiException(response.httpStatusCode, "Not Found", body, response.headers);
}
if (isCodeInRange("0", response.httpStatusCode)) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "Errors", "");
throw new ApiException(response.httpStatusCode, "Errors", body, response.headers);
}
// Work around for missing responses in specification, e.g. for petstore.yaml
if (response.httpStatusCode >= 200 && response.httpStatusCode <= 299) {
const body = ObjectSerializer.deserialize(ObjectSerializer.parse(await response.body.text(), contentType), "NotesNotesPaged", "");
return new HttpInfo(response.httpStatusCode, response.headers, response.body, body);
}
throw new ApiException(response.httpStatusCode, "Unknown API Status Code!", await response.getBodyAsAny(), response.headers);
}
}