@incident-io/sdk 1.2.0 → 2.0.0

package/dist/cjs/apis/SchedulesV2Api.d.ts

@@ -390,12 +390,12 @@ export declare class SchedulesV2Api extends runtime.BaseAPI {
      */
     schedulesV2ListScheduleEntriesRequestOpts(requestParameters: SchedulesV2ListScheduleEntriesRequest): Promise<runtime.RequestOpts>;
     /**
-     * List the schedule entries for a schedule over a window of time.  Use this endpoint to find out who is on-call for a schedule, either right now or at any point in the future. Common uses include:  - Building a calendar or timeline view of who is on-call. - Looking up who was on-call at a particular moment (for example, when an   incident fired). - Exporting upcoming shifts into another system, such as a payroll or   scheduling tool.  The response groups entries into three lists: `scheduled` (the entries the rotation rules produce, before any overrides), `overrides` (any one-off overrides that apply in the window) and `final` (the effective schedule after overrides have been merged in — this is normally the list you want).  Each entry includes the `rotation_id` and `layer_id` it belongs to. Schedules can be made up of multiple rotations (for example, a primary and a secondary rotation) and each rotation can have several layers, and we return entries for every rotation and layer on the schedule.  The endpoint returns all entries that overlap with the given window. If no window is provided we default to a sensible range starting from now.  ## Pagination  Responses are paginated. When more entries are available than fit on a single page, the response includes a `pagination_meta` block with two fields:  - `after_url` — a fully-formed URL for the next page. The simplest way   to paginate is to keep following this URL until it is no longer present. - `after` — an opaque cursor token. To fetch the next page manually,   re-issue the request with `entry_window_start` set to this value and   `entry_window_end` left unchanged from the original request. Treat   the token as opaque — do not parse or modify it.  Keep paginating until `pagination_meta` is absent from the response, at which point you have received every entry in the window.
+     * List the schedule entries for a schedule over a window of time.  Use this endpoint to find out who is on-call for a schedule, either right now or at any point in the future. Common uses include:  - Building a calendar or timeline view of who is on-call. - Looking up who was on-call at a particular moment (for example, when an   incident fired). - Exporting upcoming shifts into another system, such as a payroll or   scheduling tool.  The response groups entries into three lists: `scheduled` (the entries the rotation rules produce, before any overrides), `overrides` (any one-off overrides that apply in the window) and `final` (the effective schedule after overrides have been merged in — this is normally the list you want).  Each entry includes the `rotation_id` it belongs to. Schedules can be made up of multiple rotations (for example, a primary and a secondary rotation) and each rotation can have several layers, and we return entries for every rotation and layer on the schedule.  The endpoint returns all entries that overlap with the given window. If no window is provided we default to a sensible range starting from now.  ## Pagination  Responses are paginated. When more entries are available than fit on a single page, the response includes a `pagination_meta` block with two fields:  - `after_url` — a fully-formed URL for the next page. The simplest way   to paginate is to keep following this URL until it is no longer present. - `after` — an opaque cursor token. To fetch the next page manually,   re-issue the request with `entry_window_start` set to this value and   `entry_window_end` left unchanged from the original request. Treat   the token as opaque — do not parse or modify it.  Keep paginating until `pagination_meta` is absent from the response, at which point you have received every entry in the window.
      * ListScheduleEntries Schedules V2
      */
     schedulesV2ListScheduleEntriesRaw(requestParameters: SchedulesV2ListScheduleEntriesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SchedulesListScheduleEntriesResultV2>>;
     /**
-     * List the schedule entries for a schedule over a window of time.  Use this endpoint to find out who is on-call for a schedule, either right now or at any point in the future. Common uses include:  - Building a calendar or timeline view of who is on-call. - Looking up who was on-call at a particular moment (for example, when an   incident fired). - Exporting upcoming shifts into another system, such as a payroll or   scheduling tool.  The response groups entries into three lists: `scheduled` (the entries the rotation rules produce, before any overrides), `overrides` (any one-off overrides that apply in the window) and `final` (the effective schedule after overrides have been merged in — this is normally the list you want).  Each entry includes the `rotation_id` and `layer_id` it belongs to. Schedules can be made up of multiple rotations (for example, a primary and a secondary rotation) and each rotation can have several layers, and we return entries for every rotation and layer on the schedule.  The endpoint returns all entries that overlap with the given window. If no window is provided we default to a sensible range starting from now.  ## Pagination  Responses are paginated. When more entries are available than fit on a single page, the response includes a `pagination_meta` block with two fields:  - `after_url` — a fully-formed URL for the next page. The simplest way   to paginate is to keep following this URL until it is no longer present. - `after` — an opaque cursor token. To fetch the next page manually,   re-issue the request with `entry_window_start` set to this value and   `entry_window_end` left unchanged from the original request. Treat   the token as opaque — do not parse or modify it.  Keep paginating until `pagination_meta` is absent from the response, at which point you have received every entry in the window.
+     * List the schedule entries for a schedule over a window of time.  Use this endpoint to find out who is on-call for a schedule, either right now or at any point in the future. Common uses include:  - Building a calendar or timeline view of who is on-call. - Looking up who was on-call at a particular moment (for example, when an   incident fired). - Exporting upcoming shifts into another system, such as a payroll or   scheduling tool.  The response groups entries into three lists: `scheduled` (the entries the rotation rules produce, before any overrides), `overrides` (any one-off overrides that apply in the window) and `final` (the effective schedule after overrides have been merged in — this is normally the list you want).  Each entry includes the `rotation_id` it belongs to. Schedules can be made up of multiple rotations (for example, a primary and a secondary rotation) and each rotation can have several layers, and we return entries for every rotation and layer on the schedule.  The endpoint returns all entries that overlap with the given window. If no window is provided we default to a sensible range starting from now.  ## Pagination  Responses are paginated. When more entries are available than fit on a single page, the response includes a `pagination_meta` block with two fields:  - `after_url` — a fully-formed URL for the next page. The simplest way   to paginate is to keep following this URL until it is no longer present. - `after` — an opaque cursor token. To fetch the next page manually,   re-issue the request with `entry_window_start` set to this value and   `entry_window_end` left unchanged from the original request. Treat   the token as opaque — do not parse or modify it.  Keep paginating until `pagination_meta` is absent from the response, at which point you have received every entry in the window.
      * ListScheduleEntries Schedules V2
      */
     schedulesV2ListScheduleEntries(requestParameters: SchedulesV2ListScheduleEntriesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SchedulesListScheduleEntriesResultV2>;

package/dist/cjs/apis/SchedulesV2Api.js

@@ -563,7 +563,7 @@ class SchedulesV2Api extends runtime.BaseAPI {
         };
     }
     /**
-     * List the schedule entries for a schedule over a window of time.  Use this endpoint to find out who is on-call for a schedule, either right now or at any point in the future. Common uses include:  - Building a calendar or timeline view of who is on-call. - Looking up who was on-call at a particular moment (for example, when an   incident fired). - Exporting upcoming shifts into another system, such as a payroll or   scheduling tool.  The response groups entries into three lists: `scheduled` (the entries the rotation rules produce, before any overrides), `overrides` (any one-off overrides that apply in the window) and `final` (the effective schedule after overrides have been merged in — this is normally the list you want).  Each entry includes the `rotation_id` and `layer_id` it belongs to. Schedules can be made up of multiple rotations (for example, a primary and a secondary rotation) and each rotation can have several layers, and we return entries for every rotation and layer on the schedule.  The endpoint returns all entries that overlap with the given window. If no window is provided we default to a sensible range starting from now.  ## Pagination  Responses are paginated. When more entries are available than fit on a single page, the response includes a `pagination_meta` block with two fields:  - `after_url` — a fully-formed URL for the next page. The simplest way   to paginate is to keep following this URL until it is no longer present. - `after` — an opaque cursor token. To fetch the next page manually,   re-issue the request with `entry_window_start` set to this value and   `entry_window_end` left unchanged from the original request. Treat   the token as opaque — do not parse or modify it.  Keep paginating until `pagination_meta` is absent from the response, at which point you have received every entry in the window.
+     * List the schedule entries for a schedule over a window of time.  Use this endpoint to find out who is on-call for a schedule, either right now or at any point in the future. Common uses include:  - Building a calendar or timeline view of who is on-call. - Looking up who was on-call at a particular moment (for example, when an   incident fired). - Exporting upcoming shifts into another system, such as a payroll or   scheduling tool.  The response groups entries into three lists: `scheduled` (the entries the rotation rules produce, before any overrides), `overrides` (any one-off overrides that apply in the window) and `final` (the effective schedule after overrides have been merged in — this is normally the list you want).  Each entry includes the `rotation_id` it belongs to. Schedules can be made up of multiple rotations (for example, a primary and a secondary rotation) and each rotation can have several layers, and we return entries for every rotation and layer on the schedule.  The endpoint returns all entries that overlap with the given window. If no window is provided we default to a sensible range starting from now.  ## Pagination  Responses are paginated. When more entries are available than fit on a single page, the response includes a `pagination_meta` block with two fields:  - `after_url` — a fully-formed URL for the next page. The simplest way   to paginate is to keep following this URL until it is no longer present. - `after` — an opaque cursor token. To fetch the next page manually,   re-issue the request with `entry_window_start` set to this value and   `entry_window_end` left unchanged from the original request. Treat   the token as opaque — do not parse or modify it.  Keep paginating until `pagination_meta` is absent from the response, at which point you have received every entry in the window.
      * ListScheduleEntries Schedules V2
      */
     async schedulesV2ListScheduleEntriesRaw(requestParameters, initOverrides) {
@@ -572,7 +572,7 @@ class SchedulesV2Api extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, SchedulesListScheduleEntriesResultV2_js_1.SchedulesListScheduleEntriesResultV2FromJSON)(jsonValue));
     }
     /**
-     * List the schedule entries for a schedule over a window of time.  Use this endpoint to find out who is on-call for a schedule, either right now or at any point in the future. Common uses include:  - Building a calendar or timeline view of who is on-call. - Looking up who was on-call at a particular moment (for example, when an   incident fired). - Exporting upcoming shifts into another system, such as a payroll or   scheduling tool.  The response groups entries into three lists: `scheduled` (the entries the rotation rules produce, before any overrides), `overrides` (any one-off overrides that apply in the window) and `final` (the effective schedule after overrides have been merged in — this is normally the list you want).  Each entry includes the `rotation_id` and `layer_id` it belongs to. Schedules can be made up of multiple rotations (for example, a primary and a secondary rotation) and each rotation can have several layers, and we return entries for every rotation and layer on the schedule.  The endpoint returns all entries that overlap with the given window. If no window is provided we default to a sensible range starting from now.  ## Pagination  Responses are paginated. When more entries are available than fit on a single page, the response includes a `pagination_meta` block with two fields:  - `after_url` — a fully-formed URL for the next page. The simplest way   to paginate is to keep following this URL until it is no longer present. - `after` — an opaque cursor token. To fetch the next page manually,   re-issue the request with `entry_window_start` set to this value and   `entry_window_end` left unchanged from the original request. Treat   the token as opaque — do not parse or modify it.  Keep paginating until `pagination_meta` is absent from the response, at which point you have received every entry in the window.
+     * List the schedule entries for a schedule over a window of time.  Use this endpoint to find out who is on-call for a schedule, either right now or at any point in the future. Common uses include:  - Building a calendar or timeline view of who is on-call. - Looking up who was on-call at a particular moment (for example, when an   incident fired). - Exporting upcoming shifts into another system, such as a payroll or   scheduling tool.  The response groups entries into three lists: `scheduled` (the entries the rotation rules produce, before any overrides), `overrides` (any one-off overrides that apply in the window) and `final` (the effective schedule after overrides have been merged in — this is normally the list you want).  Each entry includes the `rotation_id` it belongs to. Schedules can be made up of multiple rotations (for example, a primary and a secondary rotation) and each rotation can have several layers, and we return entries for every rotation and layer on the schedule.  The endpoint returns all entries that overlap with the given window. If no window is provided we default to a sensible range starting from now.  ## Pagination  Responses are paginated. When more entries are available than fit on a single page, the response includes a `pagination_meta` block with two fields:  - `after_url` — a fully-formed URL for the next page. The simplest way   to paginate is to keep following this URL until it is no longer present. - `after` — an opaque cursor token. To fetch the next page manually,   re-issue the request with `entry_window_start` set to this value and   `entry_window_end` left unchanged from the original request. Treat   the token as opaque — do not parse or modify it.  Keep paginating until `pagination_meta` is absent from the response, at which point you have received every entry in the window.
      * ListScheduleEntries Schedules V2
      */
     async schedulesV2ListScheduleEntries(requestParameters, initOverrides) {

package/dist/cjs/models/AuditLogsOnCallNotificationPauseResumedV1.d.ts

@@ -0,0 +1,58 @@
+/**
+ * incident.io
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: 1.0.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 type { AuditLogActorV2 } from './AuditLogActorV2.js';
+import type { AuditLogOnCallNotificationPauseMetadataV2 } from './AuditLogOnCallNotificationPauseMetadataV2.js';
+import type { AuditLogEntryContextV2 } from './AuditLogEntryContextV2.js';
+import type { AuditLogTargetV2 } from './AuditLogTargetV2.js';
+/**
+ *
+ * @export
+ * @interface AuditLogsOnCallNotificationPauseResumedV1
+ */
+export interface AuditLogsOnCallNotificationPauseResumedV1 {
+    /**
+     * The type of log entry that this is
+     */
+    action: string;
+    /**
+     *
+     */
+    actor: AuditLogActorV2;
+    /**
+     *
+     */
+    context: AuditLogEntryContextV2;
+    /**
+     *
+     */
+    metadata: AuditLogOnCallNotificationPauseMetadataV2;
+    /**
+     * When the entry occurred
+     */
+    occurred_at: Date;
+    /**
+     * The custom field that was created
+     */
+    targets: Array<AuditLogTargetV2>;
+    /**
+     * Which version the event is
+     */
+    version: number;
+}
+/**
+ * Check if a given object implements the AuditLogsOnCallNotificationPauseResumedV1 interface.
+ */
+export declare function instanceOfAuditLogsOnCallNotificationPauseResumedV1(value: object): value is AuditLogsOnCallNotificationPauseResumedV1;
+export declare function AuditLogsOnCallNotificationPauseResumedV1FromJSON(json: any): AuditLogsOnCallNotificationPauseResumedV1;
+export declare function AuditLogsOnCallNotificationPauseResumedV1FromJSONTyped(json: any, ignoreDiscriminator: boolean): AuditLogsOnCallNotificationPauseResumedV1;
+export declare function AuditLogsOnCallNotificationPauseResumedV1ToJSON(json: any): AuditLogsOnCallNotificationPauseResumedV1;
+export declare function AuditLogsOnCallNotificationPauseResumedV1ToJSONTyped(value?: AuditLogsOnCallNotificationPauseResumedV1 | null, ignoreDiscriminator?: boolean): any;

package/dist/cjs/models/AuditLogsOnCallNotificationPauseResumedV1.js

@@ -0,0 +1,79 @@
+"use strict";
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * incident.io
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instanceOfAuditLogsOnCallNotificationPauseResumedV1 = instanceOfAuditLogsOnCallNotificationPauseResumedV1;
+exports.AuditLogsOnCallNotificationPauseResumedV1FromJSON = AuditLogsOnCallNotificationPauseResumedV1FromJSON;
+exports.AuditLogsOnCallNotificationPauseResumedV1FromJSONTyped = AuditLogsOnCallNotificationPauseResumedV1FromJSONTyped;
+exports.AuditLogsOnCallNotificationPauseResumedV1ToJSON = AuditLogsOnCallNotificationPauseResumedV1ToJSON;
+exports.AuditLogsOnCallNotificationPauseResumedV1ToJSONTyped = AuditLogsOnCallNotificationPauseResumedV1ToJSONTyped;
+const runtime_js_1 = require("../runtime.js");
+const AuditLogActorV2_js_1 = require("./AuditLogActorV2.js");
+const AuditLogOnCallNotificationPauseMetadataV2_js_1 = require("./AuditLogOnCallNotificationPauseMetadataV2.js");
+const AuditLogEntryContextV2_js_1 = require("./AuditLogEntryContextV2.js");
+const AuditLogTargetV2_js_1 = require("./AuditLogTargetV2.js");
+/**
+ * Check if a given object implements the AuditLogsOnCallNotificationPauseResumedV1 interface.
+ */
+function instanceOfAuditLogsOnCallNotificationPauseResumedV1(value) {
+    if (!('action' in value) || value['action'] === undefined)
+        return false;
+    if (!('actor' in value) || value['actor'] === undefined)
+        return false;
+    if (!('context' in value) || value['context'] === undefined)
+        return false;
+    if (!('metadata' in value) || value['metadata'] === undefined)
+        return false;
+    if (!('occurred_at' in value) || value['occurred_at'] === undefined)
+        return false;
+    if (!('targets' in value) || value['targets'] === undefined)
+        return false;
+    if (!('version' in value) || value['version'] === undefined)
+        return false;
+    return true;
+}
+function AuditLogsOnCallNotificationPauseResumedV1FromJSON(json) {
+    return AuditLogsOnCallNotificationPauseResumedV1FromJSONTyped(json, false);
+}
+function AuditLogsOnCallNotificationPauseResumedV1FromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'action': json['action'],
+        'actor': (0, AuditLogActorV2_js_1.AuditLogActorV2FromJSON)(json['actor']),
+        'context': (0, AuditLogEntryContextV2_js_1.AuditLogEntryContextV2FromJSON)(json['context']),
+        'metadata': (0, AuditLogOnCallNotificationPauseMetadataV2_js_1.AuditLogOnCallNotificationPauseMetadataV2FromJSON)(json['metadata']),
+        'occurred_at': (json['occurred_at'] == null ? json['occurred_at'] : (0, runtime_js_1.parseDateTime)(json['occurred_at'])),
+        'targets': (json['targets'].map(AuditLogTargetV2_js_1.AuditLogTargetV2FromJSON)),
+        'version': json['version'],
+    };
+}
+function AuditLogsOnCallNotificationPauseResumedV1ToJSON(json) {
+    return AuditLogsOnCallNotificationPauseResumedV1ToJSONTyped(json, false);
+}
+function AuditLogsOnCallNotificationPauseResumedV1ToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'action': value['action'],
+        'actor': (0, AuditLogActorV2_js_1.AuditLogActorV2ToJSON)(value['actor']),
+        'context': (0, AuditLogEntryContextV2_js_1.AuditLogEntryContextV2ToJSON)(value['context']),
+        'metadata': (0, AuditLogOnCallNotificationPauseMetadataV2_js_1.AuditLogOnCallNotificationPauseMetadataV2ToJSON)(value['metadata']),
+        'occurred_at': value['occurred_at'] == null ? value['occurred_at'] : (0, runtime_js_1.serializeDateTime)(value['occurred_at']),
+        'targets': (value['targets'].map(AuditLogTargetV2_js_1.AuditLogTargetV2ToJSON)),
+        'version': value['version'],
+    };
+}

package/dist/cjs/models/ScheduleEntryV2.d.ts

@@ -12,11 +12,10 @@
 import type { UserV2 } from './UserV2.js';
 /**
  * A single shift on a schedule, representing who is on-call between a start
- * and end time. When present, `rotation_id` and `layer_id` tell you which
- * rotation and which layer within that rotation the entry belongs to. A
- * schedule may have multiple rotations (for example, a primary and a secondary
- * rotation) and each rotation can be made up of several layers — entries are
- * returned for every rotation and layer on the schedule.
+ * and end time. When present, `rotation_id` tells you which rotation the
+ * entry belongs to. A schedule may have multiple rotations (for example, a
+ * primary and a secondary rotation) and each rotation can be made up of several
+ * layers — entries are returned for every rotation and layer on the schedule.
  *
  * Entries come from two places: they are either generated from a schedule's
  * rotation configuration (the regular pattern of who is on-call) or created by
@@ -46,10 +45,6 @@ export interface ScheduleEntryV2 {
      * A unique identifier for this entry, used to determine a unique shift
      */
     fingerprint?: string;
-    /**
-     * If present, the layer this entry applies to on the rotation
-     */
-    layer_id?: string;
     /**
      * If present, the rotation this entry applies to on the schedule
      */

package/dist/cjs/models/ScheduleEntryV2.js

@@ -41,7 +41,6 @@ function ScheduleEntryV2FromJSONTyped(json, ignoreDiscriminator) {
         'end_at': (json['end_at'] == null ? json['end_at'] : (0, runtime_js_1.parseDateTime)(json['end_at'])),
         'entry_id': json['entry_id'] == null ? undefined : json['entry_id'],
         'fingerprint': json['fingerprint'] == null ? undefined : json['fingerprint'],
-        'layer_id': json['layer_id'] == null ? undefined : json['layer_id'],
         'rotation_id': json['rotation_id'] == null ? undefined : json['rotation_id'],
         'start_at': (json['start_at'] == null ? json['start_at'] : (0, runtime_js_1.parseDateTime)(json['start_at'])),
         'user': json['user'] == null ? undefined : (0, UserV2_js_1.UserV2FromJSON)(json['user']),
@@ -58,7 +57,6 @@ function ScheduleEntryV2ToJSONTyped(value, ignoreDiscriminator = false) {
         'end_at': value['end_at'] == null ? value['end_at'] : (0, runtime_js_1.serializeDateTime)(value['end_at']),
         'entry_id': value['entry_id'],
         'fingerprint': value['fingerprint'],
-        'layer_id': value['layer_id'],
         'rotation_id': value['rotation_id'],
         'start_at': value['start_at'] == null ? value['start_at'] : (0, runtime_js_1.serializeDateTime)(value['start_at']),
         'user': (0, UserV2_js_1.UserV2ToJSON)(value['user']),

package/dist/cjs/models/index.d.ts

@@ -351,6 +351,7 @@ export * from './AuditLogsOnCallNotificationPauseCreatedV1.js';
 export * from './AuditLogsOnCallNotificationPauseCreatedV2.js';
 export * from './AuditLogsOnCallNotificationPauseDeletedV1.js';
 export * from './AuditLogsOnCallNotificationPauseDeletedV2.js';
+export * from './AuditLogsOnCallNotificationPauseResumedV1.js';
 export * from './AuditLogsOnCallNotificationPauseUpdatedV1.js';
 export * from './AuditLogsOnCallNotificationPauseUpdatedV2.js';
 export * from './AuditLogsOnCallUpsellRequestedV1.js';

package/dist/cjs/models/index.js

@@ -369,6 +369,7 @@ __exportStar(require("./AuditLogsOnCallNotificationPauseCreatedV1.js"), exports)
 __exportStar(require("./AuditLogsOnCallNotificationPauseCreatedV2.js"), exports);
 __exportStar(require("./AuditLogsOnCallNotificationPauseDeletedV1.js"), exports);
 __exportStar(require("./AuditLogsOnCallNotificationPauseDeletedV2.js"), exports);
+__exportStar(require("./AuditLogsOnCallNotificationPauseResumedV1.js"), exports);
 __exportStar(require("./AuditLogsOnCallNotificationPauseUpdatedV1.js"), exports);
 __exportStar(require("./AuditLogsOnCallNotificationPauseUpdatedV2.js"), exports);
 __exportStar(require("./AuditLogsOnCallUpsellRequestedV1.js"), exports);

package/dist/cjs/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "1.2.0";
+export declare const VERSION = "2.0.0";

package/dist/cjs/version.js

@@ -2,4 +2,4 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.VERSION = void 0;
 // Written by `make build` from package.json. Do not edit.
-exports.VERSION = "1.2.0";
+exports.VERSION = "2.0.0";

package/dist/esm/apis/SchedulesV2Api.d.ts

@@ -390,12 +390,12 @@ export declare class SchedulesV2Api extends runtime.BaseAPI {
      */
     schedulesV2ListScheduleEntriesRequestOpts(requestParameters: SchedulesV2ListScheduleEntriesRequest): Promise<runtime.RequestOpts>;
     /**
-     * List the schedule entries for a schedule over a window of time.  Use this endpoint to find out who is on-call for a schedule, either right now or at any point in the future. Common uses include:  - Building a calendar or timeline view of who is on-call. - Looking up who was on-call at a particular moment (for example, when an   incident fired). - Exporting upcoming shifts into another system, such as a payroll or   scheduling tool.  The response groups entries into three lists: `scheduled` (the entries the rotation rules produce, before any overrides), `overrides` (any one-off overrides that apply in the window) and `final` (the effective schedule after overrides have been merged in — this is normally the list you want).  Each entry includes the `rotation_id` and `layer_id` it belongs to. Schedules can be made up of multiple rotations (for example, a primary and a secondary rotation) and each rotation can have several layers, and we return entries for every rotation and layer on the schedule.  The endpoint returns all entries that overlap with the given window. If no window is provided we default to a sensible range starting from now.  ## Pagination  Responses are paginated. When more entries are available than fit on a single page, the response includes a `pagination_meta` block with two fields:  - `after_url` — a fully-formed URL for the next page. The simplest way   to paginate is to keep following this URL until it is no longer present. - `after` — an opaque cursor token. To fetch the next page manually,   re-issue the request with `entry_window_start` set to this value and   `entry_window_end` left unchanged from the original request. Treat   the token as opaque — do not parse or modify it.  Keep paginating until `pagination_meta` is absent from the response, at which point you have received every entry in the window.
+     * List the schedule entries for a schedule over a window of time.  Use this endpoint to find out who is on-call for a schedule, either right now or at any point in the future. Common uses include:  - Building a calendar or timeline view of who is on-call. - Looking up who was on-call at a particular moment (for example, when an   incident fired). - Exporting upcoming shifts into another system, such as a payroll or   scheduling tool.  The response groups entries into three lists: `scheduled` (the entries the rotation rules produce, before any overrides), `overrides` (any one-off overrides that apply in the window) and `final` (the effective schedule after overrides have been merged in — this is normally the list you want).  Each entry includes the `rotation_id` it belongs to. Schedules can be made up of multiple rotations (for example, a primary and a secondary rotation) and each rotation can have several layers, and we return entries for every rotation and layer on the schedule.  The endpoint returns all entries that overlap with the given window. If no window is provided we default to a sensible range starting from now.  ## Pagination  Responses are paginated. When more entries are available than fit on a single page, the response includes a `pagination_meta` block with two fields:  - `after_url` — a fully-formed URL for the next page. The simplest way   to paginate is to keep following this URL until it is no longer present. - `after` — an opaque cursor token. To fetch the next page manually,   re-issue the request with `entry_window_start` set to this value and   `entry_window_end` left unchanged from the original request. Treat   the token as opaque — do not parse or modify it.  Keep paginating until `pagination_meta` is absent from the response, at which point you have received every entry in the window.
      * ListScheduleEntries Schedules V2
      */
     schedulesV2ListScheduleEntriesRaw(requestParameters: SchedulesV2ListScheduleEntriesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<SchedulesListScheduleEntriesResultV2>>;
     /**
-     * List the schedule entries for a schedule over a window of time.  Use this endpoint to find out who is on-call for a schedule, either right now or at any point in the future. Common uses include:  - Building a calendar or timeline view of who is on-call. - Looking up who was on-call at a particular moment (for example, when an   incident fired). - Exporting upcoming shifts into another system, such as a payroll or   scheduling tool.  The response groups entries into three lists: `scheduled` (the entries the rotation rules produce, before any overrides), `overrides` (any one-off overrides that apply in the window) and `final` (the effective schedule after overrides have been merged in — this is normally the list you want).  Each entry includes the `rotation_id` and `layer_id` it belongs to. Schedules can be made up of multiple rotations (for example, a primary and a secondary rotation) and each rotation can have several layers, and we return entries for every rotation and layer on the schedule.  The endpoint returns all entries that overlap with the given window. If no window is provided we default to a sensible range starting from now.  ## Pagination  Responses are paginated. When more entries are available than fit on a single page, the response includes a `pagination_meta` block with two fields:  - `after_url` — a fully-formed URL for the next page. The simplest way   to paginate is to keep following this URL until it is no longer present. - `after` — an opaque cursor token. To fetch the next page manually,   re-issue the request with `entry_window_start` set to this value and   `entry_window_end` left unchanged from the original request. Treat   the token as opaque — do not parse or modify it.  Keep paginating until `pagination_meta` is absent from the response, at which point you have received every entry in the window.
+     * List the schedule entries for a schedule over a window of time.  Use this endpoint to find out who is on-call for a schedule, either right now or at any point in the future. Common uses include:  - Building a calendar or timeline view of who is on-call. - Looking up who was on-call at a particular moment (for example, when an   incident fired). - Exporting upcoming shifts into another system, such as a payroll or   scheduling tool.  The response groups entries into three lists: `scheduled` (the entries the rotation rules produce, before any overrides), `overrides` (any one-off overrides that apply in the window) and `final` (the effective schedule after overrides have been merged in — this is normally the list you want).  Each entry includes the `rotation_id` it belongs to. Schedules can be made up of multiple rotations (for example, a primary and a secondary rotation) and each rotation can have several layers, and we return entries for every rotation and layer on the schedule.  The endpoint returns all entries that overlap with the given window. If no window is provided we default to a sensible range starting from now.  ## Pagination  Responses are paginated. When more entries are available than fit on a single page, the response includes a `pagination_meta` block with two fields:  - `after_url` — a fully-formed URL for the next page. The simplest way   to paginate is to keep following this URL until it is no longer present. - `after` — an opaque cursor token. To fetch the next page manually,   re-issue the request with `entry_window_start` set to this value and   `entry_window_end` left unchanged from the original request. Treat   the token as opaque — do not parse or modify it.  Keep paginating until `pagination_meta` is absent from the response, at which point you have received every entry in the window.
      * ListScheduleEntries Schedules V2
      */
     schedulesV2ListScheduleEntries(requestParameters: SchedulesV2ListScheduleEntriesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<SchedulesListScheduleEntriesResultV2>;

package/dist/esm/apis/SchedulesV2Api.js

@@ -527,7 +527,7 @@ export class SchedulesV2Api extends runtime.BaseAPI {
         };
     }
     /**
-     * List the schedule entries for a schedule over a window of time.  Use this endpoint to find out who is on-call for a schedule, either right now or at any point in the future. Common uses include:  - Building a calendar or timeline view of who is on-call. - Looking up who was on-call at a particular moment (for example, when an   incident fired). - Exporting upcoming shifts into another system, such as a payroll or   scheduling tool.  The response groups entries into three lists: `scheduled` (the entries the rotation rules produce, before any overrides), `overrides` (any one-off overrides that apply in the window) and `final` (the effective schedule after overrides have been merged in — this is normally the list you want).  Each entry includes the `rotation_id` and `layer_id` it belongs to. Schedules can be made up of multiple rotations (for example, a primary and a secondary rotation) and each rotation can have several layers, and we return entries for every rotation and layer on the schedule.  The endpoint returns all entries that overlap with the given window. If no window is provided we default to a sensible range starting from now.  ## Pagination  Responses are paginated. When more entries are available than fit on a single page, the response includes a `pagination_meta` block with two fields:  - `after_url` — a fully-formed URL for the next page. The simplest way   to paginate is to keep following this URL until it is no longer present. - `after` — an opaque cursor token. To fetch the next page manually,   re-issue the request with `entry_window_start` set to this value and   `entry_window_end` left unchanged from the original request. Treat   the token as opaque — do not parse or modify it.  Keep paginating until `pagination_meta` is absent from the response, at which point you have received every entry in the window.
+     * List the schedule entries for a schedule over a window of time.  Use this endpoint to find out who is on-call for a schedule, either right now or at any point in the future. Common uses include:  - Building a calendar or timeline view of who is on-call. - Looking up who was on-call at a particular moment (for example, when an   incident fired). - Exporting upcoming shifts into another system, such as a payroll or   scheduling tool.  The response groups entries into three lists: `scheduled` (the entries the rotation rules produce, before any overrides), `overrides` (any one-off overrides that apply in the window) and `final` (the effective schedule after overrides have been merged in — this is normally the list you want).  Each entry includes the `rotation_id` it belongs to. Schedules can be made up of multiple rotations (for example, a primary and a secondary rotation) and each rotation can have several layers, and we return entries for every rotation and layer on the schedule.  The endpoint returns all entries that overlap with the given window. If no window is provided we default to a sensible range starting from now.  ## Pagination  Responses are paginated. When more entries are available than fit on a single page, the response includes a `pagination_meta` block with two fields:  - `after_url` — a fully-formed URL for the next page. The simplest way   to paginate is to keep following this URL until it is no longer present. - `after` — an opaque cursor token. To fetch the next page manually,   re-issue the request with `entry_window_start` set to this value and   `entry_window_end` left unchanged from the original request. Treat   the token as opaque — do not parse or modify it.  Keep paginating until `pagination_meta` is absent from the response, at which point you have received every entry in the window.
      * ListScheduleEntries Schedules V2
      */
     async schedulesV2ListScheduleEntriesRaw(requestParameters, initOverrides) {
@@ -536,7 +536,7 @@ export class SchedulesV2Api extends runtime.BaseAPI {
         return new runtime.JSONApiResponse(response, (jsonValue) => SchedulesListScheduleEntriesResultV2FromJSON(jsonValue));
     }
     /**
-     * List the schedule entries for a schedule over a window of time.  Use this endpoint to find out who is on-call for a schedule, either right now or at any point in the future. Common uses include:  - Building a calendar or timeline view of who is on-call. - Looking up who was on-call at a particular moment (for example, when an   incident fired). - Exporting upcoming shifts into another system, such as a payroll or   scheduling tool.  The response groups entries into three lists: `scheduled` (the entries the rotation rules produce, before any overrides), `overrides` (any one-off overrides that apply in the window) and `final` (the effective schedule after overrides have been merged in — this is normally the list you want).  Each entry includes the `rotation_id` and `layer_id` it belongs to. Schedules can be made up of multiple rotations (for example, a primary and a secondary rotation) and each rotation can have several layers, and we return entries for every rotation and layer on the schedule.  The endpoint returns all entries that overlap with the given window. If no window is provided we default to a sensible range starting from now.  ## Pagination  Responses are paginated. When more entries are available than fit on a single page, the response includes a `pagination_meta` block with two fields:  - `after_url` — a fully-formed URL for the next page. The simplest way   to paginate is to keep following this URL until it is no longer present. - `after` — an opaque cursor token. To fetch the next page manually,   re-issue the request with `entry_window_start` set to this value and   `entry_window_end` left unchanged from the original request. Treat   the token as opaque — do not parse or modify it.  Keep paginating until `pagination_meta` is absent from the response, at which point you have received every entry in the window.
+     * List the schedule entries for a schedule over a window of time.  Use this endpoint to find out who is on-call for a schedule, either right now or at any point in the future. Common uses include:  - Building a calendar or timeline view of who is on-call. - Looking up who was on-call at a particular moment (for example, when an   incident fired). - Exporting upcoming shifts into another system, such as a payroll or   scheduling tool.  The response groups entries into three lists: `scheduled` (the entries the rotation rules produce, before any overrides), `overrides` (any one-off overrides that apply in the window) and `final` (the effective schedule after overrides have been merged in — this is normally the list you want).  Each entry includes the `rotation_id` it belongs to. Schedules can be made up of multiple rotations (for example, a primary and a secondary rotation) and each rotation can have several layers, and we return entries for every rotation and layer on the schedule.  The endpoint returns all entries that overlap with the given window. If no window is provided we default to a sensible range starting from now.  ## Pagination  Responses are paginated. When more entries are available than fit on a single page, the response includes a `pagination_meta` block with two fields:  - `after_url` — a fully-formed URL for the next page. The simplest way   to paginate is to keep following this URL until it is no longer present. - `after` — an opaque cursor token. To fetch the next page manually,   re-issue the request with `entry_window_start` set to this value and   `entry_window_end` left unchanged from the original request. Treat   the token as opaque — do not parse or modify it.  Keep paginating until `pagination_meta` is absent from the response, at which point you have received every entry in the window.
      * ListScheduleEntries Schedules V2
      */
     async schedulesV2ListScheduleEntries(requestParameters, initOverrides) {

package/dist/esm/models/AuditLogsOnCallNotificationPauseResumedV1.d.ts

@@ -0,0 +1,58 @@
+/**
+ * incident.io
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: 1.0.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 type { AuditLogActorV2 } from './AuditLogActorV2.js';
+import type { AuditLogOnCallNotificationPauseMetadataV2 } from './AuditLogOnCallNotificationPauseMetadataV2.js';
+import type { AuditLogEntryContextV2 } from './AuditLogEntryContextV2.js';
+import type { AuditLogTargetV2 } from './AuditLogTargetV2.js';
+/**
+ *
+ * @export
+ * @interface AuditLogsOnCallNotificationPauseResumedV1
+ */
+export interface AuditLogsOnCallNotificationPauseResumedV1 {
+    /**
+     * The type of log entry that this is
+     */
+    action: string;
+    /**
+     *
+     */
+    actor: AuditLogActorV2;
+    /**
+     *
+     */
+    context: AuditLogEntryContextV2;
+    /**
+     *
+     */
+    metadata: AuditLogOnCallNotificationPauseMetadataV2;
+    /**
+     * When the entry occurred
+     */
+    occurred_at: Date;
+    /**
+     * The custom field that was created
+     */
+    targets: Array<AuditLogTargetV2>;
+    /**
+     * Which version the event is
+     */
+    version: number;
+}
+/**
+ * Check if a given object implements the AuditLogsOnCallNotificationPauseResumedV1 interface.
+ */
+export declare function instanceOfAuditLogsOnCallNotificationPauseResumedV1(value: object): value is AuditLogsOnCallNotificationPauseResumedV1;
+export declare function AuditLogsOnCallNotificationPauseResumedV1FromJSON(json: any): AuditLogsOnCallNotificationPauseResumedV1;
+export declare function AuditLogsOnCallNotificationPauseResumedV1FromJSONTyped(json: any, ignoreDiscriminator: boolean): AuditLogsOnCallNotificationPauseResumedV1;
+export declare function AuditLogsOnCallNotificationPauseResumedV1ToJSON(json: any): AuditLogsOnCallNotificationPauseResumedV1;
+export declare function AuditLogsOnCallNotificationPauseResumedV1ToJSONTyped(value?: AuditLogsOnCallNotificationPauseResumedV1 | null, ignoreDiscriminator?: boolean): any;

package/dist/esm/models/AuditLogsOnCallNotificationPauseResumedV1.js

@@ -0,0 +1,72 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * incident.io
+ * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
+ *
+ * The version of the OpenAPI document: 1.0.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 { parseDateTime, serializeDateTime } from '../runtime.js';
+import { AuditLogActorV2FromJSON, AuditLogActorV2ToJSON, } from './AuditLogActorV2.js';
+import { AuditLogOnCallNotificationPauseMetadataV2FromJSON, AuditLogOnCallNotificationPauseMetadataV2ToJSON, } from './AuditLogOnCallNotificationPauseMetadataV2.js';
+import { AuditLogEntryContextV2FromJSON, AuditLogEntryContextV2ToJSON, } from './AuditLogEntryContextV2.js';
+import { AuditLogTargetV2FromJSON, AuditLogTargetV2ToJSON, } from './AuditLogTargetV2.js';
+/**
+ * Check if a given object implements the AuditLogsOnCallNotificationPauseResumedV1 interface.
+ */
+export function instanceOfAuditLogsOnCallNotificationPauseResumedV1(value) {
+    if (!('action' in value) || value['action'] === undefined)
+        return false;
+    if (!('actor' in value) || value['actor'] === undefined)
+        return false;
+    if (!('context' in value) || value['context'] === undefined)
+        return false;
+    if (!('metadata' in value) || value['metadata'] === undefined)
+        return false;
+    if (!('occurred_at' in value) || value['occurred_at'] === undefined)
+        return false;
+    if (!('targets' in value) || value['targets'] === undefined)
+        return false;
+    if (!('version' in value) || value['version'] === undefined)
+        return false;
+    return true;
+}
+export function AuditLogsOnCallNotificationPauseResumedV1FromJSON(json) {
+    return AuditLogsOnCallNotificationPauseResumedV1FromJSONTyped(json, false);
+}
+export function AuditLogsOnCallNotificationPauseResumedV1FromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'action': json['action'],
+        'actor': AuditLogActorV2FromJSON(json['actor']),
+        'context': AuditLogEntryContextV2FromJSON(json['context']),
+        'metadata': AuditLogOnCallNotificationPauseMetadataV2FromJSON(json['metadata']),
+        'occurred_at': (json['occurred_at'] == null ? json['occurred_at'] : parseDateTime(json['occurred_at'])),
+        'targets': (json['targets'].map(AuditLogTargetV2FromJSON)),
+        'version': json['version'],
+    };
+}
+export function AuditLogsOnCallNotificationPauseResumedV1ToJSON(json) {
+    return AuditLogsOnCallNotificationPauseResumedV1ToJSONTyped(json, false);
+}
+export function AuditLogsOnCallNotificationPauseResumedV1ToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'action': value['action'],
+        'actor': AuditLogActorV2ToJSON(value['actor']),
+        'context': AuditLogEntryContextV2ToJSON(value['context']),
+        'metadata': AuditLogOnCallNotificationPauseMetadataV2ToJSON(value['metadata']),
+        'occurred_at': value['occurred_at'] == null ? value['occurred_at'] : serializeDateTime(value['occurred_at']),
+        'targets': (value['targets'].map(AuditLogTargetV2ToJSON)),
+        'version': value['version'],
+    };
+}

package/dist/esm/models/ScheduleEntryV2.d.ts

@@ -12,11 +12,10 @@
 import type { UserV2 } from './UserV2.js';
 /**
  * A single shift on a schedule, representing who is on-call between a start
- * and end time. When present, `rotation_id` and `layer_id` tell you which
- * rotation and which layer within that rotation the entry belongs to. A
- * schedule may have multiple rotations (for example, a primary and a secondary
- * rotation) and each rotation can be made up of several layers — entries are
- * returned for every rotation and layer on the schedule.
+ * and end time. When present, `rotation_id` tells you which rotation the
+ * entry belongs to. A schedule may have multiple rotations (for example, a
+ * primary and a secondary rotation) and each rotation can be made up of several
+ * layers — entries are returned for every rotation and layer on the schedule.
  *
  * Entries come from two places: they are either generated from a schedule's
  * rotation configuration (the regular pattern of who is on-call) or created by
@@ -46,10 +45,6 @@ export interface ScheduleEntryV2 {
      * A unique identifier for this entry, used to determine a unique shift
      */
     fingerprint?: string;
-    /**
-     * If present, the layer this entry applies to on the rotation
-     */
-    layer_id?: string;
     /**
      * If present, the rotation this entry applies to on the schedule
      */

package/dist/esm/models/ScheduleEntryV2.js

@@ -34,7 +34,6 @@ export function ScheduleEntryV2FromJSONTyped(json, ignoreDiscriminator) {
         'end_at': (json['end_at'] == null ? json['end_at'] : parseDateTime(json['end_at'])),
         'entry_id': json['entry_id'] == null ? undefined : json['entry_id'],
         'fingerprint': json['fingerprint'] == null ? undefined : json['fingerprint'],
-        'layer_id': json['layer_id'] == null ? undefined : json['layer_id'],
         'rotation_id': json['rotation_id'] == null ? undefined : json['rotation_id'],
         'start_at': (json['start_at'] == null ? json['start_at'] : parseDateTime(json['start_at'])),
         'user': json['user'] == null ? undefined : UserV2FromJSON(json['user']),
@@ -51,7 +50,6 @@ export function ScheduleEntryV2ToJSONTyped(value, ignoreDiscriminator = false) {
         'end_at': value['end_at'] == null ? value['end_at'] : serializeDateTime(value['end_at']),
         'entry_id': value['entry_id'],
         'fingerprint': value['fingerprint'],
-        'layer_id': value['layer_id'],
         'rotation_id': value['rotation_id'],
         'start_at': value['start_at'] == null ? value['start_at'] : serializeDateTime(value['start_at']),
         'user': UserV2ToJSON(value['user']),

package/dist/esm/models/index.d.ts

@@ -351,6 +351,7 @@ export * from './AuditLogsOnCallNotificationPauseCreatedV1.js';
 export * from './AuditLogsOnCallNotificationPauseCreatedV2.js';
 export * from './AuditLogsOnCallNotificationPauseDeletedV1.js';
 export * from './AuditLogsOnCallNotificationPauseDeletedV2.js';
+export * from './AuditLogsOnCallNotificationPauseResumedV1.js';
 export * from './AuditLogsOnCallNotificationPauseUpdatedV1.js';
 export * from './AuditLogsOnCallNotificationPauseUpdatedV2.js';
 export * from './AuditLogsOnCallUpsellRequestedV1.js';

package/dist/esm/models/index.js

@@ -353,6 +353,7 @@ export * from './AuditLogsOnCallNotificationPauseCreatedV1.js';
 export * from './AuditLogsOnCallNotificationPauseCreatedV2.js';
 export * from './AuditLogsOnCallNotificationPauseDeletedV1.js';
 export * from './AuditLogsOnCallNotificationPauseDeletedV2.js';
+export * from './AuditLogsOnCallNotificationPauseResumedV1.js';
 export * from './AuditLogsOnCallNotificationPauseUpdatedV1.js';
 export * from './AuditLogsOnCallNotificationPauseUpdatedV2.js';
 export * from './AuditLogsOnCallUpsellRequestedV1.js';

package/dist/esm/version.d.ts

@@ -1 +1 @@
-export declare const VERSION = "1.2.0";
+export declare const VERSION = "2.0.0";

package/dist/esm/version.js

@@ -1,2 +1,2 @@
 // Written by `make build` from package.json. Do not edit.
-export const VERSION = "1.2.0";
+export const VERSION = "2.0.0";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@incident-io/sdk",
-  "version": "1.2.0",
+  "version": "2.0.0",
   "description": "TypeScript SDK for the incident.io API",
   "license": "MIT",
   "author": "incident.io <support@incident.io>",