pyrus-api 1.0.0

package/build/esm/index.js

@@ -0,0 +1,1010 @@
+var FormFieldType;
+(function (FormFieldType) {
+    FormFieldType["Unknown"] = "unknown";
+    FormFieldType["Text"] = "text";
+    FormFieldType["Money"] = "money";
+    FormFieldType["Number"] = "number";
+    FormFieldType["Date"] = "date";
+    FormFieldType["Time"] = "time";
+    FormFieldType["Checkmark"] = "checkmark";
+    FormFieldType["MultipleChoice"] = "multiple_choice";
+    FormFieldType["DueDate"] = "due_date";
+    FormFieldType["Email"] = "email";
+    FormFieldType["Phone"] = "phone";
+    FormFieldType["Flag"] = "flag";
+    FormFieldType["Step"] = "step";
+    FormFieldType["Status"] = "status";
+    FormFieldType["CreationDate"] = "creation_date";
+    FormFieldType["Note"] = "note";
+    FormFieldType["Catalog"] = "catalog";
+    FormFieldType["File"] = "file";
+    FormFieldType["Person"] = "person";
+    FormFieldType["Author"] = "author";
+    FormFieldType["Table"] = "table";
+    FormFieldType["Title"] = "title";
+    FormFieldType["Project"] = "project";
+    FormFieldType["FormLink"] = "form_link";
+    FormFieldType["DueDateTime"] = "due_date_time";
+})(FormFieldType || (FormFieldType = {}));
+
+const dateTimeFieldTypes = [FormFieldType.DueDateTime, FormFieldType.CreationDate];
+const dateFieldTypes = [FormFieldType.Date, FormFieldType.DueDate];
+const timeFieldTypes = [FormFieldType.Time];
+const allDateAndTimeFieldTypes = [...dateFieldTypes, ...dateTimeFieldTypes, ...timeFieldTypes];
+const allDateAndTimeResponseKeys = [
+    "create_date",
+    "last_modified_date",
+    "due_date",
+    "due",
+    "scheduled_date",
+    "scheduled_datetime_utc",
+    "close_date",
+];
+const dateRequestKeys = [
+    "due_date",
+    "scheduled_date",
+];
+const dateTimeRequestKeys = [
+    "start_date_utc",
+    "end_date_utc",
+    "modified_before",
+    "modified_after",
+    "created_before",
+    "created_after",
+    "closed_before",
+    "closed_after",
+    "due",
+    "scheduled_datetime_utc",
+    "start_time",
+    "end_time"
+];
+
+var OperatorId;
+(function (OperatorId) {
+    OperatorId[OperatorId["Equals"] = 1] = "Equals";
+    OperatorId[OperatorId["LessThan"] = 2] = "LessThan";
+    OperatorId[OperatorId["GreaterThan"] = 3] = "GreaterThan";
+    OperatorId[OperatorId["IsIn"] = 4] = "IsIn";
+    OperatorId[OperatorId["Range"] = 5] = "Range";
+    OperatorId[OperatorId["MatchPrefix"] = 6] = "MatchPrefix";
+    OperatorId[OperatorId["IsEmpty"] = 7] = "IsEmpty";
+})(OperatorId || (OperatorId = {}));
+
+function toSearchParams(request) {
+    return "?" + new URLSearchParams(Object.entries(request)
+        .map(([key, value]) => {
+        if (value instanceof Date) {
+            if (dateTimeRequestKeys.includes(key))
+                return [key, toDateTimeString(value)];
+            if (dateRequestKeys.includes(key))
+                return [key, toDateString(value)];
+        }
+        return [key, value];
+    }))
+        .toString();
+}
+function extractDates(key, value) {
+    if (value instanceof Object
+        && value.type
+        && value.value) {
+        if (allDateAndTimeFieldTypes.includes(value.type)) {
+            value.value = new Date(value.value);
+        }
+        return value;
+    }
+    if (allDateAndTimeResponseKeys.includes(key)) {
+        value = value && new Date(value);
+    }
+    return value;
+}
+function packDates(key, value) {
+    if (dateRequestKeys.includes(key)) {
+        return value && toDateString(value);
+    }
+    if (dateTimeRequestKeys.includes(key)) {
+        return value && toDateTimeString(value);
+    }
+    if (value instanceof Object
+        && value.type
+        && value.value) {
+        if (dateTimeFieldTypes.includes(value.type)) {
+            value.value = toDateTimeString(value.value);
+            return value;
+        }
+        if (dateFieldTypes.includes(value.type)) {
+            value.value = toDateString(value.value);
+            return value;
+        }
+        if (timeFieldTypes.includes(value.type)) {
+            value.value = toTimeString(value.value);
+            return value;
+        }
+    }
+    return value;
+}
+function trimTailingSlash(url) {
+    return url.endsWith('/')
+        ? url.slice(0, -1)
+        : url;
+}
+function toDateTimeString(date) {
+    if (typeof date !== "string")
+        date = date.toISOString();
+    return date.split(".")[0] + "Z";
+}
+function toDateString(date) {
+    if (typeof date !== "string")
+        date = date.toISOString();
+    return date.split("T")[0];
+}
+function toTimeString(date) {
+    if (typeof date !== "string")
+        date = date.toISOString();
+    return date.split("T")[1].slice(0, 5);
+}
+function processFilters(filters) {
+    if (!filters)
+        return {};
+    return filters
+        .reduce((prev, { operator_id, values, field_id }) => {
+        switch (operator_id) {
+            case OperatorId.Equals:
+            case OperatorId.MatchPrefix:
+                prev[`fld${field_id}`] = values[0];
+                break;
+            case OperatorId.LessThan:
+                prev[`fld${field_id}`] = `lt${values[0]}`;
+                break;
+            case OperatorId.GreaterThan:
+                prev[`fld${field_id}`] = `gt${values[0]}`;
+                break;
+            case OperatorId.IsIn:
+                prev[`fld${field_id}`] = values.join(",");
+                break;
+            case OperatorId.Range:
+                prev[`fld${field_id}`] = `gt${values[0]},lt${values[1]}`;
+                break;
+            case OperatorId.IsEmpty:
+                prev[`fld${field_id}`] = "empty";
+                break;
+            default:
+                return prev;
+        }
+        return prev;
+    }, {});
+}
+
+var FilterMask;
+(function (FilterMask) {
+    FilterMask[FilterMask["Due"] = 1] = "Due";
+    FilterMask[FilterMask["DueDate"] = 2] = "DueDate";
+    FilterMask[FilterMask["DueForCurrentStep"] = 4] = "DueForCurrentStep";
+    FilterMask[FilterMask["Reminded"] = 8] = "Reminded";
+})(FilterMask || (FilterMask = {}));
+
+var CallEventType;
+(function (CallEventType) {
+    CallEventType["Show"] = "show";
+})(CallEventType || (CallEventType = {}));
+
+var SourceType;
+(function (SourceType) {
+    SourceType["Default"] = "default";
+    SourceType["FillTable"] = "fill_table";
+})(SourceType || (SourceType = {}));
+
+var ActivityAction;
+(function (ActivityAction) {
+    ActivityAction["Finished"] = "finished";
+    ActivityAction["Reopened"] = "reopened";
+})(ActivityAction || (ActivityAction = {}));
+
+var ApprovalChoice;
+(function (ApprovalChoice) {
+    ApprovalChoice["Waiting"] = "waiting";
+    ApprovalChoice["Approved"] = "approved";
+    ApprovalChoice["Rejected"] = "rejected";
+    ApprovalChoice["Revoked"] = "revoked";
+    ApprovalChoice["Acknowledged"] = "acknowledged";
+})(ApprovalChoice || (ApprovalChoice = {}));
+
+var PersonRights;
+(function (PersonRights) {
+    PersonRights[PersonRights["None"] = 0] = "None";
+    PersonRights[PersonRights["ManageRoles"] = 1] = "ManageRoles";
+    PersonRights[PersonRights["CanSeeAllTasks"] = 2] = "CanSeeAllTasks";
+    PersonRights[PersonRights["ManagePersonsInOrganization"] = 4] = "ManagePersonsInOrganization";
+    PersonRights[PersonRights["EditOrganizationProjects"] = 8] = "EditOrganizationProjects";
+    PersonRights[PersonRights["EditOrganizationSettings"] = 16] = "EditOrganizationSettings";
+    PersonRights[PersonRights["DeleteMyTasksAndProjects"] = 32] = "DeleteMyTasksAndProjects";
+    PersonRights[PersonRights["CloseDeleteAnnouncements"] = 64] = "CloseDeleteAnnouncements";
+    PersonRights[PersonRights["BillsPayment"] = 128] = "BillsPayment";
+    PersonRights[PersonRights["InvitePersonsToOrganization"] = 256] = "InvitePersonsToOrganization";
+    PersonRights[PersonRights["DeleteOtherMembersTasks"] = 512] = "DeleteOtherMembersTasks";
+    PersonRights[PersonRights["ManageIntegrationsAndCatalogs"] = 1024] = "ManageIntegrationsAndCatalogs";
+    PersonRights[PersonRights["CreateAnnouncement"] = 2048] = "CreateAnnouncement";
+    PersonRights[PersonRights["CanDeleteTaskFlagEquivalent"] = 544] = "CanDeleteTaskFlagEquivalent";
+    PersonRights[PersonRights["SupervisorRights"] = 221] = "SupervisorRights";
+    PersonRights[PersonRights["MaxAdditionalRights"] = 2047] = "MaxAdditionalRights";
+    PersonRights[PersonRights["NewOrganizationDefaultRights"] = 2080] = "NewOrganizationDefaultRights";
+    PersonRights[PersonRights["UIOrganizationManager"] = 277] = "UIOrganizationManager";
+    PersonRights[PersonRights["UIAccountant"] = 128] = "UIAccountant";
+    PersonRights[PersonRights["UISupervisor"] = 10] = "UISupervisor";
+    PersonRights[PersonRights["UIConfigurationManager"] = 1600] = "UIConfigurationManager";
+    PersonRights[PersonRights["UIAdministrator"] = 2015] = "UIAdministrator";
+})(PersonRights || (PersonRights = {}));
+
+var ListType;
+(function (ListType) {
+    ListType["Private"] = "private";
+    ListType["OrganizationWide"] = "org_wide";
+})(ListType || (ListType = {}));
+
+var ErrorCodeType;
+(function (ErrorCodeType) {
+    ErrorCodeType["ServerError"] = "server_error";
+    ErrorCodeType["AuthorizationError"] = "authorization_error";
+    ErrorCodeType["TokenNotSpecified"] = "token_not_specified";
+    ErrorCodeType["RevokedToken"] = "revoked_token";
+    ErrorCodeType["ExpiredToken"] = "expired_token";
+    ErrorCodeType["InvalidToken"] = "invalid_token";
+    ErrorCodeType["AccountBlocked"] = "account_blocked";
+    ErrorCodeType["InvalidCredentials"] = "invalid_credentials";
+    ErrorCodeType["InvalidApplicationId"] = "invalid_application_id";
+    ErrorCodeType["InvalidFieldId"] = "invalid_field_id";
+    ErrorCodeType["InvalidFieldName"] = "invalid_field_name";
+    ErrorCodeType["InvalidFieldIdName"] = "invalid_field_id_name";
+    ErrorCodeType["NonUniqueName"] = "non_unique_name";
+    ErrorCodeType["FieldIdentityMissing"] = "field_identity_missing";
+    ErrorCodeType["DuplicateField"] = "duplicate_field";
+    ErrorCodeType["InvalidCatalogId"] = "invalid_catalog_id";
+    ErrorCodeType["InvalidCatalogItemName"] = "invalid_catalog_item_name";
+    ErrorCodeType["NonUniqueCatalogItemName"] = "non_unique_catalog_item_name";
+    ErrorCodeType["InvalidCatalogItemId"] = "invalid_catalog_item_id";
+    ErrorCodeType["InvalidCatalogItemIdName"] = "catalog_item_id_name_mismatch";
+    ErrorCodeType["InvalidEmail"] = "invalid_email";
+    ErrorCodeType["NonUniqueEmail"] = "non_unique_email";
+    ErrorCodeType["InvalidPersonIdEmail"] = "invalid_person_id_email";
+    ErrorCodeType["UnrecognizedAttachmentId"] = "unrecognized_attachment_id";
+    ErrorCodeType["RequiredFieldMissing"] = "required_field_missing";
+    ErrorCodeType["FieldTypeIsNotSupported"] = "type_is_not_supported";
+    ErrorCodeType["IncorrectParametersCount"] = "incorrect_parameters_count";
+    ErrorCodeType["FilterTypeIsNotSupported"] = "filter_type_is_not_supported";
+    ErrorCodeType["StepFieldDoesNotExists"] = "step_field_does_not_exists";
+    ErrorCodeType["NoFileInRequest"] = "no_file_in_request";
+    ErrorCodeType["TooLargeRequestLength"] = "too_large_request_length";
+    ErrorCodeType["TaskHasNoForm"] = "task_has_no_form";
+    ErrorCodeType["RequiredParameterMissing"] = "required_parameter_missing";
+    ErrorCodeType["InvalidValueFormat"] = "invalid_value_format";
+    ErrorCodeType["InvalidJson"] = "invalid_json";
+    ErrorCodeType["EmptyBody"] = "empty_body";
+    ErrorCodeType["TextMissing"] = "text_missing";
+    ErrorCodeType["FormIdMissing"] = "form_id_missing";
+    ErrorCodeType["InvalidPersonId"] = "invalid_person_id";
+    ErrorCodeType["DeletedField"] = "deleted_field";
+    ErrorCodeType["PersonIdentityMissing"] = "person_identity_missing";
+    ErrorCodeType["CatalogItemIdMissing"] = "catalog_identity_missing";
+    ErrorCodeType["FormHasNoTask"] = "form_has_no_task";
+    ErrorCodeType["EitherDueDateOrDueCanBeSet"] = "either_due_date_or_due_can_be_set";
+    ErrorCodeType["NegativeDuration"] = "negative_duration";
+    ErrorCodeType["DurationIsTooLong"] = "duration_is_too_long";
+    ErrorCodeType["DueMissing"] = "due_missing";
+    ErrorCodeType["ScheduledDateInPast"] = "scheduled_date_in_past";
+    ErrorCodeType["CannotAddFormProject"] = "cannot_add_form_project";
+    ErrorCodeType["FormTemplateCantBeRemovedFromTask"] = "form_template_cant_be_removed_from_task";
+    ErrorCodeType["TooManyTaskSteps"] = "too_many_task_steps";
+    ErrorCodeType["TooManyComments"] = "too_many_comments";
+    ErrorCodeType["InvalidStepNumber"] = "invalid_step_number";
+    ErrorCodeType["TaskLimitExceeded"] = "task_limit_exceeded";
+    ErrorCodeType["FieldIsInTable"] = "field_is_in_table";
+    ErrorCodeType["RequiredTableFieldMissing"] = "required_table_field_missing";
+    ErrorCodeType["DepartmentCatalogCanNotBeModified"] = "department_catalog_can_not_be_modified";
+    ErrorCodeType["CatalogDuplicateItems"] = "catalog_duplicate_rows";
+    ErrorCodeType["EmptyCatalogHeaders"] = "empty_catalog_headers";
+    ErrorCodeType["CanNotModifyDeletedCatalog"] = "can_not_modify_deleted_catalog";
+    ErrorCodeType["CatalogDuplicateHeaders"] = "catalog_duplicate_headers";
+    ErrorCodeType["CanNotModifyFirstColumn"] = "can_not_modify_first_column";
+    ErrorCodeType["CatalogHeadersItemsMismatch"] = "catalog_headers_items_mismatch";
+    ErrorCodeType["TooManyCatalogItems"] = "too_many_catalog_items";
+    ErrorCodeType["CatalogItemMaxLengthExceeded"] = "catalog_item_max_length_exceeded";
+    ErrorCodeType["SingleValueIsNotSupported"] = "single_value_is_not_supported";
+    ErrorCodeType["ParticipantLimitExceeded"] = "participant_limit_exceeded";
+    ErrorCodeType["TableRowsLimitExceeded"] = "table_rows_limit_exceeded";
+    ErrorCodeType["TextFieldValueLimitExceeded"] = "text_field_value_limit_exceeded";
+    ErrorCodeType["UnableToEditField"] = "unable_to_edit_field";
+    ErrorCodeType["EmptyFile"] = "empty_file";
+    ErrorCodeType["BadMultipartContent"] = "bad_multipart_content";
+    ErrorCodeType["TooManyDecimalPlaces"] = "too_many_decimal_places";
+    ErrorCodeType["ExternalCommentEmptyText"] = "external_comment_empty_text";
+    ErrorCodeType["SenderAddressFieldMissing"] = "sender_address_field_missing";
+    ErrorCodeType["ExternalCommentRecipientNotFound"] = "external_comment_recipient_not_found";
+    ErrorCodeType["DefaultMailboxNotFound"] = "default_mailbox_not_found";
+    ErrorCodeType["CatalogNullValue"] = "catalog_null_value";
+    ErrorCodeType["MaxTextLengthExceeded"] = "max_text_length_exceeded";
+    ErrorCodeType["DueOutsideOfBounds"] = "due_outside_of_bounds";
+    ErrorCodeType["AttachmentsForbidden"] = "attachments_forbidden";
+    ErrorCodeType["UnrecognizedCallGuid"] = "unrecognized_call_guid";
+    ErrorCodeType["UnsupportedAttachmentFormat"] = "unsupported_attachment_format";
+    ErrorCodeType["ValidationError"] = "validation_error";
+    ErrorCodeType["UnrecognizedAccountId"] = "unrecognized_account_id";
+    ErrorCodeType["WebhookIsDisabled"] = "webhook_is_disabled";
+    ErrorCodeType["TooLargeMessageText"] = "too_large_message_text";
+    ErrorCodeType["UnrecognizedMessageType"] = "unrecognized_message_type";
+    ErrorCodeType["InvalidFieldMappingCode"] = "invalid_field_mapping_code";
+    ErrorCodeType["TooManyAttachments"] = "too_many_attachments";
+    ErrorCodeType["UnrecognizedCallId"] = "unrecognized_call_id";
+    ErrorCodeType["UnsupportedRecordFileFormat"] = "unsupported_record_file_format";
+    ErrorCodeType["UnrecognizedIntegrationGuid"] = "unrecognized_integration_guid";
+    ErrorCodeType["LimitExceeded"] = "limit_exceeded";
+    ErrorCodeType["MaxSmsTextLengthExceeded"] = "max_sms_text_length_exceeded";
+    ErrorCodeType["SmsIntegrationNotConfigured"] = "sms_integration_not_configured";
+    ErrorCodeType["AttachmentTooBig"] = "attachment_too_big";
+    ErrorCodeType["UncreatedOrDeletedTableRows"] = "invalid_table_row";
+    ErrorCodeType["PrivateChannelAccessDenied"] = "private_channel_access_denied";
+    ErrorCodeType["PrivateCommentHasForbiddenChanges"] = "private_comment_has_forbidden_changes";
+    ErrorCodeType["ItemsCountOutOfRange"] = "items_count_out_of_range";
+    ErrorCodeType["CannotAddExternalUser"] = "cannot_add_external_user";
+    ErrorCodeType["UnrecognizedTaskId"] = "unrecognized_task_id";
+    ErrorCodeType["TooManyDeletedCatalogItems"] = "too_many_deleted_catalog_items";
+    ErrorCodeType["FieldCannotHaveMultipleValues"] = "field_cannot_have_multiple_values";
+    ErrorCodeType["FieldEditingIsNotAllowed"] = "field_editing_is_not_allowed";
+    ErrorCodeType["NonUniqueCode"] = "non_unique_code";
+    ErrorCodeType["InvalidFieldCode"] = "invalid_field_code";
+    ErrorCodeType["AccessDeniedProject"] = "access_denied_project";
+    ErrorCodeType["AccessDeniedTask"] = "access_denied_task";
+    ErrorCodeType["AccessDeniedCatalog"] = "access_denied_catalog";
+    ErrorCodeType["AccessDeniedForm"] = "access_denied_form";
+    ErrorCodeType["AccessDeniedPerson"] = "access_denied_person";
+    ErrorCodeType["AccessDeniedCloseTask"] = "access_denied_close_task";
+    ErrorCodeType["AccessDeniedReopenTask"] = "access_denied_reopen_task";
+    ErrorCodeType["AccessDeniedFileAccessHistory"] = "access_denied_file_access_history";
+    ErrorCodeType["AccessDeniedFile"] = "access_denied_file";
+    ErrorCodeType["AccessDeniedReport"] = "access_denied_report";
+    ErrorCodeType["AccessDenied"] = "access_denied";
+    ErrorCodeType["FileIsMissing"] = "file_is_missing";
+    ErrorCodeType["TooManyRequests"] = "too_many_requests";
+})(ErrorCodeType || (ErrorCodeType = {}));
+
+var Flag;
+(function (Flag) {
+    Flag["None"] = "none";
+    Flag["Checked"] = "checked";
+    Flag["Unchecked"] = "unchecked";
+})(Flag || (Flag = {}));
+
+var PermissionLevel;
+(function (PermissionLevel) {
+    PermissionLevel["None"] = "none";
+    PermissionLevel["Manager"] = "manager";
+    PermissionLevel["Member"] = "member";
+    PermissionLevel["Administrator"] = "administrator";
+})(PermissionLevel || (PermissionLevel = {}));
+
+var PersonType;
+(function (PersonType) {
+    PersonType["User"] = "user";
+    PersonType["Bot"] = "bot";
+    PersonType["Role"] = "role";
+})(PersonType || (PersonType = {}));
+
+var SendSmsError;
+(function (SendSmsError) {
+    SendSmsError["None"] = "none";
+    SendSmsError["Unknown"] = "unknown";
+    SendSmsError["Expired"] = "expired";
+    SendSmsError["Forbidden"] = "forbidden";
+    SendSmsError["Unreachable"] = "unreachable";
+    SendSmsError["UnknownStatus"] = "unknown_status";
+    SendSmsError["UnableToDeliver"] = "unable_to_deliver";
+    SendSmsError["InvalidPhoneNumber"] = "invalid_phone_number";
+    SendSmsError["Rejected"] = "rejected";
+})(SendSmsError || (SendSmsError = {}));
+
+var SendSmsStatus;
+(function (SendSmsStatus) {
+    SendSmsStatus["Sent"] = "sent";
+    SendSmsStatus["Delivered"] = "delivered";
+    SendSmsStatus["DeliveryFailed"] = "delivery_failed";
+    SendSmsStatus["SendFailed"] = "send_failed";
+})(SendSmsStatus || (SendSmsStatus = {}));
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __awaiter(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());
+    });
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+class BaseApi {
+    constructor({ token, authRequest, settings }) {
+        this._authRequest = null;
+        this._moduleSubPath = '';
+        if (token)
+            this._token = token;
+        if (authRequest)
+            this._authRequest = authRequest;
+        if (settings) {
+            this._settings = settings;
+        }
+    }
+    loginDone() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this._authRequest) {
+                return;
+            }
+            const { access_token, api_url, files_url } = yield this._authRequest;
+            this._token = access_token;
+            this._settings.apiUrl = trimTailingSlash(api_url);
+            this._settings.filesUrl = trimTailingSlash(files_url);
+            this._authRequest = null;
+        });
+    }
+    fetchApi(url, method, body, headersOverride) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.loginDone();
+            const resp = yield fetch(url, {
+                method: method,
+                headers: headersOverride || (yield this.defaultHeaders()),
+                body: body,
+            });
+            return yield this._checkResponse(resp);
+        });
+    }
+    _checkResponse(resp) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (resp.ok) {
+                const contentType = resp.headers.get("Content-Type");
+                if (contentType && contentType.includes("application/json")) {
+                    return JSON.parse(yield resp.text(), extractDates);
+                }
+                return yield resp.blob();
+            }
+            else {
+                return Promise.reject(yield resp.json());
+            }
+        });
+    }
+    getModulePath() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.loginDone();
+            return this._settings.apiUrl + this._moduleSubPath;
+        });
+    }
+    authorisationHeader() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.loginDone();
+            return {
+                "Authorization": `Bearer ${this._token}`
+            };
+        });
+    }
+    defaultHeaders() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return Object.assign(Object.assign({}, (yield this.authorisationHeader())), { "Content-Type": "application/json" });
+        });
+    }
+}
+
+var Endpoints;
+(function (Endpoints) {
+    Endpoints["Auth"] = "/auth";
+    Endpoints["Roles"] = "/roles";
+    Endpoints["Profile"] = "/profile";
+    Endpoints["Contacts"] = "/contacts";
+    Endpoints["Files"] = "/files";
+    Endpoints["V4"] = "/v4";
+    Endpoints["Upload"] = "/upload";
+    Endpoints["Download"] = "/download";
+    Endpoints["Lists"] = "/lists";
+    Endpoints["Inbox"] = "/inbox";
+    Endpoints["ListTasks"] = "/tasks";
+    Endpoints["Calendar"] = "/calendar";
+    Endpoints["Announcements"] = "/announcements";
+    Endpoints["AnnouncementComments"] = "/comments";
+    Endpoints["Catalogs"] = "/catalogs";
+    Endpoints["Members"] = "/members";
+    Endpoints["Tasks"] = "/tasks";
+    Endpoints["TasksComments"] = "/comments";
+    Endpoints["Forms"] = "/forms";
+    Endpoints["FormsRegister"] = "/register";
+    Endpoints["FormsPermissions"] = "/permissions";
+    Endpoints["EventHistory"] = "/eventhistory";
+    Endpoints["FileAccessHistory"] = "/fileaccesshistory";
+    Endpoints["TaskAccessHistory"] = "/taskaccesshistory";
+    Endpoints["TaskExportHistory"] = "/taskexporthistory";
+    Endpoints["RegistryDownloadHistory"] = "/registrydownloadhistory";
+    Endpoints["Integrations"] = "/integrations";
+    Endpoints["Call"] = "/call";
+    Endpoints["AttachCallRecord"] = "/attachcallrecord";
+    Endpoints["Bots"] = "/bots";
+})(Endpoints || (Endpoints = {}));
+
+class RoleApi extends BaseApi {
+    constructor() {
+        super(...arguments);
+        this._moduleSubPath = Endpoints.Roles;
+    }
+    create(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.fetchApi(yield this.getModulePath(), "POST", JSON.stringify(request));
+        });
+    }
+    get(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ id }) {
+            return yield this.fetchApi((yield this.getModulePath()) + `/${id}`, "GET");
+        });
+    }
+    getAll(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const searchParams = request ? toSearchParams(request) : "";
+            return yield this.fetchApi((yield this.getModulePath()) + searchParams, "GET");
+        });
+    }
+    update(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.fetchApi((yield this.getModulePath()) + `/${request.id}`, "PUT", JSON.stringify(request));
+        });
+    }
+}
+
+const defaults = {
+    authUrl: "https://accounts.pyrus.com/api/v4",
+    apiUrl: "https://api.pyrus.com/v4",
+    filesUrl: "https://files.pyrus.com"
+};
+
+class ProfileApi extends BaseApi {
+    constructor() {
+        super(...arguments);
+        this._moduleSubPath = Endpoints.Profile;
+    }
+    get(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const searchParams = request ? toSearchParams(request) : "";
+            return yield this.fetchApi((yield this.getModulePath()) + searchParams, "GET");
+        });
+    }
+}
+
+class ContactsApi extends BaseApi {
+    constructor() {
+        super(...arguments);
+        this._moduleSubPath = Endpoints.Contacts;
+    }
+    getAll(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const searchParams = request ? toSearchParams(request) : "";
+            return yield this.fetchApi((yield this.getModulePath()) + searchParams, "GET");
+        });
+    }
+}
+
+class FilesApi extends BaseApi {
+    upload(file, filename) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const formData = new FormData();
+            formData.append(filename, file, filename);
+            return yield this.fetchApi((yield this._filePath()) + Endpoints.Upload, "POST", formData, yield this.authorisationHeader());
+        });
+    }
+    download(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ id }) {
+            return yield this.fetchApi((yield this._filePath()) + Endpoints.Download + `/${id}`, "GET");
+        });
+    }
+    _filePath() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.loginDone();
+            if (this._settings.filesUrl)
+                return this._settings.filesUrl + Endpoints.V4 + Endpoints.Files;
+            return this._settings.apiUrl + Endpoints.Files;
+        });
+    }
+}
+
+class ListsApi extends BaseApi {
+    constructor() {
+        super(...arguments);
+        this._moduleSubPath = Endpoints.Lists;
+    }
+    getAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.fetchApi(yield this.getModulePath(), "GET");
+        });
+    }
+    getTasksInList(listId, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const searchParams = request ? toSearchParams(request) : "";
+            return yield this.fetchApi((yield this.getModulePath()) + `/${listId}` + Endpoints.ListTasks + searchParams, "GET");
+        });
+    }
+    getInbox(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.loginDone();
+            const searchParams = request ? toSearchParams(request) : "";
+            return yield this.fetchApi(this._settings.apiUrl + Endpoints.Inbox + searchParams, "GET");
+        });
+    }
+    create(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.fetchApi(yield this.getModulePath(), "PUT", JSON.stringify(request));
+        });
+    }
+    delete(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.fetchApi((yield this.getModulePath()) + `/${request.id}`, "DELETE", JSON.stringify(request));
+        });
+    }
+    update(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.fetchApi((yield this.getModulePath()) + `/${request.id}`, "POST", JSON.stringify(request));
+        });
+    }
+}
+
+class CalendarApi extends BaseApi {
+    constructor() {
+        super(...arguments);
+        this._moduleSubPath = Endpoints.Calendar;
+    }
+    getTasks(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.fetchApi((yield this.getModulePath()) + toSearchParams(request), "GET");
+        });
+    }
+}
+
+class AnnouncementsApi extends BaseApi {
+    constructor() {
+        super(...arguments);
+        this._moduleSubPath = Endpoints.Announcements;
+    }
+    getAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.fetchApi(yield this.getModulePath(), "GET");
+        });
+    }
+    get(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ id }) {
+            return yield this.fetchApi((yield this.getModulePath()) + `/${id}`, "GET");
+        });
+    }
+    create(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.fetchApi(yield this.getModulePath(), "POST", JSON.stringify(request));
+        });
+    }
+    addComment(id, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.fetchApi((yield this.getModulePath()) + `/${id}` + Endpoints.AnnouncementComments, "POST", JSON.stringify(request));
+        });
+    }
+}
+
+class CatalogsApi extends BaseApi {
+    constructor() {
+        super(...arguments);
+        this._moduleSubPath = Endpoints.Catalogs;
+    }
+    getAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.fetchApi(yield this.getModulePath(), "GET");
+        });
+    }
+    get(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ id }) {
+            return yield this.fetchApi((yield this.getModulePath()) + `/${id}`, "GET");
+        });
+    }
+    create(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.fetchApi(yield this.getModulePath(), "PUT", JSON.stringify(request));
+        });
+    }
+    sync(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.fetchApi((yield this.getModulePath()) + `/${request.id}`, "POST", JSON.stringify(request));
+        });
+    }
+}
+
+class MembersApi extends BaseApi {
+    constructor() {
+        super(...arguments);
+        this._moduleSubPath = Endpoints.Members;
+    }
+    create(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.fetchApi(yield this.getModulePath(), "POST", JSON.stringify(request));
+        });
+    }
+    get(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ id }) {
+            return yield this.fetchApi((yield this.getModulePath()) + `/${id}`, "GET");
+        });
+    }
+    getAll(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const searchParams = request ? toSearchParams(request) : "";
+            return yield this.fetchApi((yield this.getModulePath()) + searchParams, "GET");
+        });
+    }
+    update(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.fetchApi((yield this.getModulePath()) + `/${request.id}`, "PUT", JSON.stringify(request));
+        });
+    }
+    delete(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ id }) {
+            return yield this.fetchApi((yield this.getModulePath()) + `/${id}`, "DELETE");
+        });
+    }
+}
+
+class TasksApi extends BaseApi {
+    constructor() {
+        super(...arguments);
+        this._moduleSubPath = Endpoints.Tasks;
+    }
+    get(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ id }) {
+            return yield this.fetchApi((yield this.getModulePath()) + `/${id}`, "GET");
+        });
+    }
+    create(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.fetchApi(yield this.getModulePath(), "POST", JSON.stringify(request, packDates));
+        });
+    }
+    addComment(id, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.fetchApi((yield this.getModulePath()) + `/${id}` + Endpoints.TasksComments, "POST", JSON.stringify(request, packDates));
+        });
+    }
+}
+
+class FormsApi extends BaseApi {
+    constructor() {
+        super(...arguments);
+        this._moduleSubPath = Endpoints.Forms;
+    }
+    get(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ id }) {
+            return yield this.fetchApi((yield this.getModulePath()) + `/${id}`, "GET");
+        });
+    }
+    getAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.fetchApi(yield this.getModulePath(), "GET");
+        });
+    }
+    getTasks(id, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const processedRequest = Object.assign(Object.assign({}, request), processFilters(request && request.filters));
+            if (processedRequest.filters)
+                delete processedRequest.filters;
+            return yield this.fetchApi((yield this.getModulePath()) + `/${id}` + Endpoints.FormsRegister, "POST", JSON.stringify(processedRequest, packDates));
+        });
+    }
+    getPermissions(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ id }) {
+            return yield this.fetchApi((yield this.getModulePath()) + `/${id}` + Endpoints.FormsPermissions, "GET");
+        });
+    }
+    setPermissions(id, request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.fetchApi((yield this.getModulePath()) + `/${id}` + Endpoints.FormsPermissions, "POST", JSON.stringify(request));
+        });
+    }
+}
+
+class LogsApi extends BaseApi {
+    getEvents(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.loginDone();
+            const searchParams = request ? toSearchParams(request) : "";
+            return yield this.fetchApi(this._settings.apiUrl + Endpoints.EventHistory + searchParams, "GET");
+        });
+    }
+    getFileAccess(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.loginDone();
+            const searchParams = request ? toSearchParams(request) : "";
+            return yield this.fetchApi(this._settings.apiUrl + Endpoints.FileAccessHistory + searchParams, "GET");
+        });
+    }
+    getTaskAccess(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.loginDone();
+            const searchParams = request ? toSearchParams(request) : "";
+            return yield this.fetchApi(this._settings.apiUrl + Endpoints.TaskAccessHistory + searchParams, "GET");
+        });
+    }
+    getTaskExport(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.loginDone();
+            const searchParams = request ? toSearchParams(request) : "";
+            return yield this.fetchApi(this._settings.apiUrl + Endpoints.TaskExportHistory + searchParams, "GET");
+        });
+    }
+    getRegistryDownload(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.loginDone();
+            const searchParams = request ? toSearchParams(request) : "";
+            return yield this.fetchApi(this._settings.apiUrl + Endpoints.RegistryDownloadHistory + searchParams, "GET");
+        });
+    }
+}
+
+class CallApi extends BaseApi {
+    constructor() {
+        super(...arguments);
+        this._moduleSubPath = Endpoints.Integrations;
+    }
+    registerCall(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.fetchApi((yield this.getModulePath()) + Endpoints.Call, "POST", JSON.stringify(request));
+        });
+    }
+    attachCallRecord(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.fetchApi((yield this.getModulePath()) + Endpoints.AttachCallRecord, "POST", JSON.stringify(request));
+        });
+    }
+}
+
+class BotApi extends BaseApi {
+    constructor() {
+        super(...arguments);
+        this._moduleSubPath = Endpoints.Bots;
+    }
+    create(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.fetchApi(yield this.getModulePath(), "POST", JSON.stringify(request));
+        });
+    }
+    get(_a) {
+        return __awaiter(this, arguments, void 0, function* ({ id }) {
+            return yield this.fetchApi((yield this.getModulePath()) + `/${id}`, "GET");
+        });
+    }
+    getAll(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const searchParams = request ? toSearchParams(request) : "";
+            return yield this.fetchApi((yield this.getModulePath()) + searchParams, "GET");
+        });
+    }
+    update(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.fetchApi((yield this.getModulePath()) + `/${request.id}`, "PUT", JSON.stringify(request));
+        });
+    }
+    delete(request) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return yield this.fetchApi((yield this.getModulePath()) + `/${request.id}`, "DELETE", JSON.stringify(request));
+        });
+    }
+}
+
+class PyrusApiClient extends BaseApi {
+    constructor(auth, settings) {
+        const currentSettings = !!settings
+            ? Object.assign(Object.assign({}, defaults), settings) : defaults;
+        super({ settings: currentSettings });
+        if (typeof auth === "string")
+            this._token = auth;
+        else
+            this._authRequest = this._authenticateClient(auth);
+    }
+    _authenticateClient(auth) {
+        return __awaiter(this, void 0, void 0, function* () {
+            return this.fetchApi(this._settings.authUrl + Endpoints.Auth, "POST", JSON.stringify(auth), {
+                "Content-Type": "application/json",
+            });
+        });
+    }
+    get initParams() {
+        return {
+            authRequest: this._authRequest,
+            token: this._token,
+            settings: this._settings,
+        };
+    }
+    get role() {
+        if (!this._role)
+            this._role = new RoleApi(this.initParams);
+        return this._role;
+    }
+    get profile() {
+        if (!this._profile)
+            this._profile = new ProfileApi(this.initParams);
+        return this._profile;
+    }
+    get contacts() {
+        if (!this._contacts)
+            this._contacts = new ContactsApi(this.initParams);
+        return this._contacts;
+    }
+    get files() {
+        if (!this._files)
+            this._files = new FilesApi(this.initParams);
+        return this._files;
+    }
+    get lists() {
+        if (!this._lists)
+            this._lists = new ListsApi(this.initParams);
+        return this._lists;
+    }
+    get calendar() {
+        if (!this._calendar)
+            this._calendar = new CalendarApi(this.initParams);
+        return this._calendar;
+    }
+    get announcements() {
+        if (!this._announcements)
+            this._announcements = new AnnouncementsApi(this.initParams);
+        return this._announcements;
+    }
+    get catalogs() {
+        if (!this._catalogs)
+            this._catalogs = new CatalogsApi(this.initParams);
+        return this._catalogs;
+    }
+    get members() {
+        if (!this._members)
+            this._members = new MembersApi(this.initParams);
+        return this._members;
+    }
+    get tasks() {
+        if (!this._tasks)
+            this._tasks = new TasksApi(this.initParams);
+        return this._tasks;
+    }
+    get forms() {
+        if (!this._forms)
+            this._forms = new FormsApi(this.initParams);
+        return this._forms;
+    }
+    get logs() {
+        if (!this._logs)
+            this._logs = new LogsApi(this.initParams);
+        return this._logs;
+    }
+    get call() {
+        if (!this._call)
+            this._call = new CallApi(this.initParams);
+        return this._call;
+    }
+    get bot() {
+        if (!this._bot)
+            this._bot = new BotApi(this.initParams);
+        return this._bot;
+    }
+}
+
+export { ActivityAction, ApprovalChoice, CallEventType, ErrorCodeType, FilterMask, Flag, FormFieldType, ListType, OperatorId, PermissionLevel, PersonRights, PersonType, PyrusApiClient, SendSmsError, SendSmsStatus, SourceType, toDateString, toDateTimeString, toTimeString };