sailpoint-api-client 1.8.3 → 1.8.5

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/v2025/api.ts CHANGED
@@ -17166,11 +17166,17 @@ export interface DkimAttributesV2025 {
17166
17166
  */
17167
17167
  'dkimTokens'?: Array<string>;
17168
17168
  /**
17169
- * The current status if the domain /identity has been verified. Ie Success, Failed, Pending
17169
+ * The current status if the domain /identity has been verified. Ie SUCCESS, FAILED, PENDING
17170
17170
  * @type {string}
17171
17171
  * @memberof DkimAttributesV2025
17172
17172
  */
17173
17173
  'dkimVerificationStatus'?: string;
17174
+ /**
17175
+ * The AWS SES region the domain is associated with
17176
+ * @type {string}
17177
+ * @memberof DkimAttributesV2025
17178
+ */
17179
+ 'region'?: string;
17174
17180
  }
17175
17181
  /**
17176
17182
  *
@@ -17262,10 +17268,10 @@ export interface DomainStatusDtoV2025 {
17262
17268
  'domain'?: string;
17263
17269
  /**
17264
17270
  * DKIM is enabled for this domain
17265
- * @type {object}
17271
+ * @type {boolean}
17266
17272
  * @memberof DomainStatusDtoV2025
17267
17273
  */
17268
- 'dkimEnabled'?: object;
17274
+ 'dkimEnabled'?: boolean;
17269
17275
  /**
17270
17276
  * DKIM tokens required for authentication
17271
17277
  * @type {Array<string>}
@@ -17278,6 +17284,12 @@ export interface DomainStatusDtoV2025 {
17278
17284
  * @memberof DomainStatusDtoV2025
17279
17285
  */
17280
17286
  'dkimVerificationStatus'?: string;
17287
+ /**
17288
+ * The AWS SES region the domain is associated with
17289
+ * @type {string}
17290
+ * @memberof DomainStatusDtoV2025
17291
+ */
17292
+ 'region'?: string;
17281
17293
  }
17282
17294
  /**
17283
17295
  *
@@ -17517,35 +17529,42 @@ export interface EmailNotificationOptionV2025 {
17517
17529
  */
17518
17530
  export interface EmailStatusDtoV2025 {
17519
17531
  /**
17520
- *
17532
+ * Unique identifier for the verified sender address
17521
17533
  * @type {string}
17522
17534
  * @memberof EmailStatusDtoV2025
17523
17535
  */
17524
17536
  'id'?: string | null;
17525
17537
  /**
17526
- *
17538
+ * The verified sender email address
17527
17539
  * @type {string}
17528
17540
  * @memberof EmailStatusDtoV2025
17529
17541
  */
17530
17542
  'email'?: string;
17531
17543
  /**
17532
- *
17544
+ * Whether the sender address is verified by domain
17533
17545
  * @type {boolean}
17534
17546
  * @memberof EmailStatusDtoV2025
17535
17547
  */
17536
17548
  'isVerifiedByDomain'?: boolean;
17537
17549
  /**
17538
- *
17550
+ * The verification status of the sender address
17539
17551
  * @type {string}
17540
17552
  * @memberof EmailStatusDtoV2025
17541
17553
  */
17542
17554
  'verificationStatus'?: EmailStatusDtoV2025VerificationStatusV2025;
17555
+ /**
17556
+ * The AWS SES region the sender address is associated with
17557
+ * @type {string}
17558
+ * @memberof EmailStatusDtoV2025
17559
+ */
17560
+ 'region'?: string | null;
17543
17561
  }
17544
17562
 
17545
17563
  export const EmailStatusDtoV2025VerificationStatusV2025 = {
17546
17564
  Pending: 'PENDING',
17547
17565
  Success: 'SUCCESS',
17548
- Failed: 'FAILED'
17566
+ Failed: 'FAILED',
17567
+ Na: 'NA'
17549
17568
  } as const;
17550
17569
 
17551
17570
  export type EmailStatusDtoV2025VerificationStatusV2025 = typeof EmailStatusDtoV2025VerificationStatusV2025[keyof typeof EmailStatusDtoV2025VerificationStatusV2025];
@@ -18457,6 +18476,12 @@ export interface EntitlementV2025 {
18457
18476
  * @memberof EntitlementV2025
18458
18477
  */
18459
18478
  'owner'?: EntitlementOwnerV2025 | null;
18479
+ /**
18480
+ * List of additional owner references beyond the primary owner. Each entry may be an identity (IDENTITY) or a governance group (GOVERNANCE_GROUP).
18481
+ * @type {Array<AdditionalOwnerRefV2025>}
18482
+ * @memberof EntitlementV2025
18483
+ */
18484
+ 'additionalOwners'?: Array<AdditionalOwnerRefV2025> | null;
18460
18485
  /**
18461
18486
  * A map of entitlement fields that have been manually updated. The key is the field name in UPPER_SNAKE_CASE format, and the value is true or false to indicate if the field has been updated.
18462
18487
  * @type {{ [key: string]: any; }}
@@ -20883,11 +20908,29 @@ export interface FullDiscoveredApplicationsV2025 {
20883
20908
  */
20884
20909
  'environment'?: string;
20885
20910
  /**
20886
- * The risk score of the application.
20911
+ * The risk score of the application ranging from 0-100, 100 being highest risk.
20912
+ * @type {number}
20913
+ * @memberof FullDiscoveredApplicationsV2025
20914
+ */
20915
+ 'riskScore'?: number;
20916
+ /**
20917
+ * Indicates whether the application is used for business purposes.
20918
+ * @type {boolean}
20919
+ * @memberof FullDiscoveredApplicationsV2025
20920
+ */
20921
+ 'isBusiness'?: boolean;
20922
+ /**
20923
+ * The total number of sign-in accounts for the application.
20924
+ * @type {number}
20925
+ * @memberof FullDiscoveredApplicationsV2025
20926
+ */
20927
+ 'totalSigninsCount'?: number;
20928
+ /**
20929
+ * The risk level of the application.
20887
20930
  * @type {string}
20888
20931
  * @memberof FullDiscoveredApplicationsV2025
20889
20932
  */
20890
- 'riskScore'?: string;
20933
+ 'riskLevel'?: FullDiscoveredApplicationsV2025RiskLevelV2025;
20891
20934
  /**
20892
20935
  * Indicates whether the application has privileged access.
20893
20936
  * @type {boolean}
@@ -20907,6 +20950,15 @@ export interface FullDiscoveredApplicationsV2025 {
20907
20950
  */
20908
20951
  'attributes'?: object;
20909
20952
  }
20953
+
20954
+ export const FullDiscoveredApplicationsV2025RiskLevelV2025 = {
20955
+ High: 'High',
20956
+ Medium: 'Medium',
20957
+ Low: 'Low'
20958
+ } as const;
20959
+
20960
+ export type FullDiscoveredApplicationsV2025RiskLevelV2025 = typeof FullDiscoveredApplicationsV2025RiskLevelV2025[keyof typeof FullDiscoveredApplicationsV2025RiskLevelV2025];
20961
+
20910
20962
  /**
20911
20963
  *
20912
20964
  * @export
@@ -29595,15 +29647,13 @@ export interface MatchTermV2025 {
29595
29647
  'children'?: Array<{ [key: string]: any; }> | null;
29596
29648
  }
29597
29649
  /**
29598
- *
29650
+ * The notification medium (EMAIL, SLACK, or TEAMS)
29599
29651
  * @export
29600
29652
  * @enum {string}
29601
29653
  */
29602
29654
 
29603
29655
  export const MediumV2025 = {
29604
29656
  Email: 'EMAIL',
29605
- Sms: 'SMS',
29606
- Phone: 'PHONE',
29607
29657
  Slack: 'SLACK',
29608
29658
  Teams: 'TEAMS'
29609
29659
  } as const;
@@ -43760,12 +43810,36 @@ export interface SendTestNotificationRequestDtoV2025 {
43760
43810
  * @memberof SendTestNotificationRequestDtoV2025
43761
43811
  */
43762
43812
  'medium'?: SendTestNotificationRequestDtoV2025MediumV2025;
43813
+ /**
43814
+ * The locale for the message text.
43815
+ * @type {string}
43816
+ * @memberof SendTestNotificationRequestDtoV2025
43817
+ */
43818
+ 'locale'?: string;
43763
43819
  /**
43764
43820
  * A Json object that denotes the context specific to the template.
43765
43821
  * @type {object}
43766
43822
  * @memberof SendTestNotificationRequestDtoV2025
43767
43823
  */
43768
43824
  'context'?: object;
43825
+ /**
43826
+ * A list of override recipient email addresses for the test notification.
43827
+ * @type {Array<string>}
43828
+ * @memberof SendTestNotificationRequestDtoV2025
43829
+ */
43830
+ 'recipientEmailList'?: Array<string>;
43831
+ /**
43832
+ * A list of CC email addresses for the test notification.
43833
+ * @type {Array<string>}
43834
+ * @memberof SendTestNotificationRequestDtoV2025
43835
+ */
43836
+ 'carbonCopy'?: Array<string>;
43837
+ /**
43838
+ * A list of BCC email addresses for the test notification.
43839
+ * @type {Array<string>}
43840
+ * @memberof SendTestNotificationRequestDtoV2025
43841
+ */
43842
+ 'blindCarbonCopy'?: Array<string>;
43769
43843
  }
43770
43844
 
43771
43845
  export const SendTestNotificationRequestDtoV2025MediumV2025 = {
@@ -44572,11 +44646,29 @@ export interface SlimDiscoveredApplicationsV2025 {
44572
44646
  */
44573
44647
  'environment'?: string;
44574
44648
  /**
44575
- * The risk score of the application.
44649
+ * The risk score of the application ranging from 0-100, 100 being highest risk.
44650
+ * @type {number}
44651
+ * @memberof SlimDiscoveredApplicationsV2025
44652
+ */
44653
+ 'riskScore'?: number;
44654
+ /**
44655
+ * Indicates whether the application is used for business purposes.
44656
+ * @type {boolean}
44657
+ * @memberof SlimDiscoveredApplicationsV2025
44658
+ */
44659
+ 'isBusiness'?: boolean;
44660
+ /**
44661
+ * The total number of sign-in accounts for the application.
44662
+ * @type {number}
44663
+ * @memberof SlimDiscoveredApplicationsV2025
44664
+ */
44665
+ 'totalSigninsCount'?: number;
44666
+ /**
44667
+ * The risk level of the application.
44576
44668
  * @type {string}
44577
44669
  * @memberof SlimDiscoveredApplicationsV2025
44578
44670
  */
44579
- 'riskScore'?: string;
44671
+ 'riskLevel'?: SlimDiscoveredApplicationsV2025RiskLevelV2025;
44580
44672
  /**
44581
44673
  * Indicates whether the application has privileged access.
44582
44674
  * @type {boolean}
@@ -44596,6 +44688,15 @@ export interface SlimDiscoveredApplicationsV2025 {
44596
44688
  */
44597
44689
  'attributes'?: object;
44598
44690
  }
44691
+
44692
+ export const SlimDiscoveredApplicationsV2025RiskLevelV2025 = {
44693
+ High: 'High',
44694
+ Medium: 'Medium',
44695
+ Low: 'Low'
44696
+ } as const;
44697
+
44698
+ export type SlimDiscoveredApplicationsV2025RiskLevelV2025 = typeof SlimDiscoveredApplicationsV2025RiskLevelV2025[keyof typeof SlimDiscoveredApplicationsV2025RiskLevelV2025];
44699
+
44599
44700
  /**
44600
44701
  * Details of the Entitlement criteria
44601
44702
  * @export
@@ -47517,6 +47618,25 @@ export const StandardLevelV2025 = {
47517
47618
  export type StandardLevelV2025 = typeof StandardLevelV2025[keyof typeof StandardLevelV2025];
47518
47619
 
47519
47620
 
47621
+ /**
47622
+ *
47623
+ * @export
47624
+ * @interface StartApplicationDiscovery403ResponseOneOfV2025
47625
+ */
47626
+ export interface StartApplicationDiscovery403ResponseOneOfV2025 {
47627
+ /**
47628
+ * Error message when quota is exceeded
47629
+ * @type {string}
47630
+ * @memberof StartApplicationDiscovery403ResponseOneOfV2025
47631
+ */
47632
+ 'error': string;
47633
+ }
47634
+ /**
47635
+ * @type StartApplicationDiscovery403ResponseV2025
47636
+ * @export
47637
+ */
47638
+ export type StartApplicationDiscovery403ResponseV2025 = ErrorResponseDtoV2025 | StartApplicationDiscovery403ResponseOneOfV2025;
47639
+
47520
47640
  /**
47521
47641
  *
47522
47642
  * @export
@@ -48879,13 +48999,13 @@ export type TaskStatusV2025CompletionStatusV2025 = typeof TaskStatusV2025Complet
48879
48999
  */
48880
49000
  export interface TemplateBulkDeleteDtoV2025 {
48881
49001
  /**
48882
- *
49002
+ * The template key to delete
48883
49003
  * @type {string}
48884
49004
  * @memberof TemplateBulkDeleteDtoV2025
48885
49005
  */
48886
49006
  'key': string;
48887
49007
  /**
48888
- *
49008
+ * The notification medium (EMAIL, SLACK, or TEAMS)
48889
49009
  * @type {string}
48890
49010
  * @memberof TemplateBulkDeleteDtoV2025
48891
49011
  */
@@ -48900,8 +49020,8 @@ export interface TemplateBulkDeleteDtoV2025 {
48900
49020
 
48901
49021
  export const TemplateBulkDeleteDtoV2025MediumV2025 = {
48902
49022
  Email: 'EMAIL',
48903
- Phone: 'PHONE',
48904
- Sms: 'SMS'
49023
+ Slack: 'SLACK',
49024
+ Teams: 'TEAMS'
48905
49025
  } as const;
48906
49026
 
48907
49027
  export type TemplateBulkDeleteDtoV2025MediumV2025 = typeof TemplateBulkDeleteDtoV2025MediumV2025[keyof typeof TemplateBulkDeleteDtoV2025MediumV2025];
@@ -48996,14 +49116,158 @@ export interface TemplateDtoDefaultV2025 {
48996
49116
 
48997
49117
  export const TemplateDtoDefaultV2025MediumV2025 = {
48998
49118
  Email: 'EMAIL',
48999
- Phone: 'PHONE',
49000
- Sms: 'SMS',
49001
49119
  Slack: 'SLACK',
49002
49120
  Teams: 'TEAMS'
49003
49121
  } as const;
49004
49122
 
49005
49123
  export type TemplateDtoDefaultV2025MediumV2025 = typeof TemplateDtoDefaultV2025MediumV2025[keyof typeof TemplateDtoDefaultV2025MediumV2025];
49006
49124
 
49125
+ /**
49126
+ *
49127
+ * @export
49128
+ * @interface TemplateDtoSlackTemplateV2025
49129
+ */
49130
+ export interface TemplateDtoSlackTemplateV2025 {
49131
+ /**
49132
+ * The template key
49133
+ * @type {string}
49134
+ * @memberof TemplateDtoSlackTemplateV2025
49135
+ */
49136
+ 'key'?: string | null;
49137
+ /**
49138
+ * The main text content of the Slack message
49139
+ * @type {string}
49140
+ * @memberof TemplateDtoSlackTemplateV2025
49141
+ */
49142
+ 'text'?: string;
49143
+ /**
49144
+ * JSON string of Slack Block Kit blocks for rich formatting
49145
+ * @type {string}
49146
+ * @memberof TemplateDtoSlackTemplateV2025
49147
+ */
49148
+ 'blocks'?: string | null;
49149
+ /**
49150
+ * JSON string of Slack attachments
49151
+ * @type {string}
49152
+ * @memberof TemplateDtoSlackTemplateV2025
49153
+ */
49154
+ 'attachments'?: string;
49155
+ /**
49156
+ * The type of notification
49157
+ * @type {string}
49158
+ * @memberof TemplateDtoSlackTemplateV2025
49159
+ */
49160
+ 'notificationType'?: string | null;
49161
+ /**
49162
+ * The approval request ID
49163
+ * @type {string}
49164
+ * @memberof TemplateDtoSlackTemplateV2025
49165
+ */
49166
+ 'approvalId'?: string | null;
49167
+ /**
49168
+ * The request ID
49169
+ * @type {string}
49170
+ * @memberof TemplateDtoSlackTemplateV2025
49171
+ */
49172
+ 'requestId'?: string | null;
49173
+ /**
49174
+ * The ID of the user who made the request
49175
+ * @type {string}
49176
+ * @memberof TemplateDtoSlackTemplateV2025
49177
+ */
49178
+ 'requestedById'?: string | null;
49179
+ /**
49180
+ * Whether this is a subscription notification
49181
+ * @type {boolean}
49182
+ * @memberof TemplateDtoSlackTemplateV2025
49183
+ */
49184
+ 'isSubscription'?: boolean | null;
49185
+ /**
49186
+ *
49187
+ * @type {TemplateSlackAutoApprovalDataV2025}
49188
+ * @memberof TemplateDtoSlackTemplateV2025
49189
+ */
49190
+ 'autoApprovalData'?: TemplateSlackAutoApprovalDataV2025 | null;
49191
+ /**
49192
+ *
49193
+ * @type {TemplateSlackCustomFieldsV2025}
49194
+ * @memberof TemplateDtoSlackTemplateV2025
49195
+ */
49196
+ 'customFields'?: TemplateSlackCustomFieldsV2025 | null;
49197
+ }
49198
+ /**
49199
+ *
49200
+ * @export
49201
+ * @interface TemplateDtoTeamsTemplateV2025
49202
+ */
49203
+ export interface TemplateDtoTeamsTemplateV2025 {
49204
+ /**
49205
+ * The template key
49206
+ * @type {string}
49207
+ * @memberof TemplateDtoTeamsTemplateV2025
49208
+ */
49209
+ 'key'?: string | null;
49210
+ /**
49211
+ * The title of the Teams message
49212
+ * @type {string}
49213
+ * @memberof TemplateDtoTeamsTemplateV2025
49214
+ */
49215
+ 'title'?: string | null;
49216
+ /**
49217
+ * The main text content of the Teams message
49218
+ * @type {string}
49219
+ * @memberof TemplateDtoTeamsTemplateV2025
49220
+ */
49221
+ 'text'?: string;
49222
+ /**
49223
+ * JSON string of the Teams adaptive card
49224
+ * @type {string}
49225
+ * @memberof TemplateDtoTeamsTemplateV2025
49226
+ */
49227
+ 'messageJSON'?: string | null;
49228
+ /**
49229
+ * Whether this is a subscription notification
49230
+ * @type {boolean}
49231
+ * @memberof TemplateDtoTeamsTemplateV2025
49232
+ */
49233
+ 'isSubscription'?: boolean | null;
49234
+ /**
49235
+ * The approval request ID
49236
+ * @type {string}
49237
+ * @memberof TemplateDtoTeamsTemplateV2025
49238
+ */
49239
+ 'approvalId'?: string | null;
49240
+ /**
49241
+ * The request ID
49242
+ * @type {string}
49243
+ * @memberof TemplateDtoTeamsTemplateV2025
49244
+ */
49245
+ 'requestId'?: string | null;
49246
+ /**
49247
+ * The ID of the user who made the request
49248
+ * @type {string}
49249
+ * @memberof TemplateDtoTeamsTemplateV2025
49250
+ */
49251
+ 'requestedById'?: string | null;
49252
+ /**
49253
+ * The type of notification
49254
+ * @type {string}
49255
+ * @memberof TemplateDtoTeamsTemplateV2025
49256
+ */
49257
+ 'notificationType'?: string | null;
49258
+ /**
49259
+ *
49260
+ * @type {TemplateSlackAutoApprovalDataV2025}
49261
+ * @memberof TemplateDtoTeamsTemplateV2025
49262
+ */
49263
+ 'autoApprovalData'?: TemplateSlackAutoApprovalDataV2025 | null;
49264
+ /**
49265
+ *
49266
+ * @type {TemplateSlackCustomFieldsV2025}
49267
+ * @memberof TemplateDtoTeamsTemplateV2025
49268
+ */
49269
+ 'customFields'?: TemplateSlackCustomFieldsV2025 | null;
49270
+ }
49007
49271
  /**
49008
49272
  *
49009
49273
  * @export
@@ -49098,22 +49362,20 @@ export interface TemplateDtoV2025 {
49098
49362
  'modified'?: string;
49099
49363
  /**
49100
49364
  *
49101
- * @type {string}
49365
+ * @type {TemplateDtoSlackTemplateV2025}
49102
49366
  * @memberof TemplateDtoV2025
49103
49367
  */
49104
- 'slackTemplate'?: string | null;
49368
+ 'slackTemplate'?: TemplateDtoSlackTemplateV2025;
49105
49369
  /**
49106
49370
  *
49107
- * @type {string}
49371
+ * @type {TemplateDtoTeamsTemplateV2025}
49108
49372
  * @memberof TemplateDtoV2025
49109
49373
  */
49110
- 'teamsTemplate'?: string | null;
49374
+ 'teamsTemplate'?: TemplateDtoTeamsTemplateV2025;
49111
49375
  }
49112
49376
 
49113
49377
  export const TemplateDtoV2025MediumV2025 = {
49114
49378
  Email: 'EMAIL',
49115
- Phone: 'PHONE',
49116
- Sms: 'SMS',
49117
49379
  Slack: 'SLACK',
49118
49380
  Teams: 'TEAMS'
49119
49381
  } as const;
@@ -49127,31 +49389,31 @@ export type TemplateDtoV2025MediumV2025 = typeof TemplateDtoV2025MediumV2025[key
49127
49389
  */
49128
49390
  export interface TemplateSlackAutoApprovalDataV2025 {
49129
49391
  /**
49130
- *
49392
+ * Whether the request was auto-approved
49131
49393
  * @type {string}
49132
49394
  * @memberof TemplateSlackAutoApprovalDataV2025
49133
49395
  */
49134
49396
  'isAutoApproved'?: string | null;
49135
49397
  /**
49136
- *
49398
+ * The item ID
49137
49399
  * @type {string}
49138
49400
  * @memberof TemplateSlackAutoApprovalDataV2025
49139
49401
  */
49140
49402
  'itemId'?: string | null;
49141
49403
  /**
49142
- *
49404
+ * The item type
49143
49405
  * @type {string}
49144
49406
  * @memberof TemplateSlackAutoApprovalDataV2025
49145
49407
  */
49146
49408
  'itemType'?: string | null;
49147
49409
  /**
49148
- *
49410
+ * JSON message for auto-approval
49149
49411
  * @type {string}
49150
49412
  * @memberof TemplateSlackAutoApprovalDataV2025
49151
49413
  */
49152
49414
  'autoApprovalMessageJSON'?: string | null;
49153
49415
  /**
49154
- *
49416
+ * Title for auto-approval
49155
49417
  * @type {string}
49156
49418
  * @memberof TemplateSlackAutoApprovalDataV2025
49157
49419
  */
@@ -49164,25 +49426,25 @@ export interface TemplateSlackAutoApprovalDataV2025 {
49164
49426
  */
49165
49427
  export interface TemplateSlackCustomFieldsV2025 {
49166
49428
  /**
49167
- *
49429
+ * The type of request
49168
49430
  * @type {string}
49169
49431
  * @memberof TemplateSlackCustomFieldsV2025
49170
49432
  */
49171
49433
  'requestType'?: string | null;
49172
49434
  /**
49173
- *
49435
+ * Whether the request contains a deny action
49174
49436
  * @type {string}
49175
49437
  * @memberof TemplateSlackCustomFieldsV2025
49176
49438
  */
49177
49439
  'containsDeny'?: string | null;
49178
49440
  /**
49179
- *
49441
+ * The campaign ID
49180
49442
  * @type {string}
49181
49443
  * @memberof TemplateSlackCustomFieldsV2025
49182
49444
  */
49183
49445
  'campaignId'?: string | null;
49184
49446
  /**
49185
- *
49447
+ * The campaign status
49186
49448
  * @type {string}
49187
49449
  * @memberof TemplateSlackCustomFieldsV2025
49188
49450
  */
@@ -49195,55 +49457,55 @@ export interface TemplateSlackCustomFieldsV2025 {
49195
49457
  */
49196
49458
  export interface TemplateSlackV2025 {
49197
49459
  /**
49198
- *
49460
+ * The template key
49199
49461
  * @type {string}
49200
49462
  * @memberof TemplateSlackV2025
49201
49463
  */
49202
49464
  'key'?: string | null;
49203
49465
  /**
49204
- *
49466
+ * The main text content of the Slack message
49205
49467
  * @type {string}
49206
49468
  * @memberof TemplateSlackV2025
49207
49469
  */
49208
49470
  'text'?: string;
49209
49471
  /**
49210
- *
49472
+ * JSON string of Slack Block Kit blocks for rich formatting
49211
49473
  * @type {string}
49212
49474
  * @memberof TemplateSlackV2025
49213
49475
  */
49214
49476
  'blocks'?: string | null;
49215
49477
  /**
49216
- *
49478
+ * JSON string of Slack attachments
49217
49479
  * @type {string}
49218
49480
  * @memberof TemplateSlackV2025
49219
49481
  */
49220
49482
  'attachments'?: string;
49221
49483
  /**
49222
- *
49484
+ * The type of notification
49223
49485
  * @type {string}
49224
49486
  * @memberof TemplateSlackV2025
49225
49487
  */
49226
49488
  'notificationType'?: string | null;
49227
49489
  /**
49228
- *
49490
+ * The approval request ID
49229
49491
  * @type {string}
49230
49492
  * @memberof TemplateSlackV2025
49231
49493
  */
49232
49494
  'approvalId'?: string | null;
49233
49495
  /**
49234
- *
49496
+ * The request ID
49235
49497
  * @type {string}
49236
49498
  * @memberof TemplateSlackV2025
49237
49499
  */
49238
49500
  'requestId'?: string | null;
49239
49501
  /**
49240
- *
49502
+ * The ID of the user who made the request
49241
49503
  * @type {string}
49242
49504
  * @memberof TemplateSlackV2025
49243
49505
  */
49244
49506
  'requestedById'?: string | null;
49245
49507
  /**
49246
- *
49508
+ * Whether this is a subscription notification
49247
49509
  * @type {boolean}
49248
49510
  * @memberof TemplateSlackV2025
49249
49511
  */
@@ -49268,55 +49530,55 @@ export interface TemplateSlackV2025 {
49268
49530
  */
49269
49531
  export interface TemplateTeamsV2025 {
49270
49532
  /**
49271
- *
49533
+ * The template key
49272
49534
  * @type {string}
49273
49535
  * @memberof TemplateTeamsV2025
49274
49536
  */
49275
49537
  'key'?: string | null;
49276
49538
  /**
49277
- *
49539
+ * The title of the Teams message
49278
49540
  * @type {string}
49279
49541
  * @memberof TemplateTeamsV2025
49280
49542
  */
49281
49543
  'title'?: string | null;
49282
49544
  /**
49283
- *
49545
+ * The main text content of the Teams message
49284
49546
  * @type {string}
49285
49547
  * @memberof TemplateTeamsV2025
49286
49548
  */
49287
49549
  'text'?: string;
49288
49550
  /**
49289
- *
49551
+ * JSON string of the Teams adaptive card
49290
49552
  * @type {string}
49291
49553
  * @memberof TemplateTeamsV2025
49292
49554
  */
49293
49555
  'messageJSON'?: string | null;
49294
49556
  /**
49295
- *
49557
+ * Whether this is a subscription notification
49296
49558
  * @type {boolean}
49297
49559
  * @memberof TemplateTeamsV2025
49298
49560
  */
49299
49561
  'isSubscription'?: boolean | null;
49300
49562
  /**
49301
- *
49563
+ * The approval request ID
49302
49564
  * @type {string}
49303
49565
  * @memberof TemplateTeamsV2025
49304
49566
  */
49305
49567
  'approvalId'?: string | null;
49306
49568
  /**
49307
- *
49569
+ * The request ID
49308
49570
  * @type {string}
49309
49571
  * @memberof TemplateTeamsV2025
49310
49572
  */
49311
49573
  'requestId'?: string | null;
49312
49574
  /**
49313
- *
49575
+ * The ID of the user who made the request
49314
49576
  * @type {string}
49315
49577
  * @memberof TemplateTeamsV2025
49316
49578
  */
49317
49579
  'requestedById'?: string | null;
49318
49580
  /**
49319
- *
49581
+ * The type of notification
49320
49582
  * @type {string}
49321
49583
  * @memberof TemplateTeamsV2025
49322
49584
  */
@@ -60534,17 +60796,12 @@ export const ApprovalsV2025ApiAxiosParamCreator = function (configuration?: Conf
60534
60796
  * Currently this endpoint only supports Entitlement Description Approvals. Retrieve a single approval for a given approval ID. This endpoint is for generic approvals, different than the access-request-approval endpoint and does not include access-request-approvals.
60535
60797
  * @summary Get an approval
60536
60798
  * @param {string} id ID of the approval that is to be returned
60537
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
60538
60799
  * @param {*} [axiosOptions] Override http request option.
60539
60800
  * @throws {RequiredError}
60540
60801
  */
60541
- getApproval: async (id: string, xSailPointExperimental?: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
60802
+ getApproval: async (id: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
60542
60803
  // verify required parameter 'id' is not null or undefined
60543
60804
  assertParamExists('getApproval', 'id', id)
60544
- if (xSailPointExperimental === undefined) {
60545
- xSailPointExperimental = 'true';
60546
- }
60547
-
60548
60805
  const localVarPath = `/generic-approvals/{id}`
60549
60806
  .replace(`{${"id"}}`, encodeURIComponent(String(id)));
60550
60807
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -60568,9 +60825,6 @@ export const ApprovalsV2025ApiAxiosParamCreator = function (configuration?: Conf
60568
60825
 
60569
60826
 
60570
60827
 
60571
- if (xSailPointExperimental != null) {
60572
- localVarHeaderParameter['X-SailPoint-Experimental'] = String(xSailPointExperimental);
60573
- }
60574
60828
  setSearchParams(localVarUrlObj, localVarQueryParameter);
60575
60829
  let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
60576
60830
  localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...axiosOptions.headers};
@@ -60765,7 +61019,7 @@ export const ApprovalsV2025ApiAxiosParamCreator = function (configuration?: Conf
60765
61019
  };
60766
61020
  },
60767
61021
  /**
60768
- * Upserts a singular approval configuration that matches the given configID and configScope. If id and scope are not provided, it will default to setting the tenant config.
61022
+ * Upserts a singular approval configuration that matches the given configID and configScope. For example to update the approval configurations for all Access Request Approvals please use: \'/generic-approvals/config/ACCESS_REQUEST_APPROVAL/APPROVAL_TYPE\'
60769
61023
  * @summary Put Approval Config
60770
61024
  * @param {string} id The ID defined by the scope field, where [[id]]:[[scope]] is the following [[roleID]]:ROLE [[entitlementID]]:ENTITLEMENT [[accessProfileID]]:ACCESS_PROFILE ENTITLEMENT_DESCRIPTIONS:APPROVAL_TYPE ACCESS_REQUEST_APPROVAL:APPROVAL_TYPE [[tenantID]]:TENANT [[domainObjectID]]:DOMAIN_OBJECT
60771
61025
  * @param {PutApprovalsConfigScopeV2025} scope The scope of the field, where [[id]]:[[scope]] is the following [[roleID]]:ROLE [[entitlementID]]:ENTITLEMENT [[accessProfileID]]:ACCESS_PROFILE ENTITLEMENT_DESCRIPTIONS:APPROVAL_TYPE ACCESS_REQUEST_APPROVAL:APPROVAL_TYPE [[tenantID]]:TENANT [[domainObjectID]]:DOMAIN_OBJECT
@@ -61118,12 +61372,11 @@ export const ApprovalsV2025ApiFp = function(configuration?: Configuration) {
61118
61372
  * Currently this endpoint only supports Entitlement Description Approvals. Retrieve a single approval for a given approval ID. This endpoint is for generic approvals, different than the access-request-approval endpoint and does not include access-request-approvals.
61119
61373
  * @summary Get an approval
61120
61374
  * @param {string} id ID of the approval that is to be returned
61121
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
61122
61375
  * @param {*} [axiosOptions] Override http request option.
61123
61376
  * @throws {RequiredError}
61124
61377
  */
61125
- async getApproval(id: string, xSailPointExperimental?: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ApprovalV2025>> {
61126
- const localVarAxiosArgs = await localVarAxiosParamCreator.getApproval(id, xSailPointExperimental, axiosOptions);
61378
+ async getApproval(id: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ApprovalV2025>> {
61379
+ const localVarAxiosArgs = await localVarAxiosParamCreator.getApproval(id, axiosOptions);
61127
61380
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
61128
61381
  const localVarOperationServerBasePath = operationServerMap['ApprovalsV2025Api.getApproval']?.[localVarOperationServerIndex]?.url;
61129
61382
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
@@ -61179,7 +61432,7 @@ export const ApprovalsV2025ApiFp = function(configuration?: Configuration) {
61179
61432
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
61180
61433
  },
61181
61434
  /**
61182
- * Upserts a singular approval configuration that matches the given configID and configScope. If id and scope are not provided, it will default to setting the tenant config.
61435
+ * Upserts a singular approval configuration that matches the given configID and configScope. For example to update the approval configurations for all Access Request Approvals please use: \'/generic-approvals/config/ACCESS_REQUEST_APPROVAL/APPROVAL_TYPE\'
61183
61436
  * @summary Put Approval Config
61184
61437
  * @param {string} id The ID defined by the scope field, where [[id]]:[[scope]] is the following [[roleID]]:ROLE [[entitlementID]]:ENTITLEMENT [[accessProfileID]]:ACCESS_PROFILE ENTITLEMENT_DESCRIPTIONS:APPROVAL_TYPE ACCESS_REQUEST_APPROVAL:APPROVAL_TYPE [[tenantID]]:TENANT [[domainObjectID]]:DOMAIN_OBJECT
61185
61438
  * @param {PutApprovalsConfigScopeV2025} scope The scope of the field, where [[id]]:[[scope]] is the following [[roleID]]:ROLE [[entitlementID]]:ENTITLEMENT [[accessProfileID]]:ACCESS_PROFILE ENTITLEMENT_DESCRIPTIONS:APPROVAL_TYPE ACCESS_REQUEST_APPROVAL:APPROVAL_TYPE [[tenantID]]:TENANT [[domainObjectID]]:DOMAIN_OBJECT
@@ -61320,7 +61573,7 @@ export const ApprovalsV2025ApiFactory = function (configuration?: Configuration,
61320
61573
  * @throws {RequiredError}
61321
61574
  */
61322
61575
  getApproval(requestParameters: ApprovalsV2025ApiGetApprovalRequest, axiosOptions?: RawAxiosRequestConfig): AxiosPromise<ApprovalV2025> {
61323
- return localVarFp.getApproval(requestParameters.id, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(axios, basePath));
61576
+ return localVarFp.getApproval(requestParameters.id, axiosOptions).then((request) => request(axios, basePath));
61324
61577
  },
61325
61578
  /**
61326
61579
  * Currently this endpoint only supports Entitlement Description Approvals. Get a list of approvals. This endpoint is for generic approvals, unlike the access-request-approval endpoint, and does not include access-request-approvals. Absence of all query parameters for non admins will will default to mine=true. Admin will default to mine=false. Absence of all query parameters for admins will return all approvals in the org.
@@ -61353,7 +61606,7 @@ export const ApprovalsV2025ApiFactory = function (configuration?: Configuration,
61353
61606
  return localVarFp.moveApproval(requestParameters.bulkReassignRequestDTOV2025, axiosOptions).then((request) => request(axios, basePath));
61354
61607
  },
61355
61608
  /**
61356
- * Upserts a singular approval configuration that matches the given configID and configScope. If id and scope are not provided, it will default to setting the tenant config.
61609
+ * Upserts a singular approval configuration that matches the given configID and configScope. For example to update the approval configurations for all Access Request Approvals please use: \'/generic-approvals/config/ACCESS_REQUEST_APPROVAL/APPROVAL_TYPE\'
61357
61610
  * @summary Put Approval Config
61358
61611
  * @param {ApprovalsV2025ApiPutApprovalsConfigRequest} requestParameters Request parameters.
61359
61612
  * @param {*} [axiosOptions] Override http request option.
@@ -61497,13 +61750,6 @@ export interface ApprovalsV2025ApiGetApprovalRequest {
61497
61750
  * @memberof ApprovalsV2025ApiGetApproval
61498
61751
  */
61499
61752
  readonly id: string
61500
-
61501
- /**
61502
- * Use this header to enable this experimental API.
61503
- * @type {string}
61504
- * @memberof ApprovalsV2025ApiGetApproval
61505
- */
61506
- readonly xSailPointExperimental?: string
61507
61753
  }
61508
61754
 
61509
61755
  /**
@@ -61815,7 +62061,7 @@ export class ApprovalsV2025Api extends BaseAPI {
61815
62061
  * @memberof ApprovalsV2025Api
61816
62062
  */
61817
62063
  public getApproval(requestParameters: ApprovalsV2025ApiGetApprovalRequest, axiosOptions?: RawAxiosRequestConfig) {
61818
- return ApprovalsV2025ApiFp(this.configuration).getApproval(requestParameters.id, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(this.axios, this.basePath));
62064
+ return ApprovalsV2025ApiFp(this.configuration).getApproval(requestParameters.id, axiosOptions).then((request) => request(this.axios, this.basePath));
61819
62065
  }
61820
62066
 
61821
62067
  /**
@@ -61855,7 +62101,7 @@ export class ApprovalsV2025Api extends BaseAPI {
61855
62101
  }
61856
62102
 
61857
62103
  /**
61858
- * Upserts a singular approval configuration that matches the given configID and configScope. If id and scope are not provided, it will default to setting the tenant config.
62104
+ * Upserts a singular approval configuration that matches the given configID and configScope. For example to update the approval configurations for all Access Request Approvals please use: \'/generic-approvals/config/ACCESS_REQUEST_APPROVAL/APPROVAL_TYPE\'
61859
62105
  * @summary Put Approval Config
61860
62106
  * @param {ApprovalsV2025ApiPutApprovalsConfigRequest} requestParameters Request parameters.
61861
62107
  * @param {*} [axiosOptions] Override http request option.
@@ -111814,17 +112060,12 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
111814
112060
  * Create a domain to be verified via DKIM (DomainKeys Identified Mail)
111815
112061
  * @summary Verify domain address via dkim
111816
112062
  * @param {DomainAddressV2025} domainAddressV2025
111817
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
111818
112063
  * @param {*} [axiosOptions] Override http request option.
111819
112064
  * @throws {RequiredError}
111820
112065
  */
111821
- createDomainDkim: async (domainAddressV2025: DomainAddressV2025, xSailPointExperimental?: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
112066
+ createDomainDkim: async (domainAddressV2025: DomainAddressV2025, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
111822
112067
  // verify required parameter 'domainAddressV2025' is not null or undefined
111823
112068
  assertParamExists('createDomainDkim', 'domainAddressV2025', domainAddressV2025)
111824
- if (xSailPointExperimental === undefined) {
111825
- xSailPointExperimental = 'true';
111826
- }
111827
-
111828
112069
  const localVarPath = `/verified-domains`;
111829
112070
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
111830
112071
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -111849,9 +112090,6 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
111849
112090
 
111850
112091
  localVarHeaderParameter['Content-Type'] = 'application/json';
111851
112092
 
111852
- if (xSailPointExperimental != null) {
111853
- localVarHeaderParameter['X-SailPoint-Experimental'] = String(xSailPointExperimental);
111854
- }
111855
112093
  setSearchParams(localVarUrlObj, localVarQueryParameter);
111856
112094
  let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
111857
112095
  localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...axiosOptions.headers};
@@ -111866,17 +112104,12 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
111866
112104
  * This will update notification templates that are available in your tenant. Note that you cannot create new templates in your tenant, but you can use this to create custom notifications from existing templates. First, copy the response body from the [get notification template endpoint](https://developer.sailpoint.com/idn/api/beta/get-notification-template) for a template you wish to update and paste it into the request body for this endpoint. Modify the fields you want to change and submit the POST request when ready.
111867
112105
  * @summary Create notification template
111868
112106
  * @param {TemplateDtoV2025} templateDtoV2025
111869
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
111870
112107
  * @param {*} [axiosOptions] Override http request option.
111871
112108
  * @throws {RequiredError}
111872
112109
  */
111873
- createNotificationTemplate: async (templateDtoV2025: TemplateDtoV2025, xSailPointExperimental?: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
112110
+ createNotificationTemplate: async (templateDtoV2025: TemplateDtoV2025, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
111874
112111
  // verify required parameter 'templateDtoV2025' is not null or undefined
111875
112112
  assertParamExists('createNotificationTemplate', 'templateDtoV2025', templateDtoV2025)
111876
- if (xSailPointExperimental === undefined) {
111877
- xSailPointExperimental = 'true';
111878
- }
111879
-
111880
112113
  const localVarPath = `/notification-templates`;
111881
112114
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
111882
112115
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -111901,9 +112134,6 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
111901
112134
 
111902
112135
  localVarHeaderParameter['Content-Type'] = 'application/json';
111903
112136
 
111904
- if (xSailPointExperimental != null) {
111905
- localVarHeaderParameter['X-SailPoint-Experimental'] = String(xSailPointExperimental);
111906
- }
111907
112137
  setSearchParams(localVarUrlObj, localVarQueryParameter);
111908
112138
  let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
111909
112139
  localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...axiosOptions.headers};
@@ -111918,17 +112148,12 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
111918
112148
  * Create a new sender email address and initiate verification process.
111919
112149
  * @summary Create verified from address
111920
112150
  * @param {EmailStatusDtoV2025} emailStatusDtoV2025
111921
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
111922
112151
  * @param {*} [axiosOptions] Override http request option.
111923
112152
  * @throws {RequiredError}
111924
112153
  */
111925
- createVerifiedFromAddress: async (emailStatusDtoV2025: EmailStatusDtoV2025, xSailPointExperimental?: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
112154
+ createVerifiedFromAddress: async (emailStatusDtoV2025: EmailStatusDtoV2025, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
111926
112155
  // verify required parameter 'emailStatusDtoV2025' is not null or undefined
111927
112156
  assertParamExists('createVerifiedFromAddress', 'emailStatusDtoV2025', emailStatusDtoV2025)
111928
- if (xSailPointExperimental === undefined) {
111929
- xSailPointExperimental = 'true';
111930
- }
111931
-
111932
112157
  const localVarPath = `/verified-from-addresses`;
111933
112158
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
111934
112159
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -111943,19 +112168,16 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
111943
112168
 
111944
112169
  // authentication userAuth required
111945
112170
  // oauth required
111946
- await setOAuthToObject(localVarHeaderParameter, "userAuth", ["sp:scopes:all"], configuration)
112171
+ await setOAuthToObject(localVarHeaderParameter, "userAuth", [], configuration)
111947
112172
 
111948
112173
  // authentication userAuth required
111949
112174
  // oauth required
111950
- await setOAuthToObject(localVarHeaderParameter, "userAuth", ["sp:scopes:all"], configuration)
112175
+ await setOAuthToObject(localVarHeaderParameter, "userAuth", [], configuration)
111951
112176
 
111952
112177
 
111953
112178
 
111954
112179
  localVarHeaderParameter['Content-Type'] = 'application/json';
111955
112180
 
111956
- if (xSailPointExperimental != null) {
111957
- localVarHeaderParameter['X-SailPoint-Experimental'] = String(xSailPointExperimental);
111958
- }
111959
112181
  setSearchParams(localVarUrlObj, localVarQueryParameter);
111960
112182
  let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
111961
112183
  localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...axiosOptions.headers};
@@ -111967,20 +112189,15 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
111967
112189
  };
111968
112190
  },
111969
112191
  /**
111970
- * This lets you bulk delete templates that you previously created for your site. Since this is a beta feature, please contact support to enable usage.
112192
+ * This lets you bulk delete templates that you previously created for your site.
111971
112193
  * @summary Bulk delete notification templates
111972
112194
  * @param {Array<TemplateBulkDeleteDtoV2025>} templateBulkDeleteDtoV2025
111973
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
111974
112195
  * @param {*} [axiosOptions] Override http request option.
111975
112196
  * @throws {RequiredError}
111976
112197
  */
111977
- deleteNotificationTemplatesInBulk: async (templateBulkDeleteDtoV2025: Array<TemplateBulkDeleteDtoV2025>, xSailPointExperimental?: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
112198
+ deleteNotificationTemplatesInBulk: async (templateBulkDeleteDtoV2025: Array<TemplateBulkDeleteDtoV2025>, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
111978
112199
  // verify required parameter 'templateBulkDeleteDtoV2025' is not null or undefined
111979
112200
  assertParamExists('deleteNotificationTemplatesInBulk', 'templateBulkDeleteDtoV2025', templateBulkDeleteDtoV2025)
111980
- if (xSailPointExperimental === undefined) {
111981
- xSailPointExperimental = 'true';
111982
- }
111983
-
111984
112201
  const localVarPath = `/notification-templates/bulk-delete`;
111985
112202
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
111986
112203
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -112005,9 +112222,6 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
112005
112222
 
112006
112223
  localVarHeaderParameter['Content-Type'] = 'application/json';
112007
112224
 
112008
- if (xSailPointExperimental != null) {
112009
- localVarHeaderParameter['X-SailPoint-Experimental'] = String(xSailPointExperimental);
112010
- }
112011
112225
  setSearchParams(localVarUrlObj, localVarQueryParameter);
112012
112226
  let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
112013
112227
  localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...axiosOptions.headers};
@@ -112021,18 +112235,13 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
112021
112235
  /**
112022
112236
  * Delete a verified sender email address
112023
112237
  * @summary Delete verified from address
112024
- * @param {string} id
112025
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
112238
+ * @param {string} id Unique identifier of the verified sender address to delete.
112026
112239
  * @param {*} [axiosOptions] Override http request option.
112027
112240
  * @throws {RequiredError}
112028
112241
  */
112029
- deleteVerifiedFromAddress: async (id: string, xSailPointExperimental?: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
112242
+ deleteVerifiedFromAddress: async (id: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
112030
112243
  // verify required parameter 'id' is not null or undefined
112031
112244
  assertParamExists('deleteVerifiedFromAddress', 'id', id)
112032
- if (xSailPointExperimental === undefined) {
112033
- xSailPointExperimental = 'true';
112034
- }
112035
-
112036
112245
  const localVarPath = `/verified-from-addresses/{id}`
112037
112246
  .replace(`{${"id"}}`, encodeURIComponent(String(id)));
112038
112247
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -112048,17 +112257,14 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
112048
112257
 
112049
112258
  // authentication userAuth required
112050
112259
  // oauth required
112051
- await setOAuthToObject(localVarHeaderParameter, "userAuth", ["sp:scopes:all"], configuration)
112260
+ await setOAuthToObject(localVarHeaderParameter, "userAuth", [], configuration)
112052
112261
 
112053
112262
  // authentication userAuth required
112054
112263
  // oauth required
112055
- await setOAuthToObject(localVarHeaderParameter, "userAuth", ["sp:scopes:all"], configuration)
112264
+ await setOAuthToObject(localVarHeaderParameter, "userAuth", [], configuration)
112056
112265
 
112057
112266
 
112058
112267
 
112059
- if (xSailPointExperimental != null) {
112060
- localVarHeaderParameter['X-SailPoint-Experimental'] = String(xSailPointExperimental);
112061
- }
112062
112268
  setSearchParams(localVarUrlObj, localVarQueryParameter);
112063
112269
  let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
112064
112270
  localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...axiosOptions.headers};
@@ -112071,15 +112277,12 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
112071
112277
  /**
112072
112278
  * Retrieve DKIM (DomainKeys Identified Mail) attributes for all your tenants\' AWS SES identities. Limits retrieval to 100 identities per call.
112073
112279
  * @summary Get dkim attributes
112074
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
112280
+ * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
112281
+ * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
112075
112282
  * @param {*} [axiosOptions] Override http request option.
112076
112283
  * @throws {RequiredError}
112077
112284
  */
112078
- getDkimAttributes: async (xSailPointExperimental?: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
112079
- if (xSailPointExperimental === undefined) {
112080
- xSailPointExperimental = 'true';
112081
- }
112082
-
112285
+ getDkimAttributes: async (limit?: number, offset?: number, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
112083
112286
  const localVarPath = `/verified-domains`;
112084
112287
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
112085
112288
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -112100,11 +112303,16 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
112100
112303
  // oauth required
112101
112304
  await setOAuthToObject(localVarHeaderParameter, "userAuth", [], configuration)
112102
112305
 
112306
+ if (limit !== undefined) {
112307
+ localVarQueryParameter['limit'] = limit;
112308
+ }
112103
112309
 
112104
-
112105
- if (xSailPointExperimental != null) {
112106
- localVarHeaderParameter['X-SailPoint-Experimental'] = String(xSailPointExperimental);
112310
+ if (offset !== undefined) {
112311
+ localVarQueryParameter['offset'] = offset;
112107
112312
  }
112313
+
112314
+
112315
+
112108
112316
  setSearchParams(localVarUrlObj, localVarQueryParameter);
112109
112317
  let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
112110
112318
  localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...axiosOptions.headers};
@@ -112117,19 +112325,15 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
112117
112325
  /**
112118
112326
  * Retrieve MAIL FROM attributes for a given AWS SES identity.
112119
112327
  * @summary Get mail from attributes
112120
- * @param {string} id Returns the MX and TXT record to be put in your DNS, as well as the MAIL FROM domain status
112121
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
112328
+ * @param {string} identity Returns the MX and TXT record to be put in your DNS, as well as the MAIL FROM domain status
112122
112329
  * @param {*} [axiosOptions] Override http request option.
112123
112330
  * @throws {RequiredError}
112124
112331
  */
112125
- getMailFromAttributes: async (id: string, xSailPointExperimental?: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
112126
- // verify required parameter 'id' is not null or undefined
112127
- assertParamExists('getMailFromAttributes', 'id', id)
112128
- if (xSailPointExperimental === undefined) {
112129
- xSailPointExperimental = 'true';
112130
- }
112131
-
112132
- const localVarPath = `/mail-from-attributes/{identity}`;
112332
+ getMailFromAttributes: async (identity: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
112333
+ // verify required parameter 'identity' is not null or undefined
112334
+ assertParamExists('getMailFromAttributes', 'identity', identity)
112335
+ const localVarPath = `/mail-from-attributes/{identity}`
112336
+ .replace(`{${"identity"}}`, encodeURIComponent(String(identity)));
112133
112337
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
112134
112338
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
112135
112339
  let baseOptions;
@@ -112149,15 +112353,46 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
112149
112353
  // oauth required
112150
112354
  await setOAuthToObject(localVarHeaderParameter, "userAuth", [], configuration)
112151
112355
 
112152
- if (id !== undefined) {
112153
- localVarQueryParameter['id'] = id;
112356
+
112357
+
112358
+ setSearchParams(localVarUrlObj, localVarQueryParameter);
112359
+ let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
112360
+ localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...axiosOptions.headers};
112361
+
112362
+ return {
112363
+ url: toPathString(localVarUrlObj),
112364
+ axiosOptions: localVarRequestOptions,
112365
+ };
112366
+ },
112367
+ /**
112368
+ * Returns a list of notification preferences for tenant.
112369
+ * @summary List notification preferences for tenant.
112370
+ * @param {*} [axiosOptions] Override http request option.
112371
+ * @throws {RequiredError}
112372
+ */
112373
+ getNotificationPreferences: async (axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
112374
+ const localVarPath = `/notification-preferences/{key}`;
112375
+ // use dummy base URL string because the URL constructor only accepts absolute URLs.
112376
+ const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
112377
+ let baseOptions;
112378
+ if (configuration) {
112379
+ baseOptions = configuration.baseOptions;
112154
112380
  }
112155
112381
 
112382
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...axiosOptions};
112383
+ const localVarHeaderParameter = {} as any;
112384
+ const localVarQueryParameter = {} as any;
112385
+
112386
+ // authentication userAuth required
112387
+ // oauth required
112388
+ await setOAuthToObject(localVarHeaderParameter, "userAuth", [], configuration)
112389
+
112390
+ // authentication userAuth required
112391
+ // oauth required
112392
+ await setOAuthToObject(localVarHeaderParameter, "userAuth", [], configuration)
112393
+
112156
112394
 
112157
112395
 
112158
- if (xSailPointExperimental != null) {
112159
- localVarHeaderParameter['X-SailPoint-Experimental'] = String(xSailPointExperimental);
112160
- }
112161
112396
  setSearchParams(localVarUrlObj, localVarQueryParameter);
112162
112397
  let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
112163
112398
  localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...axiosOptions.headers};
@@ -112171,17 +112406,12 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
112171
112406
  * This gets a template that you have modified for your site by Id.
112172
112407
  * @summary Get notification template by id
112173
112408
  * @param {string} id Id of the Notification Template
112174
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
112175
112409
  * @param {*} [axiosOptions] Override http request option.
112176
112410
  * @throws {RequiredError}
112177
112411
  */
112178
- getNotificationTemplate: async (id: string, xSailPointExperimental?: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
112412
+ getNotificationTemplate: async (id: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
112179
112413
  // verify required parameter 'id' is not null or undefined
112180
112414
  assertParamExists('getNotificationTemplate', 'id', id)
112181
- if (xSailPointExperimental === undefined) {
112182
- xSailPointExperimental = 'true';
112183
- }
112184
-
112185
112415
  const localVarPath = `/notification-templates/{id}`
112186
112416
  .replace(`{${"id"}}`, encodeURIComponent(String(id)));
112187
112417
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -112197,17 +112427,14 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
112197
112427
 
112198
112428
  // authentication userAuth required
112199
112429
  // oauth required
112200
- await setOAuthToObject(localVarHeaderParameter, "userAuth", ["sp:scopes:all"], configuration)
112430
+ await setOAuthToObject(localVarHeaderParameter, "userAuth", [], configuration)
112201
112431
 
112202
112432
  // authentication userAuth required
112203
112433
  // oauth required
112204
- await setOAuthToObject(localVarHeaderParameter, "userAuth", ["sp:scopes:all"], configuration)
112434
+ await setOAuthToObject(localVarHeaderParameter, "userAuth", [], configuration)
112205
112435
 
112206
112436
 
112207
112437
 
112208
- if (xSailPointExperimental != null) {
112209
- localVarHeaderParameter['X-SailPoint-Experimental'] = String(xSailPointExperimental);
112210
- }
112211
112438
  setSearchParams(localVarUrlObj, localVarQueryParameter);
112212
112439
  let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
112213
112440
  localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...axiosOptions.headers};
@@ -112220,15 +112447,10 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
112220
112447
  /**
112221
112448
  * The notification service maintains metadata to construct the notification templates or supply any information during the event propagation. The data-store where this information is retrieved is called \"Global Context\" (a.k.a. notification template context). It defines a set of attributes that will be available per tenant (organization).
112222
112449
  * @summary Get notification template context
112223
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
112224
112450
  * @param {*} [axiosOptions] Override http request option.
112225
112451
  * @throws {RequiredError}
112226
112452
  */
112227
- getNotificationsTemplateContext: async (xSailPointExperimental?: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
112228
- if (xSailPointExperimental === undefined) {
112229
- xSailPointExperimental = 'true';
112230
- }
112231
-
112453
+ getNotificationsTemplateContext: async (axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
112232
112454
  const localVarPath = `/notification-template-context`;
112233
112455
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
112234
112456
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -112251,9 +112473,6 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
112251
112473
 
112252
112474
 
112253
112475
 
112254
- if (xSailPointExperimental != null) {
112255
- localVarHeaderParameter['X-SailPoint-Experimental'] = String(xSailPointExperimental);
112256
- }
112257
112476
  setSearchParams(localVarUrlObj, localVarQueryParameter);
112258
112477
  let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
112259
112478
  localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...axiosOptions.headers};
@@ -112269,17 +112488,12 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
112269
112488
  * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
112270
112489
  * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
112271
112490
  * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored. Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
112272
- * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results) Filtering is supported for the following fields and operators: **email**: *eq, ge, le, sw*
112491
+ * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results) Filtering is supported for the following fields and operators: **email**: *eq, ge, le, gt, lt*
112273
112492
  * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results) Sorting is supported for the following fields: **email**
112274
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
112275
112493
  * @param {*} [axiosOptions] Override http request option.
112276
112494
  * @throws {RequiredError}
112277
112495
  */
112278
- listFromAddresses: async (limit?: number, offset?: number, count?: boolean, filters?: string, sorters?: string, xSailPointExperimental?: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
112279
- if (xSailPointExperimental === undefined) {
112280
- xSailPointExperimental = 'true';
112281
- }
112282
-
112496
+ listFromAddresses: async (limit?: number, offset?: number, count?: boolean, filters?: string, sorters?: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
112283
112497
  const localVarPath = `/verified-from-addresses`;
112284
112498
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
112285
112499
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -112294,11 +112508,11 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
112294
112508
 
112295
112509
  // authentication userAuth required
112296
112510
  // oauth required
112297
- await setOAuthToObject(localVarHeaderParameter, "userAuth", ["sp:scopes:all"], configuration)
112511
+ await setOAuthToObject(localVarHeaderParameter, "userAuth", [], configuration)
112298
112512
 
112299
112513
  // authentication userAuth required
112300
112514
  // oauth required
112301
- await setOAuthToObject(localVarHeaderParameter, "userAuth", ["sp:scopes:all"], configuration)
112515
+ await setOAuthToObject(localVarHeaderParameter, "userAuth", [], configuration)
112302
112516
 
112303
112517
  if (limit !== undefined) {
112304
112518
  localVarQueryParameter['limit'] = limit;
@@ -112322,55 +112536,6 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
112322
112536
 
112323
112537
 
112324
112538
 
112325
- if (xSailPointExperimental != null) {
112326
- localVarHeaderParameter['X-SailPoint-Experimental'] = String(xSailPointExperimental);
112327
- }
112328
- setSearchParams(localVarUrlObj, localVarQueryParameter);
112329
- let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
112330
- localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...axiosOptions.headers};
112331
-
112332
- return {
112333
- url: toPathString(localVarUrlObj),
112334
- axiosOptions: localVarRequestOptions,
112335
- };
112336
- },
112337
- /**
112338
- * Returns a list of notification preferences for tenant.
112339
- * @summary List notification preferences for tenant.
112340
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
112341
- * @param {*} [axiosOptions] Override http request option.
112342
- * @throws {RequiredError}
112343
- */
112344
- listNotificationPreferences: async (xSailPointExperimental?: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
112345
- if (xSailPointExperimental === undefined) {
112346
- xSailPointExperimental = 'true';
112347
- }
112348
-
112349
- const localVarPath = `/notification-preferences/{key}`;
112350
- // use dummy base URL string because the URL constructor only accepts absolute URLs.
112351
- const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
112352
- let baseOptions;
112353
- if (configuration) {
112354
- baseOptions = configuration.baseOptions;
112355
- }
112356
-
112357
- const localVarRequestOptions = { method: 'GET', ...baseOptions, ...axiosOptions};
112358
- const localVarHeaderParameter = {} as any;
112359
- const localVarQueryParameter = {} as any;
112360
-
112361
- // authentication userAuth required
112362
- // oauth required
112363
- await setOAuthToObject(localVarHeaderParameter, "userAuth", [], configuration)
112364
-
112365
- // authentication userAuth required
112366
- // oauth required
112367
- await setOAuthToObject(localVarHeaderParameter, "userAuth", [], configuration)
112368
-
112369
-
112370
-
112371
- if (xSailPointExperimental != null) {
112372
- localVarHeaderParameter['X-SailPoint-Experimental'] = String(xSailPointExperimental);
112373
- }
112374
112539
  setSearchParams(localVarUrlObj, localVarQueryParameter);
112375
112540
  let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
112376
112541
  localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...axiosOptions.headers};
@@ -112386,15 +112551,10 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
112386
112551
  * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
112387
112552
  * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
112388
112553
  * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results) Filtering is supported for the following fields and operators: **key**: *eq, in, sw* **medium**: *eq, sw* **locale**: *eq, sw*
112389
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
112390
112554
  * @param {*} [axiosOptions] Override http request option.
112391
112555
  * @throws {RequiredError}
112392
112556
  */
112393
- listNotificationTemplateDefaults: async (limit?: number, offset?: number, filters?: string, xSailPointExperimental?: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
112394
- if (xSailPointExperimental === undefined) {
112395
- xSailPointExperimental = 'true';
112396
- }
112397
-
112557
+ listNotificationTemplateDefaults: async (limit?: number, offset?: number, filters?: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
112398
112558
  const localVarPath = `/notification-template-defaults`;
112399
112559
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
112400
112560
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -112429,9 +112589,6 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
112429
112589
 
112430
112590
 
112431
112591
 
112432
- if (xSailPointExperimental != null) {
112433
- localVarHeaderParameter['X-SailPoint-Experimental'] = String(xSailPointExperimental);
112434
- }
112435
112592
  setSearchParams(localVarUrlObj, localVarQueryParameter);
112436
112593
  let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
112437
112594
  localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...axiosOptions.headers};
@@ -112448,15 +112605,10 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
112448
112605
  * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
112449
112606
  * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results) Filtering is supported for the following fields and operators: **key**: *eq, in, sw* **medium**: *eq, sw* **locale**: *eq, sw*
112450
112607
  * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results) Sorting is supported for the following fields: **key, name, medium**
112451
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
112452
112608
  * @param {*} [axiosOptions] Override http request option.
112453
112609
  * @throws {RequiredError}
112454
112610
  */
112455
- listNotificationTemplates: async (limit?: number, offset?: number, filters?: string, sorters?: string, xSailPointExperimental?: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
112456
- if (xSailPointExperimental === undefined) {
112457
- xSailPointExperimental = 'true';
112458
- }
112459
-
112611
+ listNotificationTemplates: async (limit?: number, offset?: number, filters?: string, sorters?: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
112460
112612
  const localVarPath = `/notification-templates`;
112461
112613
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
112462
112614
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -112495,9 +112647,6 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
112495
112647
 
112496
112648
 
112497
112649
 
112498
- if (xSailPointExperimental != null) {
112499
- localVarHeaderParameter['X-SailPoint-Experimental'] = String(xSailPointExperimental);
112500
- }
112501
112650
  setSearchParams(localVarUrlObj, localVarQueryParameter);
112502
112651
  let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
112503
112652
  localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...axiosOptions.headers};
@@ -112511,17 +112660,12 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
112511
112660
  * Change the MAIL FROM domain of an AWS SES email identity and provide the MX and TXT records to be placed in the caller\'s DNS
112512
112661
  * @summary Change mail from domain
112513
112662
  * @param {MailFromAttributesDtoV2025} mailFromAttributesDtoV2025
112514
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
112515
112663
  * @param {*} [axiosOptions] Override http request option.
112516
112664
  * @throws {RequiredError}
112517
112665
  */
112518
- putMailFromAttributes: async (mailFromAttributesDtoV2025: MailFromAttributesDtoV2025, xSailPointExperimental?: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
112666
+ putMailFromAttributes: async (mailFromAttributesDtoV2025: MailFromAttributesDtoV2025, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
112519
112667
  // verify required parameter 'mailFromAttributesDtoV2025' is not null or undefined
112520
112668
  assertParamExists('putMailFromAttributes', 'mailFromAttributesDtoV2025', mailFromAttributesDtoV2025)
112521
- if (xSailPointExperimental === undefined) {
112522
- xSailPointExperimental = 'true';
112523
- }
112524
-
112525
112669
  const localVarPath = `/mail-from-attributes`;
112526
112670
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
112527
112671
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -112546,9 +112690,6 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
112546
112690
 
112547
112691
  localVarHeaderParameter['Content-Type'] = 'application/json';
112548
112692
 
112549
- if (xSailPointExperimental != null) {
112550
- localVarHeaderParameter['X-SailPoint-Experimental'] = String(xSailPointExperimental);
112551
- }
112552
112693
  setSearchParams(localVarUrlObj, localVarQueryParameter);
112553
112694
  let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
112554
112695
  localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...axiosOptions.headers};
@@ -112563,17 +112704,12 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
112563
112704
  * Send a Test Notification
112564
112705
  * @summary Send test notification
112565
112706
  * @param {SendTestNotificationRequestDtoV2025} sendTestNotificationRequestDtoV2025
112566
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
112567
112707
  * @param {*} [axiosOptions] Override http request option.
112568
112708
  * @throws {RequiredError}
112569
112709
  */
112570
- sendTestNotification: async (sendTestNotificationRequestDtoV2025: SendTestNotificationRequestDtoV2025, xSailPointExperimental?: string, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
112710
+ sendTestNotification: async (sendTestNotificationRequestDtoV2025: SendTestNotificationRequestDtoV2025, axiosOptions: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
112571
112711
  // verify required parameter 'sendTestNotificationRequestDtoV2025' is not null or undefined
112572
112712
  assertParamExists('sendTestNotification', 'sendTestNotificationRequestDtoV2025', sendTestNotificationRequestDtoV2025)
112573
- if (xSailPointExperimental === undefined) {
112574
- xSailPointExperimental = 'true';
112575
- }
112576
-
112577
112713
  const localVarPath = `/send-test-notification`;
112578
112714
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
112579
112715
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -112588,19 +112724,16 @@ export const NotificationsV2025ApiAxiosParamCreator = function (configuration?:
112588
112724
 
112589
112725
  // authentication userAuth required
112590
112726
  // oauth required
112591
- await setOAuthToObject(localVarHeaderParameter, "userAuth", ["sp:scopes:all"], configuration)
112727
+ await setOAuthToObject(localVarHeaderParameter, "userAuth", [], configuration)
112592
112728
 
112593
112729
  // authentication userAuth required
112594
112730
  // oauth required
112595
- await setOAuthToObject(localVarHeaderParameter, "userAuth", ["sp:scopes:all"], configuration)
112731
+ await setOAuthToObject(localVarHeaderParameter, "userAuth", [], configuration)
112596
112732
 
112597
112733
 
112598
112734
 
112599
112735
  localVarHeaderParameter['Content-Type'] = 'application/json';
112600
112736
 
112601
- if (xSailPointExperimental != null) {
112602
- localVarHeaderParameter['X-SailPoint-Experimental'] = String(xSailPointExperimental);
112603
- }
112604
112737
  setSearchParams(localVarUrlObj, localVarQueryParameter);
112605
112738
  let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
112606
112739
  localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...axiosOptions.headers};
@@ -112625,12 +112758,11 @@ export const NotificationsV2025ApiFp = function(configuration?: Configuration) {
112625
112758
  * Create a domain to be verified via DKIM (DomainKeys Identified Mail)
112626
112759
  * @summary Verify domain address via dkim
112627
112760
  * @param {DomainAddressV2025} domainAddressV2025
112628
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
112629
112761
  * @param {*} [axiosOptions] Override http request option.
112630
112762
  * @throws {RequiredError}
112631
112763
  */
112632
- async createDomainDkim(domainAddressV2025: DomainAddressV2025, xSailPointExperimental?: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DomainStatusDtoV2025>> {
112633
- const localVarAxiosArgs = await localVarAxiosParamCreator.createDomainDkim(domainAddressV2025, xSailPointExperimental, axiosOptions);
112764
+ async createDomainDkim(domainAddressV2025: DomainAddressV2025, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<DomainStatusDtoV2025>> {
112765
+ const localVarAxiosArgs = await localVarAxiosParamCreator.createDomainDkim(domainAddressV2025, axiosOptions);
112634
112766
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
112635
112767
  const localVarOperationServerBasePath = operationServerMap['NotificationsV2025Api.createDomainDkim']?.[localVarOperationServerIndex]?.url;
112636
112768
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
@@ -112639,12 +112771,11 @@ export const NotificationsV2025ApiFp = function(configuration?: Configuration) {
112639
112771
  * This will update notification templates that are available in your tenant. Note that you cannot create new templates in your tenant, but you can use this to create custom notifications from existing templates. First, copy the response body from the [get notification template endpoint](https://developer.sailpoint.com/idn/api/beta/get-notification-template) for a template you wish to update and paste it into the request body for this endpoint. Modify the fields you want to change and submit the POST request when ready.
112640
112772
  * @summary Create notification template
112641
112773
  * @param {TemplateDtoV2025} templateDtoV2025
112642
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
112643
112774
  * @param {*} [axiosOptions] Override http request option.
112644
112775
  * @throws {RequiredError}
112645
112776
  */
112646
- async createNotificationTemplate(templateDtoV2025: TemplateDtoV2025, xSailPointExperimental?: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<TemplateDtoV2025>> {
112647
- const localVarAxiosArgs = await localVarAxiosParamCreator.createNotificationTemplate(templateDtoV2025, xSailPointExperimental, axiosOptions);
112777
+ async createNotificationTemplate(templateDtoV2025: TemplateDtoV2025, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<TemplateDtoV2025>> {
112778
+ const localVarAxiosArgs = await localVarAxiosParamCreator.createNotificationTemplate(templateDtoV2025, axiosOptions);
112648
112779
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
112649
112780
  const localVarOperationServerBasePath = operationServerMap['NotificationsV2025Api.createNotificationTemplate']?.[localVarOperationServerIndex]?.url;
112650
112781
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
@@ -112653,26 +112784,24 @@ export const NotificationsV2025ApiFp = function(configuration?: Configuration) {
112653
112784
  * Create a new sender email address and initiate verification process.
112654
112785
  * @summary Create verified from address
112655
112786
  * @param {EmailStatusDtoV2025} emailStatusDtoV2025
112656
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
112657
112787
  * @param {*} [axiosOptions] Override http request option.
112658
112788
  * @throws {RequiredError}
112659
112789
  */
112660
- async createVerifiedFromAddress(emailStatusDtoV2025: EmailStatusDtoV2025, xSailPointExperimental?: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<EmailStatusDtoV2025>> {
112661
- const localVarAxiosArgs = await localVarAxiosParamCreator.createVerifiedFromAddress(emailStatusDtoV2025, xSailPointExperimental, axiosOptions);
112790
+ async createVerifiedFromAddress(emailStatusDtoV2025: EmailStatusDtoV2025, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<EmailStatusDtoV2025>> {
112791
+ const localVarAxiosArgs = await localVarAxiosParamCreator.createVerifiedFromAddress(emailStatusDtoV2025, axiosOptions);
112662
112792
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
112663
112793
  const localVarOperationServerBasePath = operationServerMap['NotificationsV2025Api.createVerifiedFromAddress']?.[localVarOperationServerIndex]?.url;
112664
112794
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
112665
112795
  },
112666
112796
  /**
112667
- * This lets you bulk delete templates that you previously created for your site. Since this is a beta feature, please contact support to enable usage.
112797
+ * This lets you bulk delete templates that you previously created for your site.
112668
112798
  * @summary Bulk delete notification templates
112669
112799
  * @param {Array<TemplateBulkDeleteDtoV2025>} templateBulkDeleteDtoV2025
112670
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
112671
112800
  * @param {*} [axiosOptions] Override http request option.
112672
112801
  * @throws {RequiredError}
112673
112802
  */
112674
- async deleteNotificationTemplatesInBulk(templateBulkDeleteDtoV2025: Array<TemplateBulkDeleteDtoV2025>, xSailPointExperimental?: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
112675
- const localVarAxiosArgs = await localVarAxiosParamCreator.deleteNotificationTemplatesInBulk(templateBulkDeleteDtoV2025, xSailPointExperimental, axiosOptions);
112803
+ async deleteNotificationTemplatesInBulk(templateBulkDeleteDtoV2025: Array<TemplateBulkDeleteDtoV2025>, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
112804
+ const localVarAxiosArgs = await localVarAxiosParamCreator.deleteNotificationTemplatesInBulk(templateBulkDeleteDtoV2025, axiosOptions);
112676
112805
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
112677
112806
  const localVarOperationServerBasePath = operationServerMap['NotificationsV2025Api.deleteNotificationTemplatesInBulk']?.[localVarOperationServerIndex]?.url;
112678
112807
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
@@ -112680,13 +112809,12 @@ export const NotificationsV2025ApiFp = function(configuration?: Configuration) {
112680
112809
  /**
112681
112810
  * Delete a verified sender email address
112682
112811
  * @summary Delete verified from address
112683
- * @param {string} id
112684
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
112812
+ * @param {string} id Unique identifier of the verified sender address to delete.
112685
112813
  * @param {*} [axiosOptions] Override http request option.
112686
112814
  * @throws {RequiredError}
112687
112815
  */
112688
- async deleteVerifiedFromAddress(id: string, xSailPointExperimental?: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
112689
- const localVarAxiosArgs = await localVarAxiosParamCreator.deleteVerifiedFromAddress(id, xSailPointExperimental, axiosOptions);
112816
+ async deleteVerifiedFromAddress(id: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
112817
+ const localVarAxiosArgs = await localVarAxiosParamCreator.deleteVerifiedFromAddress(id, axiosOptions);
112690
112818
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
112691
112819
  const localVarOperationServerBasePath = operationServerMap['NotificationsV2025Api.deleteVerifiedFromAddress']?.[localVarOperationServerIndex]?.url;
112692
112820
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
@@ -112694,12 +112822,13 @@ export const NotificationsV2025ApiFp = function(configuration?: Configuration) {
112694
112822
  /**
112695
112823
  * Retrieve DKIM (DomainKeys Identified Mail) attributes for all your tenants\' AWS SES identities. Limits retrieval to 100 identities per call.
112696
112824
  * @summary Get dkim attributes
112697
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
112825
+ * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
112826
+ * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
112698
112827
  * @param {*} [axiosOptions] Override http request option.
112699
112828
  * @throws {RequiredError}
112700
112829
  */
112701
- async getDkimAttributes(xSailPointExperimental?: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<DkimAttributesV2025>>> {
112702
- const localVarAxiosArgs = await localVarAxiosParamCreator.getDkimAttributes(xSailPointExperimental, axiosOptions);
112830
+ async getDkimAttributes(limit?: number, offset?: number, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<DkimAttributesV2025>>> {
112831
+ const localVarAxiosArgs = await localVarAxiosParamCreator.getDkimAttributes(limit, offset, axiosOptions);
112703
112832
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
112704
112833
  const localVarOperationServerBasePath = operationServerMap['NotificationsV2025Api.getDkimAttributes']?.[localVarOperationServerIndex]?.url;
112705
112834
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
@@ -112707,27 +112836,37 @@ export const NotificationsV2025ApiFp = function(configuration?: Configuration) {
112707
112836
  /**
112708
112837
  * Retrieve MAIL FROM attributes for a given AWS SES identity.
112709
112838
  * @summary Get mail from attributes
112710
- * @param {string} id Returns the MX and TXT record to be put in your DNS, as well as the MAIL FROM domain status
112711
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
112839
+ * @param {string} identity Returns the MX and TXT record to be put in your DNS, as well as the MAIL FROM domain status
112712
112840
  * @param {*} [axiosOptions] Override http request option.
112713
112841
  * @throws {RequiredError}
112714
112842
  */
112715
- async getMailFromAttributes(id: string, xSailPointExperimental?: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<MailFromAttributesV2025>> {
112716
- const localVarAxiosArgs = await localVarAxiosParamCreator.getMailFromAttributes(id, xSailPointExperimental, axiosOptions);
112843
+ async getMailFromAttributes(identity: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<MailFromAttributesV2025>> {
112844
+ const localVarAxiosArgs = await localVarAxiosParamCreator.getMailFromAttributes(identity, axiosOptions);
112717
112845
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
112718
112846
  const localVarOperationServerBasePath = operationServerMap['NotificationsV2025Api.getMailFromAttributes']?.[localVarOperationServerIndex]?.url;
112719
112847
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
112720
112848
  },
112849
+ /**
112850
+ * Returns a list of notification preferences for tenant.
112851
+ * @summary List notification preferences for tenant.
112852
+ * @param {*} [axiosOptions] Override http request option.
112853
+ * @throws {RequiredError}
112854
+ */
112855
+ async getNotificationPreferences(axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PreferencesDtoV2025>> {
112856
+ const localVarAxiosArgs = await localVarAxiosParamCreator.getNotificationPreferences(axiosOptions);
112857
+ const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
112858
+ const localVarOperationServerBasePath = operationServerMap['NotificationsV2025Api.getNotificationPreferences']?.[localVarOperationServerIndex]?.url;
112859
+ return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
112860
+ },
112721
112861
  /**
112722
112862
  * This gets a template that you have modified for your site by Id.
112723
112863
  * @summary Get notification template by id
112724
112864
  * @param {string} id Id of the Notification Template
112725
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
112726
112865
  * @param {*} [axiosOptions] Override http request option.
112727
112866
  * @throws {RequiredError}
112728
112867
  */
112729
- async getNotificationTemplate(id: string, xSailPointExperimental?: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<TemplateDtoV2025>> {
112730
- const localVarAxiosArgs = await localVarAxiosParamCreator.getNotificationTemplate(id, xSailPointExperimental, axiosOptions);
112868
+ async getNotificationTemplate(id: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<TemplateDtoV2025>> {
112869
+ const localVarAxiosArgs = await localVarAxiosParamCreator.getNotificationTemplate(id, axiosOptions);
112731
112870
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
112732
112871
  const localVarOperationServerBasePath = operationServerMap['NotificationsV2025Api.getNotificationTemplate']?.[localVarOperationServerIndex]?.url;
112733
112872
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
@@ -112735,12 +112874,11 @@ export const NotificationsV2025ApiFp = function(configuration?: Configuration) {
112735
112874
  /**
112736
112875
  * The notification service maintains metadata to construct the notification templates or supply any information during the event propagation. The data-store where this information is retrieved is called \"Global Context\" (a.k.a. notification template context). It defines a set of attributes that will be available per tenant (organization).
112737
112876
  * @summary Get notification template context
112738
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
112739
112877
  * @param {*} [axiosOptions] Override http request option.
112740
112878
  * @throws {RequiredError}
112741
112879
  */
112742
- async getNotificationsTemplateContext(xSailPointExperimental?: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<NotificationTemplateContextV2025>> {
112743
- const localVarAxiosArgs = await localVarAxiosParamCreator.getNotificationsTemplateContext(xSailPointExperimental, axiosOptions);
112880
+ async getNotificationsTemplateContext(axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<NotificationTemplateContextV2025>> {
112881
+ const localVarAxiosArgs = await localVarAxiosParamCreator.getNotificationsTemplateContext(axiosOptions);
112744
112882
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
112745
112883
  const localVarOperationServerBasePath = operationServerMap['NotificationsV2025Api.getNotificationsTemplateContext']?.[localVarOperationServerIndex]?.url;
112746
112884
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
@@ -112751,43 +112889,28 @@ export const NotificationsV2025ApiFp = function(configuration?: Configuration) {
112751
112889
  * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
112752
112890
  * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
112753
112891
  * @param {boolean} [count] If *true* it will populate the *X-Total-Count* response header with the number of results that would be returned if *limit* and *offset* were ignored. Since requesting a total count can have a performance impact, it is recommended not to send **count&#x3D;true** if that value will not be used. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
112754
- * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results) Filtering is supported for the following fields and operators: **email**: *eq, ge, le, sw*
112892
+ * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results) Filtering is supported for the following fields and operators: **email**: *eq, ge, le, gt, lt*
112755
112893
  * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results) Sorting is supported for the following fields: **email**
112756
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
112757
112894
  * @param {*} [axiosOptions] Override http request option.
112758
112895
  * @throws {RequiredError}
112759
112896
  */
112760
- async listFromAddresses(limit?: number, offset?: number, count?: boolean, filters?: string, sorters?: string, xSailPointExperimental?: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<EmailStatusDtoV2025>>> {
112761
- const localVarAxiosArgs = await localVarAxiosParamCreator.listFromAddresses(limit, offset, count, filters, sorters, xSailPointExperimental, axiosOptions);
112897
+ async listFromAddresses(limit?: number, offset?: number, count?: boolean, filters?: string, sorters?: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<EmailStatusDtoV2025>>> {
112898
+ const localVarAxiosArgs = await localVarAxiosParamCreator.listFromAddresses(limit, offset, count, filters, sorters, axiosOptions);
112762
112899
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
112763
112900
  const localVarOperationServerBasePath = operationServerMap['NotificationsV2025Api.listFromAddresses']?.[localVarOperationServerIndex]?.url;
112764
112901
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
112765
112902
  },
112766
- /**
112767
- * Returns a list of notification preferences for tenant.
112768
- * @summary List notification preferences for tenant.
112769
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
112770
- * @param {*} [axiosOptions] Override http request option.
112771
- * @throws {RequiredError}
112772
- */
112773
- async listNotificationPreferences(xSailPointExperimental?: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PreferencesDtoV2025>> {
112774
- const localVarAxiosArgs = await localVarAxiosParamCreator.listNotificationPreferences(xSailPointExperimental, axiosOptions);
112775
- const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
112776
- const localVarOperationServerBasePath = operationServerMap['NotificationsV2025Api.listNotificationPreferences']?.[localVarOperationServerIndex]?.url;
112777
- return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
112778
- },
112779
112903
  /**
112780
112904
  * This lists the default templates used for notifications, such as emails from IdentityNow.
112781
112905
  * @summary List notification template defaults
112782
112906
  * @param {number} [limit] Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
112783
112907
  * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
112784
112908
  * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results) Filtering is supported for the following fields and operators: **key**: *eq, in, sw* **medium**: *eq, sw* **locale**: *eq, sw*
112785
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
112786
112909
  * @param {*} [axiosOptions] Override http request option.
112787
112910
  * @throws {RequiredError}
112788
112911
  */
112789
- async listNotificationTemplateDefaults(limit?: number, offset?: number, filters?: string, xSailPointExperimental?: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<TemplateDtoDefaultV2025>>> {
112790
- const localVarAxiosArgs = await localVarAxiosParamCreator.listNotificationTemplateDefaults(limit, offset, filters, xSailPointExperimental, axiosOptions);
112912
+ async listNotificationTemplateDefaults(limit?: number, offset?: number, filters?: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<TemplateDtoDefaultV2025>>> {
112913
+ const localVarAxiosArgs = await localVarAxiosParamCreator.listNotificationTemplateDefaults(limit, offset, filters, axiosOptions);
112791
112914
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
112792
112915
  const localVarOperationServerBasePath = operationServerMap['NotificationsV2025Api.listNotificationTemplateDefaults']?.[localVarOperationServerIndex]?.url;
112793
112916
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
@@ -112799,12 +112922,11 @@ export const NotificationsV2025ApiFp = function(configuration?: Configuration) {
112799
112922
  * @param {number} [offset] Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
112800
112923
  * @param {string} [filters] Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results) Filtering is supported for the following fields and operators: **key**: *eq, in, sw* **medium**: *eq, sw* **locale**: *eq, sw*
112801
112924
  * @param {string} [sorters] Sort results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#sorting-results) Sorting is supported for the following fields: **key, name, medium**
112802
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
112803
112925
  * @param {*} [axiosOptions] Override http request option.
112804
112926
  * @throws {RequiredError}
112805
112927
  */
112806
- async listNotificationTemplates(limit?: number, offset?: number, filters?: string, sorters?: string, xSailPointExperimental?: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<TemplateDtoV2025>>> {
112807
- const localVarAxiosArgs = await localVarAxiosParamCreator.listNotificationTemplates(limit, offset, filters, sorters, xSailPointExperimental, axiosOptions);
112928
+ async listNotificationTemplates(limit?: number, offset?: number, filters?: string, sorters?: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Array<TemplateDtoV2025>>> {
112929
+ const localVarAxiosArgs = await localVarAxiosParamCreator.listNotificationTemplates(limit, offset, filters, sorters, axiosOptions);
112808
112930
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
112809
112931
  const localVarOperationServerBasePath = operationServerMap['NotificationsV2025Api.listNotificationTemplates']?.[localVarOperationServerIndex]?.url;
112810
112932
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
@@ -112813,12 +112935,11 @@ export const NotificationsV2025ApiFp = function(configuration?: Configuration) {
112813
112935
  * Change the MAIL FROM domain of an AWS SES email identity and provide the MX and TXT records to be placed in the caller\'s DNS
112814
112936
  * @summary Change mail from domain
112815
112937
  * @param {MailFromAttributesDtoV2025} mailFromAttributesDtoV2025
112816
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
112817
112938
  * @param {*} [axiosOptions] Override http request option.
112818
112939
  * @throws {RequiredError}
112819
112940
  */
112820
- async putMailFromAttributes(mailFromAttributesDtoV2025: MailFromAttributesDtoV2025, xSailPointExperimental?: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<MailFromAttributesV2025>> {
112821
- const localVarAxiosArgs = await localVarAxiosParamCreator.putMailFromAttributes(mailFromAttributesDtoV2025, xSailPointExperimental, axiosOptions);
112941
+ async putMailFromAttributes(mailFromAttributesDtoV2025: MailFromAttributesDtoV2025, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<MailFromAttributesV2025>> {
112942
+ const localVarAxiosArgs = await localVarAxiosParamCreator.putMailFromAttributes(mailFromAttributesDtoV2025, axiosOptions);
112822
112943
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
112823
112944
  const localVarOperationServerBasePath = operationServerMap['NotificationsV2025Api.putMailFromAttributes']?.[localVarOperationServerIndex]?.url;
112824
112945
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
@@ -112827,12 +112948,11 @@ export const NotificationsV2025ApiFp = function(configuration?: Configuration) {
112827
112948
  * Send a Test Notification
112828
112949
  * @summary Send test notification
112829
112950
  * @param {SendTestNotificationRequestDtoV2025} sendTestNotificationRequestDtoV2025
112830
- * @param {string} [xSailPointExperimental] Use this header to enable this experimental API.
112831
112951
  * @param {*} [axiosOptions] Override http request option.
112832
112952
  * @throws {RequiredError}
112833
112953
  */
112834
- async sendTestNotification(sendTestNotificationRequestDtoV2025: SendTestNotificationRequestDtoV2025, xSailPointExperimental?: string, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
112835
- const localVarAxiosArgs = await localVarAxiosParamCreator.sendTestNotification(sendTestNotificationRequestDtoV2025, xSailPointExperimental, axiosOptions);
112954
+ async sendTestNotification(sendTestNotificationRequestDtoV2025: SendTestNotificationRequestDtoV2025, axiosOptions?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
112955
+ const localVarAxiosArgs = await localVarAxiosParamCreator.sendTestNotification(sendTestNotificationRequestDtoV2025, axiosOptions);
112836
112956
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
112837
112957
  const localVarOperationServerBasePath = operationServerMap['NotificationsV2025Api.sendTestNotification']?.[localVarOperationServerIndex]?.url;
112838
112958
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
@@ -112855,7 +112975,7 @@ export const NotificationsV2025ApiFactory = function (configuration?: Configurat
112855
112975
  * @throws {RequiredError}
112856
112976
  */
112857
112977
  createDomainDkim(requestParameters: NotificationsV2025ApiCreateDomainDkimRequest, axiosOptions?: RawAxiosRequestConfig): AxiosPromise<DomainStatusDtoV2025> {
112858
- return localVarFp.createDomainDkim(requestParameters.domainAddressV2025, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(axios, basePath));
112978
+ return localVarFp.createDomainDkim(requestParameters.domainAddressV2025, axiosOptions).then((request) => request(axios, basePath));
112859
112979
  },
112860
112980
  /**
112861
112981
  * This will update notification templates that are available in your tenant. Note that you cannot create new templates in your tenant, but you can use this to create custom notifications from existing templates. First, copy the response body from the [get notification template endpoint](https://developer.sailpoint.com/idn/api/beta/get-notification-template) for a template you wish to update and paste it into the request body for this endpoint. Modify the fields you want to change and submit the POST request when ready.
@@ -112865,7 +112985,7 @@ export const NotificationsV2025ApiFactory = function (configuration?: Configurat
112865
112985
  * @throws {RequiredError}
112866
112986
  */
112867
112987
  createNotificationTemplate(requestParameters: NotificationsV2025ApiCreateNotificationTemplateRequest, axiosOptions?: RawAxiosRequestConfig): AxiosPromise<TemplateDtoV2025> {
112868
- return localVarFp.createNotificationTemplate(requestParameters.templateDtoV2025, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(axios, basePath));
112988
+ return localVarFp.createNotificationTemplate(requestParameters.templateDtoV2025, axiosOptions).then((request) => request(axios, basePath));
112869
112989
  },
112870
112990
  /**
112871
112991
  * Create a new sender email address and initiate verification process.
@@ -112875,17 +112995,17 @@ export const NotificationsV2025ApiFactory = function (configuration?: Configurat
112875
112995
  * @throws {RequiredError}
112876
112996
  */
112877
112997
  createVerifiedFromAddress(requestParameters: NotificationsV2025ApiCreateVerifiedFromAddressRequest, axiosOptions?: RawAxiosRequestConfig): AxiosPromise<EmailStatusDtoV2025> {
112878
- return localVarFp.createVerifiedFromAddress(requestParameters.emailStatusDtoV2025, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(axios, basePath));
112998
+ return localVarFp.createVerifiedFromAddress(requestParameters.emailStatusDtoV2025, axiosOptions).then((request) => request(axios, basePath));
112879
112999
  },
112880
113000
  /**
112881
- * This lets you bulk delete templates that you previously created for your site. Since this is a beta feature, please contact support to enable usage.
113001
+ * This lets you bulk delete templates that you previously created for your site.
112882
113002
  * @summary Bulk delete notification templates
112883
113003
  * @param {NotificationsV2025ApiDeleteNotificationTemplatesInBulkRequest} requestParameters Request parameters.
112884
113004
  * @param {*} [axiosOptions] Override http request option.
112885
113005
  * @throws {RequiredError}
112886
113006
  */
112887
113007
  deleteNotificationTemplatesInBulk(requestParameters: NotificationsV2025ApiDeleteNotificationTemplatesInBulkRequest, axiosOptions?: RawAxiosRequestConfig): AxiosPromise<void> {
112888
- return localVarFp.deleteNotificationTemplatesInBulk(requestParameters.templateBulkDeleteDtoV2025, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(axios, basePath));
113008
+ return localVarFp.deleteNotificationTemplatesInBulk(requestParameters.templateBulkDeleteDtoV2025, axiosOptions).then((request) => request(axios, basePath));
112889
113009
  },
112890
113010
  /**
112891
113011
  * Delete a verified sender email address
@@ -112895,7 +113015,7 @@ export const NotificationsV2025ApiFactory = function (configuration?: Configurat
112895
113015
  * @throws {RequiredError}
112896
113016
  */
112897
113017
  deleteVerifiedFromAddress(requestParameters: NotificationsV2025ApiDeleteVerifiedFromAddressRequest, axiosOptions?: RawAxiosRequestConfig): AxiosPromise<void> {
112898
- return localVarFp.deleteVerifiedFromAddress(requestParameters.id, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(axios, basePath));
113018
+ return localVarFp.deleteVerifiedFromAddress(requestParameters.id, axiosOptions).then((request) => request(axios, basePath));
112899
113019
  },
112900
113020
  /**
112901
113021
  * Retrieve DKIM (DomainKeys Identified Mail) attributes for all your tenants\' AWS SES identities. Limits retrieval to 100 identities per call.
@@ -112905,7 +113025,7 @@ export const NotificationsV2025ApiFactory = function (configuration?: Configurat
112905
113025
  * @throws {RequiredError}
112906
113026
  */
112907
113027
  getDkimAttributes(requestParameters: NotificationsV2025ApiGetDkimAttributesRequest = {}, axiosOptions?: RawAxiosRequestConfig): AxiosPromise<Array<DkimAttributesV2025>> {
112908
- return localVarFp.getDkimAttributes(requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(axios, basePath));
113028
+ return localVarFp.getDkimAttributes(requestParameters.limit, requestParameters.offset, axiosOptions).then((request) => request(axios, basePath));
112909
113029
  },
112910
113030
  /**
112911
113031
  * Retrieve MAIL FROM attributes for a given AWS SES identity.
@@ -112915,7 +113035,16 @@ export const NotificationsV2025ApiFactory = function (configuration?: Configurat
112915
113035
  * @throws {RequiredError}
112916
113036
  */
112917
113037
  getMailFromAttributes(requestParameters: NotificationsV2025ApiGetMailFromAttributesRequest, axiosOptions?: RawAxiosRequestConfig): AxiosPromise<MailFromAttributesV2025> {
112918
- return localVarFp.getMailFromAttributes(requestParameters.id, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(axios, basePath));
113038
+ return localVarFp.getMailFromAttributes(requestParameters.identity, axiosOptions).then((request) => request(axios, basePath));
113039
+ },
113040
+ /**
113041
+ * Returns a list of notification preferences for tenant.
113042
+ * @summary List notification preferences for tenant.
113043
+ * @param {*} [axiosOptions] Override http request option.
113044
+ * @throws {RequiredError}
113045
+ */
113046
+ getNotificationPreferences(axiosOptions?: RawAxiosRequestConfig): AxiosPromise<PreferencesDtoV2025> {
113047
+ return localVarFp.getNotificationPreferences(axiosOptions).then((request) => request(axios, basePath));
112919
113048
  },
112920
113049
  /**
112921
113050
  * This gets a template that you have modified for your site by Id.
@@ -112925,17 +113054,16 @@ export const NotificationsV2025ApiFactory = function (configuration?: Configurat
112925
113054
  * @throws {RequiredError}
112926
113055
  */
112927
113056
  getNotificationTemplate(requestParameters: NotificationsV2025ApiGetNotificationTemplateRequest, axiosOptions?: RawAxiosRequestConfig): AxiosPromise<TemplateDtoV2025> {
112928
- return localVarFp.getNotificationTemplate(requestParameters.id, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(axios, basePath));
113057
+ return localVarFp.getNotificationTemplate(requestParameters.id, axiosOptions).then((request) => request(axios, basePath));
112929
113058
  },
112930
113059
  /**
112931
113060
  * The notification service maintains metadata to construct the notification templates or supply any information during the event propagation. The data-store where this information is retrieved is called \"Global Context\" (a.k.a. notification template context). It defines a set of attributes that will be available per tenant (organization).
112932
113061
  * @summary Get notification template context
112933
- * @param {NotificationsV2025ApiGetNotificationsTemplateContextRequest} requestParameters Request parameters.
112934
113062
  * @param {*} [axiosOptions] Override http request option.
112935
113063
  * @throws {RequiredError}
112936
113064
  */
112937
- getNotificationsTemplateContext(requestParameters: NotificationsV2025ApiGetNotificationsTemplateContextRequest = {}, axiosOptions?: RawAxiosRequestConfig): AxiosPromise<NotificationTemplateContextV2025> {
112938
- return localVarFp.getNotificationsTemplateContext(requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(axios, basePath));
113065
+ getNotificationsTemplateContext(axiosOptions?: RawAxiosRequestConfig): AxiosPromise<NotificationTemplateContextV2025> {
113066
+ return localVarFp.getNotificationsTemplateContext(axiosOptions).then((request) => request(axios, basePath));
112939
113067
  },
112940
113068
  /**
112941
113069
  * Retrieve a list of sender email addresses and their verification statuses
@@ -112945,17 +113073,7 @@ export const NotificationsV2025ApiFactory = function (configuration?: Configurat
112945
113073
  * @throws {RequiredError}
112946
113074
  */
112947
113075
  listFromAddresses(requestParameters: NotificationsV2025ApiListFromAddressesRequest = {}, axiosOptions?: RawAxiosRequestConfig): AxiosPromise<Array<EmailStatusDtoV2025>> {
112948
- return localVarFp.listFromAddresses(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(axios, basePath));
112949
- },
112950
- /**
112951
- * Returns a list of notification preferences for tenant.
112952
- * @summary List notification preferences for tenant.
112953
- * @param {NotificationsV2025ApiListNotificationPreferencesRequest} requestParameters Request parameters.
112954
- * @param {*} [axiosOptions] Override http request option.
112955
- * @throws {RequiredError}
112956
- */
112957
- listNotificationPreferences(requestParameters: NotificationsV2025ApiListNotificationPreferencesRequest = {}, axiosOptions?: RawAxiosRequestConfig): AxiosPromise<PreferencesDtoV2025> {
112958
- return localVarFp.listNotificationPreferences(requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(axios, basePath));
113076
+ return localVarFp.listFromAddresses(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then((request) => request(axios, basePath));
112959
113077
  },
112960
113078
  /**
112961
113079
  * This lists the default templates used for notifications, such as emails from IdentityNow.
@@ -112965,7 +113083,7 @@ export const NotificationsV2025ApiFactory = function (configuration?: Configurat
112965
113083
  * @throws {RequiredError}
112966
113084
  */
112967
113085
  listNotificationTemplateDefaults(requestParameters: NotificationsV2025ApiListNotificationTemplateDefaultsRequest = {}, axiosOptions?: RawAxiosRequestConfig): AxiosPromise<Array<TemplateDtoDefaultV2025>> {
112968
- return localVarFp.listNotificationTemplateDefaults(requestParameters.limit, requestParameters.offset, requestParameters.filters, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(axios, basePath));
113086
+ return localVarFp.listNotificationTemplateDefaults(requestParameters.limit, requestParameters.offset, requestParameters.filters, axiosOptions).then((request) => request(axios, basePath));
112969
113087
  },
112970
113088
  /**
112971
113089
  * This lists the templates that you have modified for your site.
@@ -112975,7 +113093,7 @@ export const NotificationsV2025ApiFactory = function (configuration?: Configurat
112975
113093
  * @throws {RequiredError}
112976
113094
  */
112977
113095
  listNotificationTemplates(requestParameters: NotificationsV2025ApiListNotificationTemplatesRequest = {}, axiosOptions?: RawAxiosRequestConfig): AxiosPromise<Array<TemplateDtoV2025>> {
112978
- return localVarFp.listNotificationTemplates(requestParameters.limit, requestParameters.offset, requestParameters.filters, requestParameters.sorters, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(axios, basePath));
113096
+ return localVarFp.listNotificationTemplates(requestParameters.limit, requestParameters.offset, requestParameters.filters, requestParameters.sorters, axiosOptions).then((request) => request(axios, basePath));
112979
113097
  },
112980
113098
  /**
112981
113099
  * Change the MAIL FROM domain of an AWS SES email identity and provide the MX and TXT records to be placed in the caller\'s DNS
@@ -112985,7 +113103,7 @@ export const NotificationsV2025ApiFactory = function (configuration?: Configurat
112985
113103
  * @throws {RequiredError}
112986
113104
  */
112987
113105
  putMailFromAttributes(requestParameters: NotificationsV2025ApiPutMailFromAttributesRequest, axiosOptions?: RawAxiosRequestConfig): AxiosPromise<MailFromAttributesV2025> {
112988
- return localVarFp.putMailFromAttributes(requestParameters.mailFromAttributesDtoV2025, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(axios, basePath));
113106
+ return localVarFp.putMailFromAttributes(requestParameters.mailFromAttributesDtoV2025, axiosOptions).then((request) => request(axios, basePath));
112989
113107
  },
112990
113108
  /**
112991
113109
  * Send a Test Notification
@@ -112995,7 +113113,7 @@ export const NotificationsV2025ApiFactory = function (configuration?: Configurat
112995
113113
  * @throws {RequiredError}
112996
113114
  */
112997
113115
  sendTestNotification(requestParameters: NotificationsV2025ApiSendTestNotificationRequest, axiosOptions?: RawAxiosRequestConfig): AxiosPromise<void> {
112998
- return localVarFp.sendTestNotification(requestParameters.sendTestNotificationRequestDtoV2025, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(axios, basePath));
113116
+ return localVarFp.sendTestNotification(requestParameters.sendTestNotificationRequestDtoV2025, axiosOptions).then((request) => request(axios, basePath));
112999
113117
  },
113000
113118
  };
113001
113119
  };
@@ -113012,13 +113130,6 @@ export interface NotificationsV2025ApiCreateDomainDkimRequest {
113012
113130
  * @memberof NotificationsV2025ApiCreateDomainDkim
113013
113131
  */
113014
113132
  readonly domainAddressV2025: DomainAddressV2025
113015
-
113016
- /**
113017
- * Use this header to enable this experimental API.
113018
- * @type {string}
113019
- * @memberof NotificationsV2025ApiCreateDomainDkim
113020
- */
113021
- readonly xSailPointExperimental?: string
113022
113133
  }
113023
113134
 
113024
113135
  /**
@@ -113033,13 +113144,6 @@ export interface NotificationsV2025ApiCreateNotificationTemplateRequest {
113033
113144
  * @memberof NotificationsV2025ApiCreateNotificationTemplate
113034
113145
  */
113035
113146
  readonly templateDtoV2025: TemplateDtoV2025
113036
-
113037
- /**
113038
- * Use this header to enable this experimental API.
113039
- * @type {string}
113040
- * @memberof NotificationsV2025ApiCreateNotificationTemplate
113041
- */
113042
- readonly xSailPointExperimental?: string
113043
113147
  }
113044
113148
 
113045
113149
  /**
@@ -113054,13 +113158,6 @@ export interface NotificationsV2025ApiCreateVerifiedFromAddressRequest {
113054
113158
  * @memberof NotificationsV2025ApiCreateVerifiedFromAddress
113055
113159
  */
113056
113160
  readonly emailStatusDtoV2025: EmailStatusDtoV2025
113057
-
113058
- /**
113059
- * Use this header to enable this experimental API.
113060
- * @type {string}
113061
- * @memberof NotificationsV2025ApiCreateVerifiedFromAddress
113062
- */
113063
- readonly xSailPointExperimental?: string
113064
113161
  }
113065
113162
 
113066
113163
  /**
@@ -113075,13 +113172,6 @@ export interface NotificationsV2025ApiDeleteNotificationTemplatesInBulkRequest {
113075
113172
  * @memberof NotificationsV2025ApiDeleteNotificationTemplatesInBulk
113076
113173
  */
113077
113174
  readonly templateBulkDeleteDtoV2025: Array<TemplateBulkDeleteDtoV2025>
113078
-
113079
- /**
113080
- * Use this header to enable this experimental API.
113081
- * @type {string}
113082
- * @memberof NotificationsV2025ApiDeleteNotificationTemplatesInBulk
113083
- */
113084
- readonly xSailPointExperimental?: string
113085
113175
  }
113086
113176
 
113087
113177
  /**
@@ -113091,18 +113181,11 @@ export interface NotificationsV2025ApiDeleteNotificationTemplatesInBulkRequest {
113091
113181
  */
113092
113182
  export interface NotificationsV2025ApiDeleteVerifiedFromAddressRequest {
113093
113183
  /**
113094
- *
113184
+ * Unique identifier of the verified sender address to delete.
113095
113185
  * @type {string}
113096
113186
  * @memberof NotificationsV2025ApiDeleteVerifiedFromAddress
113097
113187
  */
113098
113188
  readonly id: string
113099
-
113100
- /**
113101
- * Use this header to enable this experimental API.
113102
- * @type {string}
113103
- * @memberof NotificationsV2025ApiDeleteVerifiedFromAddress
113104
- */
113105
- readonly xSailPointExperimental?: string
113106
113189
  }
113107
113190
 
113108
113191
  /**
@@ -113112,11 +113195,18 @@ export interface NotificationsV2025ApiDeleteVerifiedFromAddressRequest {
113112
113195
  */
113113
113196
  export interface NotificationsV2025ApiGetDkimAttributesRequest {
113114
113197
  /**
113115
- * Use this header to enable this experimental API.
113116
- * @type {string}
113198
+ * Max number of results to return. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
113199
+ * @type {number}
113117
113200
  * @memberof NotificationsV2025ApiGetDkimAttributes
113118
113201
  */
113119
- readonly xSailPointExperimental?: string
113202
+ readonly limit?: number
113203
+
113204
+ /**
113205
+ * Offset into the full result set. Usually specified with *limit* to paginate through the results. See [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters) for more information.
113206
+ * @type {number}
113207
+ * @memberof NotificationsV2025ApiGetDkimAttributes
113208
+ */
113209
+ readonly offset?: number
113120
113210
  }
113121
113211
 
113122
113212
  /**
@@ -113130,14 +113220,7 @@ export interface NotificationsV2025ApiGetMailFromAttributesRequest {
113130
113220
  * @type {string}
113131
113221
  * @memberof NotificationsV2025ApiGetMailFromAttributes
113132
113222
  */
113133
- readonly id: string
113134
-
113135
- /**
113136
- * Use this header to enable this experimental API.
113137
- * @type {string}
113138
- * @memberof NotificationsV2025ApiGetMailFromAttributes
113139
- */
113140
- readonly xSailPointExperimental?: string
113223
+ readonly identity: string
113141
113224
  }
113142
113225
 
113143
113226
  /**
@@ -113152,27 +113235,6 @@ export interface NotificationsV2025ApiGetNotificationTemplateRequest {
113152
113235
  * @memberof NotificationsV2025ApiGetNotificationTemplate
113153
113236
  */
113154
113237
  readonly id: string
113155
-
113156
- /**
113157
- * Use this header to enable this experimental API.
113158
- * @type {string}
113159
- * @memberof NotificationsV2025ApiGetNotificationTemplate
113160
- */
113161
- readonly xSailPointExperimental?: string
113162
- }
113163
-
113164
- /**
113165
- * Request parameters for getNotificationsTemplateContext operation in NotificationsV2025Api.
113166
- * @export
113167
- * @interface NotificationsV2025ApiGetNotificationsTemplateContextRequest
113168
- */
113169
- export interface NotificationsV2025ApiGetNotificationsTemplateContextRequest {
113170
- /**
113171
- * Use this header to enable this experimental API.
113172
- * @type {string}
113173
- * @memberof NotificationsV2025ApiGetNotificationsTemplateContext
113174
- */
113175
- readonly xSailPointExperimental?: string
113176
113238
  }
113177
113239
 
113178
113240
  /**
@@ -113203,7 +113265,7 @@ export interface NotificationsV2025ApiListFromAddressesRequest {
113203
113265
  readonly count?: boolean
113204
113266
 
113205
113267
  /**
113206
- * Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results) Filtering is supported for the following fields and operators: **email**: *eq, ge, le, sw*
113268
+ * Filter results using the standard syntax described in [V3 API Standard Collection Parameters](https://developer.sailpoint.com/idn/api/standard-collection-parameters#filtering-results) Filtering is supported for the following fields and operators: **email**: *eq, ge, le, gt, lt*
113207
113269
  * @type {string}
113208
113270
  * @memberof NotificationsV2025ApiListFromAddresses
113209
113271
  */
@@ -113215,27 +113277,6 @@ export interface NotificationsV2025ApiListFromAddressesRequest {
113215
113277
  * @memberof NotificationsV2025ApiListFromAddresses
113216
113278
  */
113217
113279
  readonly sorters?: string
113218
-
113219
- /**
113220
- * Use this header to enable this experimental API.
113221
- * @type {string}
113222
- * @memberof NotificationsV2025ApiListFromAddresses
113223
- */
113224
- readonly xSailPointExperimental?: string
113225
- }
113226
-
113227
- /**
113228
- * Request parameters for listNotificationPreferences operation in NotificationsV2025Api.
113229
- * @export
113230
- * @interface NotificationsV2025ApiListNotificationPreferencesRequest
113231
- */
113232
- export interface NotificationsV2025ApiListNotificationPreferencesRequest {
113233
- /**
113234
- * Use this header to enable this experimental API.
113235
- * @type {string}
113236
- * @memberof NotificationsV2025ApiListNotificationPreferences
113237
- */
113238
- readonly xSailPointExperimental?: string
113239
113280
  }
113240
113281
 
113241
113282
  /**
@@ -113264,13 +113305,6 @@ export interface NotificationsV2025ApiListNotificationTemplateDefaultsRequest {
113264
113305
  * @memberof NotificationsV2025ApiListNotificationTemplateDefaults
113265
113306
  */
113266
113307
  readonly filters?: string
113267
-
113268
- /**
113269
- * Use this header to enable this experimental API.
113270
- * @type {string}
113271
- * @memberof NotificationsV2025ApiListNotificationTemplateDefaults
113272
- */
113273
- readonly xSailPointExperimental?: string
113274
113308
  }
113275
113309
 
113276
113310
  /**
@@ -113306,13 +113340,6 @@ export interface NotificationsV2025ApiListNotificationTemplatesRequest {
113306
113340
  * @memberof NotificationsV2025ApiListNotificationTemplates
113307
113341
  */
113308
113342
  readonly sorters?: string
113309
-
113310
- /**
113311
- * Use this header to enable this experimental API.
113312
- * @type {string}
113313
- * @memberof NotificationsV2025ApiListNotificationTemplates
113314
- */
113315
- readonly xSailPointExperimental?: string
113316
113343
  }
113317
113344
 
113318
113345
  /**
@@ -113327,13 +113354,6 @@ export interface NotificationsV2025ApiPutMailFromAttributesRequest {
113327
113354
  * @memberof NotificationsV2025ApiPutMailFromAttributes
113328
113355
  */
113329
113356
  readonly mailFromAttributesDtoV2025: MailFromAttributesDtoV2025
113330
-
113331
- /**
113332
- * Use this header to enable this experimental API.
113333
- * @type {string}
113334
- * @memberof NotificationsV2025ApiPutMailFromAttributes
113335
- */
113336
- readonly xSailPointExperimental?: string
113337
113357
  }
113338
113358
 
113339
113359
  /**
@@ -113348,13 +113368,6 @@ export interface NotificationsV2025ApiSendTestNotificationRequest {
113348
113368
  * @memberof NotificationsV2025ApiSendTestNotification
113349
113369
  */
113350
113370
  readonly sendTestNotificationRequestDtoV2025: SendTestNotificationRequestDtoV2025
113351
-
113352
- /**
113353
- * Use this header to enable this experimental API.
113354
- * @type {string}
113355
- * @memberof NotificationsV2025ApiSendTestNotification
113356
- */
113357
- readonly xSailPointExperimental?: string
113358
113371
  }
113359
113372
 
113360
113373
  /**
@@ -113373,7 +113386,7 @@ export class NotificationsV2025Api extends BaseAPI {
113373
113386
  * @memberof NotificationsV2025Api
113374
113387
  */
113375
113388
  public createDomainDkim(requestParameters: NotificationsV2025ApiCreateDomainDkimRequest, axiosOptions?: RawAxiosRequestConfig) {
113376
- return NotificationsV2025ApiFp(this.configuration).createDomainDkim(requestParameters.domainAddressV2025, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(this.axios, this.basePath));
113389
+ return NotificationsV2025ApiFp(this.configuration).createDomainDkim(requestParameters.domainAddressV2025, axiosOptions).then((request) => request(this.axios, this.basePath));
113377
113390
  }
113378
113391
 
113379
113392
  /**
@@ -113385,7 +113398,7 @@ export class NotificationsV2025Api extends BaseAPI {
113385
113398
  * @memberof NotificationsV2025Api
113386
113399
  */
113387
113400
  public createNotificationTemplate(requestParameters: NotificationsV2025ApiCreateNotificationTemplateRequest, axiosOptions?: RawAxiosRequestConfig) {
113388
- return NotificationsV2025ApiFp(this.configuration).createNotificationTemplate(requestParameters.templateDtoV2025, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(this.axios, this.basePath));
113401
+ return NotificationsV2025ApiFp(this.configuration).createNotificationTemplate(requestParameters.templateDtoV2025, axiosOptions).then((request) => request(this.axios, this.basePath));
113389
113402
  }
113390
113403
 
113391
113404
  /**
@@ -113397,11 +113410,11 @@ export class NotificationsV2025Api extends BaseAPI {
113397
113410
  * @memberof NotificationsV2025Api
113398
113411
  */
113399
113412
  public createVerifiedFromAddress(requestParameters: NotificationsV2025ApiCreateVerifiedFromAddressRequest, axiosOptions?: RawAxiosRequestConfig) {
113400
- return NotificationsV2025ApiFp(this.configuration).createVerifiedFromAddress(requestParameters.emailStatusDtoV2025, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(this.axios, this.basePath));
113413
+ return NotificationsV2025ApiFp(this.configuration).createVerifiedFromAddress(requestParameters.emailStatusDtoV2025, axiosOptions).then((request) => request(this.axios, this.basePath));
113401
113414
  }
113402
113415
 
113403
113416
  /**
113404
- * This lets you bulk delete templates that you previously created for your site. Since this is a beta feature, please contact support to enable usage.
113417
+ * This lets you bulk delete templates that you previously created for your site.
113405
113418
  * @summary Bulk delete notification templates
113406
113419
  * @param {NotificationsV2025ApiDeleteNotificationTemplatesInBulkRequest} requestParameters Request parameters.
113407
113420
  * @param {*} [axiosOptions] Override http request option.
@@ -113409,7 +113422,7 @@ export class NotificationsV2025Api extends BaseAPI {
113409
113422
  * @memberof NotificationsV2025Api
113410
113423
  */
113411
113424
  public deleteNotificationTemplatesInBulk(requestParameters: NotificationsV2025ApiDeleteNotificationTemplatesInBulkRequest, axiosOptions?: RawAxiosRequestConfig) {
113412
- return NotificationsV2025ApiFp(this.configuration).deleteNotificationTemplatesInBulk(requestParameters.templateBulkDeleteDtoV2025, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(this.axios, this.basePath));
113425
+ return NotificationsV2025ApiFp(this.configuration).deleteNotificationTemplatesInBulk(requestParameters.templateBulkDeleteDtoV2025, axiosOptions).then((request) => request(this.axios, this.basePath));
113413
113426
  }
113414
113427
 
113415
113428
  /**
@@ -113421,7 +113434,7 @@ export class NotificationsV2025Api extends BaseAPI {
113421
113434
  * @memberof NotificationsV2025Api
113422
113435
  */
113423
113436
  public deleteVerifiedFromAddress(requestParameters: NotificationsV2025ApiDeleteVerifiedFromAddressRequest, axiosOptions?: RawAxiosRequestConfig) {
113424
- return NotificationsV2025ApiFp(this.configuration).deleteVerifiedFromAddress(requestParameters.id, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(this.axios, this.basePath));
113437
+ return NotificationsV2025ApiFp(this.configuration).deleteVerifiedFromAddress(requestParameters.id, axiosOptions).then((request) => request(this.axios, this.basePath));
113425
113438
  }
113426
113439
 
113427
113440
  /**
@@ -113433,7 +113446,7 @@ export class NotificationsV2025Api extends BaseAPI {
113433
113446
  * @memberof NotificationsV2025Api
113434
113447
  */
113435
113448
  public getDkimAttributes(requestParameters: NotificationsV2025ApiGetDkimAttributesRequest = {}, axiosOptions?: RawAxiosRequestConfig) {
113436
- return NotificationsV2025ApiFp(this.configuration).getDkimAttributes(requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(this.axios, this.basePath));
113449
+ return NotificationsV2025ApiFp(this.configuration).getDkimAttributes(requestParameters.limit, requestParameters.offset, axiosOptions).then((request) => request(this.axios, this.basePath));
113437
113450
  }
113438
113451
 
113439
113452
  /**
@@ -113445,7 +113458,18 @@ export class NotificationsV2025Api extends BaseAPI {
113445
113458
  * @memberof NotificationsV2025Api
113446
113459
  */
113447
113460
  public getMailFromAttributes(requestParameters: NotificationsV2025ApiGetMailFromAttributesRequest, axiosOptions?: RawAxiosRequestConfig) {
113448
- return NotificationsV2025ApiFp(this.configuration).getMailFromAttributes(requestParameters.id, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(this.axios, this.basePath));
113461
+ return NotificationsV2025ApiFp(this.configuration).getMailFromAttributes(requestParameters.identity, axiosOptions).then((request) => request(this.axios, this.basePath));
113462
+ }
113463
+
113464
+ /**
113465
+ * Returns a list of notification preferences for tenant.
113466
+ * @summary List notification preferences for tenant.
113467
+ * @param {*} [axiosOptions] Override http request option.
113468
+ * @throws {RequiredError}
113469
+ * @memberof NotificationsV2025Api
113470
+ */
113471
+ public getNotificationPreferences(axiosOptions?: RawAxiosRequestConfig) {
113472
+ return NotificationsV2025ApiFp(this.configuration).getNotificationPreferences(axiosOptions).then((request) => request(this.axios, this.basePath));
113449
113473
  }
113450
113474
 
113451
113475
  /**
@@ -113457,19 +113481,18 @@ export class NotificationsV2025Api extends BaseAPI {
113457
113481
  * @memberof NotificationsV2025Api
113458
113482
  */
113459
113483
  public getNotificationTemplate(requestParameters: NotificationsV2025ApiGetNotificationTemplateRequest, axiosOptions?: RawAxiosRequestConfig) {
113460
- return NotificationsV2025ApiFp(this.configuration).getNotificationTemplate(requestParameters.id, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(this.axios, this.basePath));
113484
+ return NotificationsV2025ApiFp(this.configuration).getNotificationTemplate(requestParameters.id, axiosOptions).then((request) => request(this.axios, this.basePath));
113461
113485
  }
113462
113486
 
113463
113487
  /**
113464
113488
  * The notification service maintains metadata to construct the notification templates or supply any information during the event propagation. The data-store where this information is retrieved is called \"Global Context\" (a.k.a. notification template context). It defines a set of attributes that will be available per tenant (organization).
113465
113489
  * @summary Get notification template context
113466
- * @param {NotificationsV2025ApiGetNotificationsTemplateContextRequest} requestParameters Request parameters.
113467
113490
  * @param {*} [axiosOptions] Override http request option.
113468
113491
  * @throws {RequiredError}
113469
113492
  * @memberof NotificationsV2025Api
113470
113493
  */
113471
- public getNotificationsTemplateContext(requestParameters: NotificationsV2025ApiGetNotificationsTemplateContextRequest = {}, axiosOptions?: RawAxiosRequestConfig) {
113472
- return NotificationsV2025ApiFp(this.configuration).getNotificationsTemplateContext(requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(this.axios, this.basePath));
113494
+ public getNotificationsTemplateContext(axiosOptions?: RawAxiosRequestConfig) {
113495
+ return NotificationsV2025ApiFp(this.configuration).getNotificationsTemplateContext(axiosOptions).then((request) => request(this.axios, this.basePath));
113473
113496
  }
113474
113497
 
113475
113498
  /**
@@ -113481,19 +113504,7 @@ export class NotificationsV2025Api extends BaseAPI {
113481
113504
  * @memberof NotificationsV2025Api
113482
113505
  */
113483
113506
  public listFromAddresses(requestParameters: NotificationsV2025ApiListFromAddressesRequest = {}, axiosOptions?: RawAxiosRequestConfig) {
113484
- return NotificationsV2025ApiFp(this.configuration).listFromAddresses(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(this.axios, this.basePath));
113485
- }
113486
-
113487
- /**
113488
- * Returns a list of notification preferences for tenant.
113489
- * @summary List notification preferences for tenant.
113490
- * @param {NotificationsV2025ApiListNotificationPreferencesRequest} requestParameters Request parameters.
113491
- * @param {*} [axiosOptions] Override http request option.
113492
- * @throws {RequiredError}
113493
- * @memberof NotificationsV2025Api
113494
- */
113495
- public listNotificationPreferences(requestParameters: NotificationsV2025ApiListNotificationPreferencesRequest = {}, axiosOptions?: RawAxiosRequestConfig) {
113496
- return NotificationsV2025ApiFp(this.configuration).listNotificationPreferences(requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(this.axios, this.basePath));
113507
+ return NotificationsV2025ApiFp(this.configuration).listFromAddresses(requestParameters.limit, requestParameters.offset, requestParameters.count, requestParameters.filters, requestParameters.sorters, axiosOptions).then((request) => request(this.axios, this.basePath));
113497
113508
  }
113498
113509
 
113499
113510
  /**
@@ -113505,7 +113516,7 @@ export class NotificationsV2025Api extends BaseAPI {
113505
113516
  * @memberof NotificationsV2025Api
113506
113517
  */
113507
113518
  public listNotificationTemplateDefaults(requestParameters: NotificationsV2025ApiListNotificationTemplateDefaultsRequest = {}, axiosOptions?: RawAxiosRequestConfig) {
113508
- return NotificationsV2025ApiFp(this.configuration).listNotificationTemplateDefaults(requestParameters.limit, requestParameters.offset, requestParameters.filters, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(this.axios, this.basePath));
113519
+ return NotificationsV2025ApiFp(this.configuration).listNotificationTemplateDefaults(requestParameters.limit, requestParameters.offset, requestParameters.filters, axiosOptions).then((request) => request(this.axios, this.basePath));
113509
113520
  }
113510
113521
 
113511
113522
  /**
@@ -113517,7 +113528,7 @@ export class NotificationsV2025Api extends BaseAPI {
113517
113528
  * @memberof NotificationsV2025Api
113518
113529
  */
113519
113530
  public listNotificationTemplates(requestParameters: NotificationsV2025ApiListNotificationTemplatesRequest = {}, axiosOptions?: RawAxiosRequestConfig) {
113520
- return NotificationsV2025ApiFp(this.configuration).listNotificationTemplates(requestParameters.limit, requestParameters.offset, requestParameters.filters, requestParameters.sorters, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(this.axios, this.basePath));
113531
+ return NotificationsV2025ApiFp(this.configuration).listNotificationTemplates(requestParameters.limit, requestParameters.offset, requestParameters.filters, requestParameters.sorters, axiosOptions).then((request) => request(this.axios, this.basePath));
113521
113532
  }
113522
113533
 
113523
113534
  /**
@@ -113529,7 +113540,7 @@ export class NotificationsV2025Api extends BaseAPI {
113529
113540
  * @memberof NotificationsV2025Api
113530
113541
  */
113531
113542
  public putMailFromAttributes(requestParameters: NotificationsV2025ApiPutMailFromAttributesRequest, axiosOptions?: RawAxiosRequestConfig) {
113532
- return NotificationsV2025ApiFp(this.configuration).putMailFromAttributes(requestParameters.mailFromAttributesDtoV2025, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(this.axios, this.basePath));
113543
+ return NotificationsV2025ApiFp(this.configuration).putMailFromAttributes(requestParameters.mailFromAttributesDtoV2025, axiosOptions).then((request) => request(this.axios, this.basePath));
113533
113544
  }
113534
113545
 
113535
113546
  /**
@@ -113541,7 +113552,7 @@ export class NotificationsV2025Api extends BaseAPI {
113541
113552
  * @memberof NotificationsV2025Api
113542
113553
  */
113543
113554
  public sendTestNotification(requestParameters: NotificationsV2025ApiSendTestNotificationRequest, axiosOptions?: RawAxiosRequestConfig) {
113544
- return NotificationsV2025ApiFp(this.configuration).sendTestNotification(requestParameters.sendTestNotificationRequestDtoV2025, requestParameters.xSailPointExperimental, axiosOptions).then((request) => request(this.axios, this.basePath));
113555
+ return NotificationsV2025ApiFp(this.configuration).sendTestNotification(requestParameters.sendTestNotificationRequestDtoV2025, axiosOptions).then((request) => request(this.axios, this.basePath));
113545
113556
  }
113546
113557
  }
113547
113558