@flashstart/client 0.1.0
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/README.md +37 -0
- package/dist/src/generated/client/client.gen.d.ts +2 -0
- package/dist/src/generated/client/client.gen.js +216 -0
- package/dist/src/generated/client/index.d.ts +10 -0
- package/dist/src/generated/client/index.js +6 -0
- package/dist/src/generated/client/types.gen.d.ts +120 -0
- package/dist/src/generated/client/types.gen.js +2 -0
- package/dist/src/generated/client/utils.gen.d.ts +37 -0
- package/dist/src/generated/client/utils.gen.js +228 -0
- package/dist/src/generated/client.gen.d.ts +12 -0
- package/dist/src/generated/client.gen.js +3 -0
- package/dist/src/generated/core/auth.gen.d.ts +25 -0
- package/dist/src/generated/core/auth.gen.js +14 -0
- package/dist/src/generated/core/bodySerializer.gen.d.ts +25 -0
- package/dist/src/generated/core/bodySerializer.gen.js +57 -0
- package/dist/src/generated/core/params.gen.d.ts +43 -0
- package/dist/src/generated/core/params.gen.js +109 -0
- package/dist/src/generated/core/pathSerializer.gen.d.ts +33 -0
- package/dist/src/generated/core/pathSerializer.gen.js +106 -0
- package/dist/src/generated/core/queryKeySerializer.gen.d.ts +18 -0
- package/dist/src/generated/core/queryKeySerializer.gen.js +92 -0
- package/dist/src/generated/core/serverSentEvents.gen.d.ts +71 -0
- package/dist/src/generated/core/serverSentEvents.gen.js +132 -0
- package/dist/src/generated/core/types.gen.d.ts +83 -0
- package/dist/src/generated/core/types.gen.js +2 -0
- package/dist/src/generated/core/utils.gen.d.ts +19 -0
- package/dist/src/generated/core/utils.gen.js +87 -0
- package/dist/src/generated/index.d.ts +2 -0
- package/dist/src/generated/index.js +2 -0
- package/dist/src/generated/network/client/client.gen.d.ts +2 -0
- package/dist/src/generated/network/client/client.gen.js +216 -0
- package/dist/src/generated/network/client/index.d.ts +10 -0
- package/dist/src/generated/network/client/index.js +6 -0
- package/dist/src/generated/network/client/types.gen.d.ts +120 -0
- package/dist/src/generated/network/client/types.gen.js +2 -0
- package/dist/src/generated/network/client/utils.gen.d.ts +37 -0
- package/dist/src/generated/network/client/utils.gen.js +228 -0
- package/dist/src/generated/network/client.gen.d.ts +12 -0
- package/dist/src/generated/network/client.gen.js +3 -0
- package/dist/src/generated/network/core/auth.gen.d.ts +25 -0
- package/dist/src/generated/network/core/auth.gen.js +14 -0
- package/dist/src/generated/network/core/bodySerializer.gen.d.ts +25 -0
- package/dist/src/generated/network/core/bodySerializer.gen.js +57 -0
- package/dist/src/generated/network/core/params.gen.d.ts +43 -0
- package/dist/src/generated/network/core/params.gen.js +109 -0
- package/dist/src/generated/network/core/pathSerializer.gen.d.ts +33 -0
- package/dist/src/generated/network/core/pathSerializer.gen.js +106 -0
- package/dist/src/generated/network/core/queryKeySerializer.gen.d.ts +18 -0
- package/dist/src/generated/network/core/queryKeySerializer.gen.js +92 -0
- package/dist/src/generated/network/core/serverSentEvents.gen.d.ts +71 -0
- package/dist/src/generated/network/core/serverSentEvents.gen.js +132 -0
- package/dist/src/generated/network/core/types.gen.d.ts +83 -0
- package/dist/src/generated/network/core/types.gen.js +2 -0
- package/dist/src/generated/network/core/utils.gen.d.ts +19 -0
- package/dist/src/generated/network/core/utils.gen.js +87 -0
- package/dist/src/generated/network/index.d.ts +2 -0
- package/dist/src/generated/network/index.js +2 -0
- package/dist/src/generated/network/sdk.gen.d.ts +135 -0
- package/dist/src/generated/network/sdk.gen.js +339 -0
- package/dist/src/generated/network/types.gen.d.ts +1188 -0
- package/dist/src/generated/network/types.gen.js +2 -0
- package/dist/src/generated/protection/client/client.gen.d.ts +2 -0
- package/dist/src/generated/protection/client/client.gen.js +216 -0
- package/dist/src/generated/protection/client/index.d.ts +10 -0
- package/dist/src/generated/protection/client/index.js +6 -0
- package/dist/src/generated/protection/client/types.gen.d.ts +120 -0
- package/dist/src/generated/protection/client/types.gen.js +2 -0
- package/dist/src/generated/protection/client/utils.gen.d.ts +37 -0
- package/dist/src/generated/protection/client/utils.gen.js +228 -0
- package/dist/src/generated/protection/client.gen.d.ts +12 -0
- package/dist/src/generated/protection/client.gen.js +3 -0
- package/dist/src/generated/protection/core/auth.gen.d.ts +25 -0
- package/dist/src/generated/protection/core/auth.gen.js +14 -0
- package/dist/src/generated/protection/core/bodySerializer.gen.d.ts +25 -0
- package/dist/src/generated/protection/core/bodySerializer.gen.js +57 -0
- package/dist/src/generated/protection/core/params.gen.d.ts +43 -0
- package/dist/src/generated/protection/core/params.gen.js +109 -0
- package/dist/src/generated/protection/core/pathSerializer.gen.d.ts +33 -0
- package/dist/src/generated/protection/core/pathSerializer.gen.js +106 -0
- package/dist/src/generated/protection/core/queryKeySerializer.gen.d.ts +18 -0
- package/dist/src/generated/protection/core/queryKeySerializer.gen.js +92 -0
- package/dist/src/generated/protection/core/serverSentEvents.gen.d.ts +71 -0
- package/dist/src/generated/protection/core/serverSentEvents.gen.js +132 -0
- package/dist/src/generated/protection/core/types.gen.d.ts +83 -0
- package/dist/src/generated/protection/core/types.gen.js +2 -0
- package/dist/src/generated/protection/core/utils.gen.d.ts +19 -0
- package/dist/src/generated/protection/core/utils.gen.js +87 -0
- package/dist/src/generated/protection/index.d.ts +2 -0
- package/dist/src/generated/protection/index.js +2 -0
- package/dist/src/generated/protection/sdk.gen.d.ts +255 -0
- package/dist/src/generated/protection/sdk.gen.js +663 -0
- package/dist/src/generated/protection/types.gen.d.ts +2199 -0
- package/dist/src/generated/protection/types.gen.js +2 -0
- package/dist/src/generated/sdk.gen.d.ts +91 -0
- package/dist/src/generated/sdk.gen.js +206 -0
- package/dist/src/generated/types.gen.d.ts +909 -0
- package/dist/src/generated/types.gen.js +2 -0
- package/dist/src/index.d.ts +50 -0
- package/dist/src/index.js +85 -0
- package/package.json +34 -0
|
@@ -0,0 +1,2199 @@
|
|
|
1
|
+
export type ClientOptions = {
|
|
2
|
+
baseUrl: 'https://core.flashstart.com/protection' | (string & {});
|
|
3
|
+
};
|
|
4
|
+
export type Uuid = string;
|
|
5
|
+
export type Policy = {
|
|
6
|
+
id: Uuid;
|
|
7
|
+
isLimited: boolean;
|
|
8
|
+
isShared: boolean;
|
|
9
|
+
name: string;
|
|
10
|
+
organizationId: Uuid;
|
|
11
|
+
};
|
|
12
|
+
export type PolicyCreation = {
|
|
13
|
+
name: string;
|
|
14
|
+
isLimited: boolean;
|
|
15
|
+
isShared?: boolean;
|
|
16
|
+
organizationId?: Uuid;
|
|
17
|
+
templateId?: Uuid;
|
|
18
|
+
};
|
|
19
|
+
export type PolicyUpdate = {
|
|
20
|
+
name?: string;
|
|
21
|
+
isLimited?: boolean;
|
|
22
|
+
isShared?: boolean;
|
|
23
|
+
};
|
|
24
|
+
export type PolicySettings = {
|
|
25
|
+
bingSafeSearchEnabled: boolean;
|
|
26
|
+
duckduckgoSafeSearchEnabled: boolean;
|
|
27
|
+
googleSafeSearchEnabled: boolean;
|
|
28
|
+
ipBlockingEnabled: boolean;
|
|
29
|
+
youtubeSafeSearchEnabled: boolean;
|
|
30
|
+
};
|
|
31
|
+
export type PolicySettingsUpdate = {
|
|
32
|
+
bingSafeSearchEnabled?: boolean;
|
|
33
|
+
duckduckgoSafeSearchEnabled?: boolean;
|
|
34
|
+
googleSafeSearchEnabled?: boolean;
|
|
35
|
+
ipBlockingEnabled?: boolean;
|
|
36
|
+
youtubeSafeSearchEnabled?: boolean;
|
|
37
|
+
};
|
|
38
|
+
export type BaseNetwork = {
|
|
39
|
+
id: Uuid;
|
|
40
|
+
type: 'STATIC_SINGLE' | 'STATIC_CIDR' | 'STATIC_RANGE' | 'DYNAMIC_INTERNAL' | 'DYNAMIC_EXTERNAL' | 'STATIC_ENCRYPTED';
|
|
41
|
+
name: string;
|
|
42
|
+
note: string;
|
|
43
|
+
organizationId: Uuid;
|
|
44
|
+
createdAt: string;
|
|
45
|
+
updatedAt: string;
|
|
46
|
+
lastQueriedAt?: string;
|
|
47
|
+
};
|
|
48
|
+
export type PolicyWithNetworks = Policy & {
|
|
49
|
+
networks: Array<BaseNetwork>;
|
|
50
|
+
};
|
|
51
|
+
export type PolicyExceptionGroup = {
|
|
52
|
+
exceptionGroupId: Uuid;
|
|
53
|
+
policyId: Uuid;
|
|
54
|
+
};
|
|
55
|
+
export type DynamicDnsRedirect = {
|
|
56
|
+
isEnabled: boolean;
|
|
57
|
+
};
|
|
58
|
+
export type Category = {
|
|
59
|
+
code: string;
|
|
60
|
+
id: Uuid;
|
|
61
|
+
macroCategoryId: Uuid;
|
|
62
|
+
name: string;
|
|
63
|
+
};
|
|
64
|
+
export type MacroCategoryWithCategories = {
|
|
65
|
+
id: Uuid;
|
|
66
|
+
name: string;
|
|
67
|
+
protectionModule: 'content_filter' | 'malware_protection' | 'app_blocker';
|
|
68
|
+
categories: Array<Category>;
|
|
69
|
+
};
|
|
70
|
+
export type TimeBlock = {
|
|
71
|
+
day: number;
|
|
72
|
+
from: string;
|
|
73
|
+
to: string;
|
|
74
|
+
};
|
|
75
|
+
export type TimeBlockRequest = {
|
|
76
|
+
day: number;
|
|
77
|
+
from: string;
|
|
78
|
+
to: string;
|
|
79
|
+
};
|
|
80
|
+
export type BlockedCategoryWithTimeBlock = TimeBlock & {
|
|
81
|
+
categoryId: Uuid;
|
|
82
|
+
id: Uuid;
|
|
83
|
+
policyId: Uuid;
|
|
84
|
+
};
|
|
85
|
+
export type BlockedCategoryWithSchedule = {
|
|
86
|
+
categoryId: Uuid;
|
|
87
|
+
policyId: Uuid;
|
|
88
|
+
timeBlocks: Array<TimeBlock & {
|
|
89
|
+
id: Uuid;
|
|
90
|
+
}>;
|
|
91
|
+
};
|
|
92
|
+
export type CategoryScheduleRequest = {
|
|
93
|
+
categoryId: Uuid;
|
|
94
|
+
blockSchedulation: Array<TimeBlockRequest>;
|
|
95
|
+
};
|
|
96
|
+
export type CategoryBlockedOnPolicy = {
|
|
97
|
+
categoryId: Uuid;
|
|
98
|
+
policyId: Uuid;
|
|
99
|
+
};
|
|
100
|
+
export type Country = {
|
|
101
|
+
code: string;
|
|
102
|
+
continentId: Uuid;
|
|
103
|
+
id: Uuid;
|
|
104
|
+
name: string;
|
|
105
|
+
};
|
|
106
|
+
export type BlockedCountry = Country & {
|
|
107
|
+
policyId: Uuid;
|
|
108
|
+
};
|
|
109
|
+
export type ContinentWithCountries = {
|
|
110
|
+
code: string;
|
|
111
|
+
id: Uuid;
|
|
112
|
+
name: string;
|
|
113
|
+
countries: Array<Country>;
|
|
114
|
+
};
|
|
115
|
+
export type Tld = {
|
|
116
|
+
id: Uuid;
|
|
117
|
+
tld: string;
|
|
118
|
+
};
|
|
119
|
+
export type TldBlockedOnPolicy = Tld & {
|
|
120
|
+
policyId: Uuid;
|
|
121
|
+
tldId: Uuid;
|
|
122
|
+
};
|
|
123
|
+
export type MacroTldWithTlds = {
|
|
124
|
+
code: string;
|
|
125
|
+
id: Uuid;
|
|
126
|
+
name: string;
|
|
127
|
+
tlds: Array<Tld>;
|
|
128
|
+
};
|
|
129
|
+
export type ExceptionGroup = {
|
|
130
|
+
id: Uuid;
|
|
131
|
+
name: string;
|
|
132
|
+
organizationId: Uuid;
|
|
133
|
+
type: 'allowlist' | 'blocklist';
|
|
134
|
+
};
|
|
135
|
+
export type Domain = {
|
|
136
|
+
id: Uuid;
|
|
137
|
+
name: string;
|
|
138
|
+
note?: string | null;
|
|
139
|
+
};
|
|
140
|
+
export type DomainInput = {
|
|
141
|
+
domain: string;
|
|
142
|
+
note?: string;
|
|
143
|
+
};
|
|
144
|
+
export type DomainInExceptionGroup = {
|
|
145
|
+
domainId: Uuid;
|
|
146
|
+
exceptionGroupId: Uuid;
|
|
147
|
+
note?: string | null;
|
|
148
|
+
};
|
|
149
|
+
export type ExceptionGroupWithDomains = ExceptionGroup & {
|
|
150
|
+
domains: Array<Domain>;
|
|
151
|
+
};
|
|
152
|
+
export type ExceptionGroupWithDomainsAndPolicies = ExceptionGroupWithDomains & {
|
|
153
|
+
policies: Array<Policy>;
|
|
154
|
+
isHidden: boolean;
|
|
155
|
+
};
|
|
156
|
+
export type ExceptionGroupCreation = {
|
|
157
|
+
domains?: Array<string>;
|
|
158
|
+
name: string;
|
|
159
|
+
organizationId?: Uuid;
|
|
160
|
+
type: 'allowlist' | 'blocklist';
|
|
161
|
+
};
|
|
162
|
+
export type ExceptionGroupUpdate = {
|
|
163
|
+
name?: string;
|
|
164
|
+
type?: 'allowlist' | 'blocklist';
|
|
165
|
+
};
|
|
166
|
+
export type TemplateWithConfigData = {
|
|
167
|
+
id: Uuid;
|
|
168
|
+
name: string;
|
|
169
|
+
type: 'malware_threats' | 'malware_contents' | 'malware_free_time';
|
|
170
|
+
categories: Array<Category>;
|
|
171
|
+
settings: Array<'google_safesearch' | 'youtube_safesearch' | 'ip_blocking' | 'bing_safesearch' | 'duckduckgo_safesearch'>;
|
|
172
|
+
};
|
|
173
|
+
export type CategoryMultiStatus = MultiStatusCategoryBlockedOnPolicy;
|
|
174
|
+
export type CountryMultiStatus = MultiStatusBlockedCountry;
|
|
175
|
+
export type TldMultiStatus = MultiStatusTldBlockedOnPolicy;
|
|
176
|
+
export type MultiStatusCategoryBlockedOnPolicy = {
|
|
177
|
+
errors: Array<FlashStartErrorBody>;
|
|
178
|
+
successes: Array<CategoryBlockedOnPolicy>;
|
|
179
|
+
};
|
|
180
|
+
export type MultiStatusBlockedCountry = {
|
|
181
|
+
errors: Array<FlashStartErrorBody>;
|
|
182
|
+
successes: Array<BlockedCountry>;
|
|
183
|
+
};
|
|
184
|
+
export type MultiStatusTldBlockedOnPolicy = {
|
|
185
|
+
errors: Array<FlashStartErrorBody>;
|
|
186
|
+
successes: Array<TldBlockedOnPolicy>;
|
|
187
|
+
};
|
|
188
|
+
export type FlashStartErrorBody = {
|
|
189
|
+
code: string;
|
|
190
|
+
message?: string;
|
|
191
|
+
details?: unknown;
|
|
192
|
+
};
|
|
193
|
+
export type MissingCredentialsErrorBody = {
|
|
194
|
+
message: string;
|
|
195
|
+
};
|
|
196
|
+
export type PolicyId = Uuid;
|
|
197
|
+
export type ExceptionGroupId = Uuid;
|
|
198
|
+
export type DomainId = Uuid;
|
|
199
|
+
export type SchedulationId = Uuid;
|
|
200
|
+
export type TemplateId = Uuid;
|
|
201
|
+
export type TldName = string;
|
|
202
|
+
export type OrganizationId = Uuid;
|
|
203
|
+
export type Lang = string;
|
|
204
|
+
export type IncludeNetworkCount = 'true' | 'false';
|
|
205
|
+
export type IncludeAssociatedPolicies = 'true' | 'false';
|
|
206
|
+
export type PolicyCreation2 = PolicyCreation;
|
|
207
|
+
export type PolicyUpdate2 = PolicyUpdate;
|
|
208
|
+
export type PolicySettingsUpdate2 = PolicySettingsUpdate;
|
|
209
|
+
export type ExceptionGroupId2 = {
|
|
210
|
+
exceptionGroupId: Uuid;
|
|
211
|
+
};
|
|
212
|
+
export type CategoryIds = {
|
|
213
|
+
categoryIds: Array<Uuid>;
|
|
214
|
+
};
|
|
215
|
+
export type CountryIds = {
|
|
216
|
+
countryIds: Array<Uuid>;
|
|
217
|
+
};
|
|
218
|
+
export type TldIds = {
|
|
219
|
+
tldIds: Array<Uuid>;
|
|
220
|
+
};
|
|
221
|
+
export type CategorySchedule = CategoryScheduleRequest;
|
|
222
|
+
export type ExceptionGroupCreation2 = ExceptionGroupCreation;
|
|
223
|
+
export type ExceptionGroupUpdate2 = ExceptionGroupUpdate;
|
|
224
|
+
export type Domains = {
|
|
225
|
+
domains: Array<DomainInput>;
|
|
226
|
+
};
|
|
227
|
+
export type DomainNote = {
|
|
228
|
+
note?: string | null;
|
|
229
|
+
};
|
|
230
|
+
export type ListPoliciesData = {
|
|
231
|
+
body?: never;
|
|
232
|
+
path?: never;
|
|
233
|
+
query?: {
|
|
234
|
+
organizationId?: Uuid;
|
|
235
|
+
includeNetworkCount?: 'true' | 'false';
|
|
236
|
+
};
|
|
237
|
+
url: '/v1/policies';
|
|
238
|
+
};
|
|
239
|
+
export type ListPoliciesErrors = {
|
|
240
|
+
/**
|
|
241
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
242
|
+
*/
|
|
243
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
244
|
+
/**
|
|
245
|
+
* Insufficient permission
|
|
246
|
+
*/
|
|
247
|
+
403: FlashStartErrorBody;
|
|
248
|
+
/**
|
|
249
|
+
* Resource not found
|
|
250
|
+
*/
|
|
251
|
+
404: FlashStartErrorBody;
|
|
252
|
+
/**
|
|
253
|
+
* Internal server error
|
|
254
|
+
*/
|
|
255
|
+
500: FlashStartErrorBody;
|
|
256
|
+
};
|
|
257
|
+
export type ListPoliciesError = ListPoliciesErrors[keyof ListPoliciesErrors];
|
|
258
|
+
export type ListPoliciesResponses = {
|
|
259
|
+
/**
|
|
260
|
+
* Policies
|
|
261
|
+
*/
|
|
262
|
+
200: Array<Policy | PolicyWithNetworks>;
|
|
263
|
+
};
|
|
264
|
+
export type ListPoliciesResponse = ListPoliciesResponses[keyof ListPoliciesResponses];
|
|
265
|
+
export type CreatePolicyData = {
|
|
266
|
+
body: PolicyCreation2;
|
|
267
|
+
path?: never;
|
|
268
|
+
query?: never;
|
|
269
|
+
url: '/v1/policies';
|
|
270
|
+
};
|
|
271
|
+
export type CreatePolicyErrors = {
|
|
272
|
+
/**
|
|
273
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
274
|
+
*/
|
|
275
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
276
|
+
/**
|
|
277
|
+
* Insufficient permission
|
|
278
|
+
*/
|
|
279
|
+
403: FlashStartErrorBody;
|
|
280
|
+
/**
|
|
281
|
+
* Resource not found
|
|
282
|
+
*/
|
|
283
|
+
404: FlashStartErrorBody;
|
|
284
|
+
/**
|
|
285
|
+
* Request validation failed
|
|
286
|
+
*/
|
|
287
|
+
422: FlashStartErrorBody;
|
|
288
|
+
/**
|
|
289
|
+
* Internal server error
|
|
290
|
+
*/
|
|
291
|
+
500: FlashStartErrorBody;
|
|
292
|
+
};
|
|
293
|
+
export type CreatePolicyError = CreatePolicyErrors[keyof CreatePolicyErrors];
|
|
294
|
+
export type CreatePolicyResponses = {
|
|
295
|
+
/**
|
|
296
|
+
* Policy
|
|
297
|
+
*/
|
|
298
|
+
201: Policy;
|
|
299
|
+
};
|
|
300
|
+
export type CreatePolicyResponse = CreatePolicyResponses[keyof CreatePolicyResponses];
|
|
301
|
+
export type DeletePolicyData = {
|
|
302
|
+
body?: never;
|
|
303
|
+
path: {
|
|
304
|
+
policyId: Uuid;
|
|
305
|
+
};
|
|
306
|
+
query?: never;
|
|
307
|
+
url: '/v1/policies/{policyId}';
|
|
308
|
+
};
|
|
309
|
+
export type DeletePolicyErrors = {
|
|
310
|
+
/**
|
|
311
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
312
|
+
*/
|
|
313
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
314
|
+
/**
|
|
315
|
+
* Insufficient permission
|
|
316
|
+
*/
|
|
317
|
+
403: FlashStartErrorBody;
|
|
318
|
+
/**
|
|
319
|
+
* Resource not found
|
|
320
|
+
*/
|
|
321
|
+
404: FlashStartErrorBody;
|
|
322
|
+
/**
|
|
323
|
+
* Internal server error
|
|
324
|
+
*/
|
|
325
|
+
500: FlashStartErrorBody;
|
|
326
|
+
};
|
|
327
|
+
export type DeletePolicyError = DeletePolicyErrors[keyof DeletePolicyErrors];
|
|
328
|
+
export type DeletePolicyResponses = {
|
|
329
|
+
/**
|
|
330
|
+
* Policy
|
|
331
|
+
*/
|
|
332
|
+
200: Policy;
|
|
333
|
+
};
|
|
334
|
+
export type DeletePolicyResponse = DeletePolicyResponses[keyof DeletePolicyResponses];
|
|
335
|
+
export type GetPolicyData = {
|
|
336
|
+
body?: never;
|
|
337
|
+
path: {
|
|
338
|
+
policyId: Uuid;
|
|
339
|
+
};
|
|
340
|
+
query?: never;
|
|
341
|
+
url: '/v1/policies/{policyId}';
|
|
342
|
+
};
|
|
343
|
+
export type GetPolicyErrors = {
|
|
344
|
+
/**
|
|
345
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
346
|
+
*/
|
|
347
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
348
|
+
/**
|
|
349
|
+
* Insufficient permission
|
|
350
|
+
*/
|
|
351
|
+
403: FlashStartErrorBody;
|
|
352
|
+
/**
|
|
353
|
+
* Resource not found
|
|
354
|
+
*/
|
|
355
|
+
404: FlashStartErrorBody;
|
|
356
|
+
/**
|
|
357
|
+
* Internal server error
|
|
358
|
+
*/
|
|
359
|
+
500: FlashStartErrorBody;
|
|
360
|
+
};
|
|
361
|
+
export type GetPolicyError = GetPolicyErrors[keyof GetPolicyErrors];
|
|
362
|
+
export type GetPolicyResponses = {
|
|
363
|
+
/**
|
|
364
|
+
* Policy
|
|
365
|
+
*/
|
|
366
|
+
200: Policy;
|
|
367
|
+
};
|
|
368
|
+
export type GetPolicyResponse = GetPolicyResponses[keyof GetPolicyResponses];
|
|
369
|
+
export type UpdatePolicyData = {
|
|
370
|
+
body: PolicyUpdate2;
|
|
371
|
+
path: {
|
|
372
|
+
policyId: Uuid;
|
|
373
|
+
};
|
|
374
|
+
query?: never;
|
|
375
|
+
url: '/v1/policies/{policyId}';
|
|
376
|
+
};
|
|
377
|
+
export type UpdatePolicyErrors = {
|
|
378
|
+
/**
|
|
379
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
380
|
+
*/
|
|
381
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
382
|
+
/**
|
|
383
|
+
* Insufficient permission
|
|
384
|
+
*/
|
|
385
|
+
403: FlashStartErrorBody;
|
|
386
|
+
/**
|
|
387
|
+
* Resource not found
|
|
388
|
+
*/
|
|
389
|
+
404: FlashStartErrorBody;
|
|
390
|
+
/**
|
|
391
|
+
* Request validation failed
|
|
392
|
+
*/
|
|
393
|
+
422: FlashStartErrorBody;
|
|
394
|
+
/**
|
|
395
|
+
* Internal server error
|
|
396
|
+
*/
|
|
397
|
+
500: FlashStartErrorBody;
|
|
398
|
+
};
|
|
399
|
+
export type UpdatePolicyError = UpdatePolicyErrors[keyof UpdatePolicyErrors];
|
|
400
|
+
export type UpdatePolicyResponses = {
|
|
401
|
+
/**
|
|
402
|
+
* Policy
|
|
403
|
+
*/
|
|
404
|
+
200: Policy;
|
|
405
|
+
};
|
|
406
|
+
export type UpdatePolicyResponse = UpdatePolicyResponses[keyof UpdatePolicyResponses];
|
|
407
|
+
export type GetPolicySettingsData = {
|
|
408
|
+
body?: never;
|
|
409
|
+
path: {
|
|
410
|
+
policyId: Uuid;
|
|
411
|
+
};
|
|
412
|
+
query?: never;
|
|
413
|
+
url: '/v1/policies/{policyId}/settings';
|
|
414
|
+
};
|
|
415
|
+
export type GetPolicySettingsErrors = {
|
|
416
|
+
/**
|
|
417
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
418
|
+
*/
|
|
419
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
420
|
+
/**
|
|
421
|
+
* Insufficient permission
|
|
422
|
+
*/
|
|
423
|
+
403: FlashStartErrorBody;
|
|
424
|
+
/**
|
|
425
|
+
* Resource not found
|
|
426
|
+
*/
|
|
427
|
+
404: FlashStartErrorBody;
|
|
428
|
+
/**
|
|
429
|
+
* Internal server error
|
|
430
|
+
*/
|
|
431
|
+
500: FlashStartErrorBody;
|
|
432
|
+
};
|
|
433
|
+
export type GetPolicySettingsError = GetPolicySettingsErrors[keyof GetPolicySettingsErrors];
|
|
434
|
+
export type GetPolicySettingsResponses = {
|
|
435
|
+
/**
|
|
436
|
+
* Policy settings
|
|
437
|
+
*/
|
|
438
|
+
200: PolicySettings;
|
|
439
|
+
};
|
|
440
|
+
export type GetPolicySettingsResponse = GetPolicySettingsResponses[keyof GetPolicySettingsResponses];
|
|
441
|
+
export type UpdatePolicySettingsData = {
|
|
442
|
+
body: PolicySettingsUpdate2;
|
|
443
|
+
path: {
|
|
444
|
+
policyId: Uuid;
|
|
445
|
+
};
|
|
446
|
+
query?: never;
|
|
447
|
+
url: '/v1/policies/{policyId}/settings';
|
|
448
|
+
};
|
|
449
|
+
export type UpdatePolicySettingsErrors = {
|
|
450
|
+
/**
|
|
451
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
452
|
+
*/
|
|
453
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
454
|
+
/**
|
|
455
|
+
* Insufficient permission
|
|
456
|
+
*/
|
|
457
|
+
403: FlashStartErrorBody;
|
|
458
|
+
/**
|
|
459
|
+
* Resource not found
|
|
460
|
+
*/
|
|
461
|
+
404: FlashStartErrorBody;
|
|
462
|
+
/**
|
|
463
|
+
* Request validation failed
|
|
464
|
+
*/
|
|
465
|
+
422: FlashStartErrorBody;
|
|
466
|
+
/**
|
|
467
|
+
* Internal server error
|
|
468
|
+
*/
|
|
469
|
+
500: FlashStartErrorBody;
|
|
470
|
+
};
|
|
471
|
+
export type UpdatePolicySettingsError = UpdatePolicySettingsErrors[keyof UpdatePolicySettingsErrors];
|
|
472
|
+
export type UpdatePolicySettingsResponses = {
|
|
473
|
+
/**
|
|
474
|
+
* Policy settings
|
|
475
|
+
*/
|
|
476
|
+
200: PolicySettings;
|
|
477
|
+
};
|
|
478
|
+
export type UpdatePolicySettingsResponse = UpdatePolicySettingsResponses[keyof UpdatePolicySettingsResponses];
|
|
479
|
+
export type ListPolicyExceptionGroupsData = {
|
|
480
|
+
body?: never;
|
|
481
|
+
path: {
|
|
482
|
+
policyId: Uuid;
|
|
483
|
+
};
|
|
484
|
+
query?: never;
|
|
485
|
+
url: '/v1/policies/{policyId}/exceptiongroups';
|
|
486
|
+
};
|
|
487
|
+
export type ListPolicyExceptionGroupsErrors = {
|
|
488
|
+
/**
|
|
489
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
490
|
+
*/
|
|
491
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
492
|
+
/**
|
|
493
|
+
* Insufficient permission
|
|
494
|
+
*/
|
|
495
|
+
403: FlashStartErrorBody;
|
|
496
|
+
/**
|
|
497
|
+
* Resource not found
|
|
498
|
+
*/
|
|
499
|
+
404: FlashStartErrorBody;
|
|
500
|
+
/**
|
|
501
|
+
* Internal server error
|
|
502
|
+
*/
|
|
503
|
+
500: FlashStartErrorBody;
|
|
504
|
+
};
|
|
505
|
+
export type ListPolicyExceptionGroupsError = ListPolicyExceptionGroupsErrors[keyof ListPolicyExceptionGroupsErrors];
|
|
506
|
+
export type ListPolicyExceptionGroupsResponses = {
|
|
507
|
+
/**
|
|
508
|
+
* Exception groups
|
|
509
|
+
*/
|
|
510
|
+
200: Array<ExceptionGroupWithDomains>;
|
|
511
|
+
};
|
|
512
|
+
export type ListPolicyExceptionGroupsResponse = ListPolicyExceptionGroupsResponses[keyof ListPolicyExceptionGroupsResponses];
|
|
513
|
+
export type AddPolicyExceptionGroupData = {
|
|
514
|
+
body: ExceptionGroupId2;
|
|
515
|
+
path: {
|
|
516
|
+
policyId: Uuid;
|
|
517
|
+
};
|
|
518
|
+
query?: never;
|
|
519
|
+
url: '/v1/policies/{policyId}/exceptiongroups';
|
|
520
|
+
};
|
|
521
|
+
export type AddPolicyExceptionGroupErrors = {
|
|
522
|
+
/**
|
|
523
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
524
|
+
*/
|
|
525
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
526
|
+
/**
|
|
527
|
+
* Insufficient permission
|
|
528
|
+
*/
|
|
529
|
+
403: FlashStartErrorBody;
|
|
530
|
+
/**
|
|
531
|
+
* Resource not found
|
|
532
|
+
*/
|
|
533
|
+
404: FlashStartErrorBody;
|
|
534
|
+
/**
|
|
535
|
+
* Request validation failed
|
|
536
|
+
*/
|
|
537
|
+
422: FlashStartErrorBody;
|
|
538
|
+
/**
|
|
539
|
+
* Internal server error
|
|
540
|
+
*/
|
|
541
|
+
500: FlashStartErrorBody;
|
|
542
|
+
};
|
|
543
|
+
export type AddPolicyExceptionGroupError = AddPolicyExceptionGroupErrors[keyof AddPolicyExceptionGroupErrors];
|
|
544
|
+
export type AddPolicyExceptionGroupResponses = {
|
|
545
|
+
/**
|
|
546
|
+
* Policy exception group association
|
|
547
|
+
*/
|
|
548
|
+
201: PolicyExceptionGroup;
|
|
549
|
+
};
|
|
550
|
+
export type AddPolicyExceptionGroupResponse = AddPolicyExceptionGroupResponses[keyof AddPolicyExceptionGroupResponses];
|
|
551
|
+
export type RemovePolicyExceptionGroupData = {
|
|
552
|
+
body?: never;
|
|
553
|
+
path: {
|
|
554
|
+
policyId: Uuid;
|
|
555
|
+
exceptionGroupId: Uuid;
|
|
556
|
+
};
|
|
557
|
+
query?: never;
|
|
558
|
+
url: '/v1/policies/{policyId}/exceptiongroups/{exceptionGroupId}';
|
|
559
|
+
};
|
|
560
|
+
export type RemovePolicyExceptionGroupErrors = {
|
|
561
|
+
/**
|
|
562
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
563
|
+
*/
|
|
564
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
565
|
+
/**
|
|
566
|
+
* Insufficient permission
|
|
567
|
+
*/
|
|
568
|
+
403: FlashStartErrorBody;
|
|
569
|
+
/**
|
|
570
|
+
* Resource not found
|
|
571
|
+
*/
|
|
572
|
+
404: FlashStartErrorBody;
|
|
573
|
+
/**
|
|
574
|
+
* Internal server error
|
|
575
|
+
*/
|
|
576
|
+
500: FlashStartErrorBody;
|
|
577
|
+
};
|
|
578
|
+
export type RemovePolicyExceptionGroupError = RemovePolicyExceptionGroupErrors[keyof RemovePolicyExceptionGroupErrors];
|
|
579
|
+
export type RemovePolicyExceptionGroupResponses = {
|
|
580
|
+
/**
|
|
581
|
+
* Policy exception group association
|
|
582
|
+
*/
|
|
583
|
+
200: PolicyExceptionGroup;
|
|
584
|
+
};
|
|
585
|
+
export type RemovePolicyExceptionGroupResponse = RemovePolicyExceptionGroupResponses[keyof RemovePolicyExceptionGroupResponses];
|
|
586
|
+
export type DisableDynamicDnsRedirectData = {
|
|
587
|
+
body?: never;
|
|
588
|
+
path: {
|
|
589
|
+
policyId: Uuid;
|
|
590
|
+
};
|
|
591
|
+
query?: never;
|
|
592
|
+
url: '/v1/policies/{policyId}/dyndns-redirect';
|
|
593
|
+
};
|
|
594
|
+
export type DisableDynamicDnsRedirectErrors = {
|
|
595
|
+
/**
|
|
596
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
597
|
+
*/
|
|
598
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
599
|
+
/**
|
|
600
|
+
* Insufficient permission
|
|
601
|
+
*/
|
|
602
|
+
403: FlashStartErrorBody;
|
|
603
|
+
/**
|
|
604
|
+
* Resource not found
|
|
605
|
+
*/
|
|
606
|
+
404: FlashStartErrorBody;
|
|
607
|
+
/**
|
|
608
|
+
* Internal server error
|
|
609
|
+
*/
|
|
610
|
+
500: FlashStartErrorBody;
|
|
611
|
+
};
|
|
612
|
+
export type DisableDynamicDnsRedirectError = DisableDynamicDnsRedirectErrors[keyof DisableDynamicDnsRedirectErrors];
|
|
613
|
+
export type DisableDynamicDnsRedirectResponses = {
|
|
614
|
+
/**
|
|
615
|
+
* Dynamic DNS redirect disabled
|
|
616
|
+
*/
|
|
617
|
+
204: void;
|
|
618
|
+
};
|
|
619
|
+
export type DisableDynamicDnsRedirectResponse = DisableDynamicDnsRedirectResponses[keyof DisableDynamicDnsRedirectResponses];
|
|
620
|
+
export type GetDynamicDnsRedirectData = {
|
|
621
|
+
body?: never;
|
|
622
|
+
path: {
|
|
623
|
+
policyId: Uuid;
|
|
624
|
+
};
|
|
625
|
+
query?: never;
|
|
626
|
+
url: '/v1/policies/{policyId}/dyndns-redirect';
|
|
627
|
+
};
|
|
628
|
+
export type GetDynamicDnsRedirectErrors = {
|
|
629
|
+
/**
|
|
630
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
631
|
+
*/
|
|
632
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
633
|
+
/**
|
|
634
|
+
* Insufficient permission
|
|
635
|
+
*/
|
|
636
|
+
403: FlashStartErrorBody;
|
|
637
|
+
/**
|
|
638
|
+
* Resource not found
|
|
639
|
+
*/
|
|
640
|
+
404: FlashStartErrorBody;
|
|
641
|
+
/**
|
|
642
|
+
* Internal server error
|
|
643
|
+
*/
|
|
644
|
+
500: FlashStartErrorBody;
|
|
645
|
+
};
|
|
646
|
+
export type GetDynamicDnsRedirectError = GetDynamicDnsRedirectErrors[keyof GetDynamicDnsRedirectErrors];
|
|
647
|
+
export type GetDynamicDnsRedirectResponses = {
|
|
648
|
+
/**
|
|
649
|
+
* Dynamic DNS redirect status
|
|
650
|
+
*/
|
|
651
|
+
200: DynamicDnsRedirect;
|
|
652
|
+
};
|
|
653
|
+
export type GetDynamicDnsRedirectResponse = GetDynamicDnsRedirectResponses[keyof GetDynamicDnsRedirectResponses];
|
|
654
|
+
export type EnableDynamicDnsRedirectData = {
|
|
655
|
+
body?: never;
|
|
656
|
+
path: {
|
|
657
|
+
policyId: Uuid;
|
|
658
|
+
};
|
|
659
|
+
query?: never;
|
|
660
|
+
url: '/v1/policies/{policyId}/dyndns-redirect';
|
|
661
|
+
};
|
|
662
|
+
export type EnableDynamicDnsRedirectErrors = {
|
|
663
|
+
/**
|
|
664
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
665
|
+
*/
|
|
666
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
667
|
+
/**
|
|
668
|
+
* Insufficient permission
|
|
669
|
+
*/
|
|
670
|
+
403: FlashStartErrorBody;
|
|
671
|
+
/**
|
|
672
|
+
* Resource not found
|
|
673
|
+
*/
|
|
674
|
+
404: FlashStartErrorBody;
|
|
675
|
+
/**
|
|
676
|
+
* Internal server error
|
|
677
|
+
*/
|
|
678
|
+
500: FlashStartErrorBody;
|
|
679
|
+
};
|
|
680
|
+
export type EnableDynamicDnsRedirectError = EnableDynamicDnsRedirectErrors[keyof EnableDynamicDnsRedirectErrors];
|
|
681
|
+
export type EnableDynamicDnsRedirectResponses = {
|
|
682
|
+
/**
|
|
683
|
+
* Dynamic DNS redirect enabled
|
|
684
|
+
*/
|
|
685
|
+
204: void;
|
|
686
|
+
};
|
|
687
|
+
export type EnableDynamicDnsRedirectResponse = EnableDynamicDnsRedirectResponses[keyof EnableDynamicDnsRedirectResponses];
|
|
688
|
+
export type AllowCategoriesData = {
|
|
689
|
+
body: CategoryIds;
|
|
690
|
+
path: {
|
|
691
|
+
policyId: Uuid;
|
|
692
|
+
};
|
|
693
|
+
query?: never;
|
|
694
|
+
url: '/v1/policies/{policyId}/categories/blocked';
|
|
695
|
+
};
|
|
696
|
+
export type AllowCategoriesErrors = {
|
|
697
|
+
/**
|
|
698
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
699
|
+
*/
|
|
700
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
701
|
+
/**
|
|
702
|
+
* Insufficient permission
|
|
703
|
+
*/
|
|
704
|
+
403: FlashStartErrorBody;
|
|
705
|
+
/**
|
|
706
|
+
* Resource not found
|
|
707
|
+
*/
|
|
708
|
+
404: FlashStartErrorBody;
|
|
709
|
+
/**
|
|
710
|
+
* Request validation failed
|
|
711
|
+
*/
|
|
712
|
+
422: FlashStartErrorBody;
|
|
713
|
+
/**
|
|
714
|
+
* Internal server error
|
|
715
|
+
*/
|
|
716
|
+
500: FlashStartErrorBody;
|
|
717
|
+
};
|
|
718
|
+
export type AllowCategoriesError = AllowCategoriesErrors[keyof AllowCategoriesErrors];
|
|
719
|
+
export type AllowCategoriesResponses = {
|
|
720
|
+
/**
|
|
721
|
+
* Per-category results
|
|
722
|
+
*/
|
|
723
|
+
207: MultiStatusCategoryBlockedOnPolicy;
|
|
724
|
+
};
|
|
725
|
+
export type AllowCategoriesResponse = AllowCategoriesResponses[keyof AllowCategoriesResponses];
|
|
726
|
+
export type ListBlockedCategoriesData = {
|
|
727
|
+
body?: never;
|
|
728
|
+
path: {
|
|
729
|
+
policyId: Uuid;
|
|
730
|
+
};
|
|
731
|
+
query?: {
|
|
732
|
+
lang?: string;
|
|
733
|
+
};
|
|
734
|
+
url: '/v1/policies/{policyId}/categories/blocked';
|
|
735
|
+
};
|
|
736
|
+
export type ListBlockedCategoriesErrors = {
|
|
737
|
+
/**
|
|
738
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
739
|
+
*/
|
|
740
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
741
|
+
/**
|
|
742
|
+
* Insufficient permission
|
|
743
|
+
*/
|
|
744
|
+
403: FlashStartErrorBody;
|
|
745
|
+
/**
|
|
746
|
+
* Resource not found
|
|
747
|
+
*/
|
|
748
|
+
404: FlashStartErrorBody;
|
|
749
|
+
/**
|
|
750
|
+
* Internal server error
|
|
751
|
+
*/
|
|
752
|
+
500: FlashStartErrorBody;
|
|
753
|
+
};
|
|
754
|
+
export type ListBlockedCategoriesError = ListBlockedCategoriesErrors[keyof ListBlockedCategoriesErrors];
|
|
755
|
+
export type ListBlockedCategoriesResponses = {
|
|
756
|
+
/**
|
|
757
|
+
* Blocked categories
|
|
758
|
+
*/
|
|
759
|
+
200: Array<BlockedCategoryWithSchedule>;
|
|
760
|
+
};
|
|
761
|
+
export type ListBlockedCategoriesResponse = ListBlockedCategoriesResponses[keyof ListBlockedCategoriesResponses];
|
|
762
|
+
export type BlockCategoriesData = {
|
|
763
|
+
body: CategoryIds;
|
|
764
|
+
path: {
|
|
765
|
+
policyId: Uuid;
|
|
766
|
+
};
|
|
767
|
+
query?: never;
|
|
768
|
+
url: '/v1/policies/{policyId}/categories/blocked';
|
|
769
|
+
};
|
|
770
|
+
export type BlockCategoriesErrors = {
|
|
771
|
+
/**
|
|
772
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
773
|
+
*/
|
|
774
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
775
|
+
/**
|
|
776
|
+
* Insufficient permission
|
|
777
|
+
*/
|
|
778
|
+
403: FlashStartErrorBody;
|
|
779
|
+
/**
|
|
780
|
+
* Resource not found
|
|
781
|
+
*/
|
|
782
|
+
404: FlashStartErrorBody;
|
|
783
|
+
/**
|
|
784
|
+
* Request validation failed
|
|
785
|
+
*/
|
|
786
|
+
422: FlashStartErrorBody;
|
|
787
|
+
/**
|
|
788
|
+
* Internal server error
|
|
789
|
+
*/
|
|
790
|
+
500: FlashStartErrorBody;
|
|
791
|
+
};
|
|
792
|
+
export type BlockCategoriesError = BlockCategoriesErrors[keyof BlockCategoriesErrors];
|
|
793
|
+
export type BlockCategoriesResponses = {
|
|
794
|
+
/**
|
|
795
|
+
* Per-category results
|
|
796
|
+
*/
|
|
797
|
+
207: MultiStatusCategoryBlockedOnPolicy;
|
|
798
|
+
};
|
|
799
|
+
export type BlockCategoriesResponse = BlockCategoriesResponses[keyof BlockCategoriesResponses];
|
|
800
|
+
export type AllowAppBlockerCategoriesData = {
|
|
801
|
+
body: CategoryIds;
|
|
802
|
+
path: {
|
|
803
|
+
policyId: Uuid;
|
|
804
|
+
};
|
|
805
|
+
query?: never;
|
|
806
|
+
url: '/v1/policies/{policyId}/appblocker/blocked';
|
|
807
|
+
};
|
|
808
|
+
export type AllowAppBlockerCategoriesErrors = {
|
|
809
|
+
/**
|
|
810
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
811
|
+
*/
|
|
812
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
813
|
+
/**
|
|
814
|
+
* Insufficient permission
|
|
815
|
+
*/
|
|
816
|
+
403: FlashStartErrorBody;
|
|
817
|
+
/**
|
|
818
|
+
* Resource not found
|
|
819
|
+
*/
|
|
820
|
+
404: FlashStartErrorBody;
|
|
821
|
+
/**
|
|
822
|
+
* Request validation failed
|
|
823
|
+
*/
|
|
824
|
+
422: FlashStartErrorBody;
|
|
825
|
+
/**
|
|
826
|
+
* Internal server error
|
|
827
|
+
*/
|
|
828
|
+
500: FlashStartErrorBody;
|
|
829
|
+
};
|
|
830
|
+
export type AllowAppBlockerCategoriesError = AllowAppBlockerCategoriesErrors[keyof AllowAppBlockerCategoriesErrors];
|
|
831
|
+
export type AllowAppBlockerCategoriesResponses = {
|
|
832
|
+
/**
|
|
833
|
+
* Per-category results
|
|
834
|
+
*/
|
|
835
|
+
207: MultiStatusCategoryBlockedOnPolicy;
|
|
836
|
+
};
|
|
837
|
+
export type AllowAppBlockerCategoriesResponse = AllowAppBlockerCategoriesResponses[keyof AllowAppBlockerCategoriesResponses];
|
|
838
|
+
export type ListBlockedAppBlockerCategoriesData = {
|
|
839
|
+
body?: never;
|
|
840
|
+
path: {
|
|
841
|
+
policyId: Uuid;
|
|
842
|
+
};
|
|
843
|
+
query?: {
|
|
844
|
+
lang?: string;
|
|
845
|
+
};
|
|
846
|
+
url: '/v1/policies/{policyId}/appblocker/blocked';
|
|
847
|
+
};
|
|
848
|
+
export type ListBlockedAppBlockerCategoriesErrors = {
|
|
849
|
+
/**
|
|
850
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
851
|
+
*/
|
|
852
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
853
|
+
/**
|
|
854
|
+
* Insufficient permission
|
|
855
|
+
*/
|
|
856
|
+
403: FlashStartErrorBody;
|
|
857
|
+
/**
|
|
858
|
+
* Resource not found
|
|
859
|
+
*/
|
|
860
|
+
404: FlashStartErrorBody;
|
|
861
|
+
/**
|
|
862
|
+
* Internal server error
|
|
863
|
+
*/
|
|
864
|
+
500: FlashStartErrorBody;
|
|
865
|
+
};
|
|
866
|
+
export type ListBlockedAppBlockerCategoriesError = ListBlockedAppBlockerCategoriesErrors[keyof ListBlockedAppBlockerCategoriesErrors];
|
|
867
|
+
export type ListBlockedAppBlockerCategoriesResponses = {
|
|
868
|
+
/**
|
|
869
|
+
* Blocked categories
|
|
870
|
+
*/
|
|
871
|
+
200: Array<BlockedCategoryWithSchedule>;
|
|
872
|
+
};
|
|
873
|
+
export type ListBlockedAppBlockerCategoriesResponse = ListBlockedAppBlockerCategoriesResponses[keyof ListBlockedAppBlockerCategoriesResponses];
|
|
874
|
+
export type BlockAppBlockerCategoriesData = {
|
|
875
|
+
body: CategoryIds;
|
|
876
|
+
path: {
|
|
877
|
+
policyId: Uuid;
|
|
878
|
+
};
|
|
879
|
+
query?: never;
|
|
880
|
+
url: '/v1/policies/{policyId}/appblocker/blocked';
|
|
881
|
+
};
|
|
882
|
+
export type BlockAppBlockerCategoriesErrors = {
|
|
883
|
+
/**
|
|
884
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
885
|
+
*/
|
|
886
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
887
|
+
/**
|
|
888
|
+
* Insufficient permission
|
|
889
|
+
*/
|
|
890
|
+
403: FlashStartErrorBody;
|
|
891
|
+
/**
|
|
892
|
+
* Resource not found
|
|
893
|
+
*/
|
|
894
|
+
404: FlashStartErrorBody;
|
|
895
|
+
/**
|
|
896
|
+
* Request validation failed
|
|
897
|
+
*/
|
|
898
|
+
422: FlashStartErrorBody;
|
|
899
|
+
/**
|
|
900
|
+
* Internal server error
|
|
901
|
+
*/
|
|
902
|
+
500: FlashStartErrorBody;
|
|
903
|
+
};
|
|
904
|
+
export type BlockAppBlockerCategoriesError = BlockAppBlockerCategoriesErrors[keyof BlockAppBlockerCategoriesErrors];
|
|
905
|
+
export type BlockAppBlockerCategoriesResponses = {
|
|
906
|
+
/**
|
|
907
|
+
* Per-category results
|
|
908
|
+
*/
|
|
909
|
+
207: MultiStatusCategoryBlockedOnPolicy;
|
|
910
|
+
};
|
|
911
|
+
export type BlockAppBlockerCategoriesResponse = BlockAppBlockerCategoriesResponses[keyof BlockAppBlockerCategoriesResponses];
|
|
912
|
+
export type AllowMalwareCategoriesData = {
|
|
913
|
+
body: CategoryIds;
|
|
914
|
+
path: {
|
|
915
|
+
policyId: Uuid;
|
|
916
|
+
};
|
|
917
|
+
query?: never;
|
|
918
|
+
url: '/v1/policies/{policyId}/malwares/blocked';
|
|
919
|
+
};
|
|
920
|
+
export type AllowMalwareCategoriesErrors = {
|
|
921
|
+
/**
|
|
922
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
923
|
+
*/
|
|
924
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
925
|
+
/**
|
|
926
|
+
* Insufficient permission
|
|
927
|
+
*/
|
|
928
|
+
403: FlashStartErrorBody;
|
|
929
|
+
/**
|
|
930
|
+
* Resource not found
|
|
931
|
+
*/
|
|
932
|
+
404: FlashStartErrorBody;
|
|
933
|
+
/**
|
|
934
|
+
* Request validation failed
|
|
935
|
+
*/
|
|
936
|
+
422: FlashStartErrorBody;
|
|
937
|
+
/**
|
|
938
|
+
* Internal server error
|
|
939
|
+
*/
|
|
940
|
+
500: FlashStartErrorBody;
|
|
941
|
+
};
|
|
942
|
+
export type AllowMalwareCategoriesError = AllowMalwareCategoriesErrors[keyof AllowMalwareCategoriesErrors];
|
|
943
|
+
export type AllowMalwareCategoriesResponses = {
|
|
944
|
+
/**
|
|
945
|
+
* Per-category results
|
|
946
|
+
*/
|
|
947
|
+
207: MultiStatusCategoryBlockedOnPolicy;
|
|
948
|
+
};
|
|
949
|
+
export type AllowMalwareCategoriesResponse = AllowMalwareCategoriesResponses[keyof AllowMalwareCategoriesResponses];
|
|
950
|
+
export type ListBlockedMalwareCategoriesData = {
|
|
951
|
+
body?: never;
|
|
952
|
+
path: {
|
|
953
|
+
policyId: Uuid;
|
|
954
|
+
};
|
|
955
|
+
query?: {
|
|
956
|
+
lang?: string;
|
|
957
|
+
};
|
|
958
|
+
url: '/v1/policies/{policyId}/malwares/blocked';
|
|
959
|
+
};
|
|
960
|
+
export type ListBlockedMalwareCategoriesErrors = {
|
|
961
|
+
/**
|
|
962
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
963
|
+
*/
|
|
964
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
965
|
+
/**
|
|
966
|
+
* Insufficient permission
|
|
967
|
+
*/
|
|
968
|
+
403: FlashStartErrorBody;
|
|
969
|
+
/**
|
|
970
|
+
* Resource not found
|
|
971
|
+
*/
|
|
972
|
+
404: FlashStartErrorBody;
|
|
973
|
+
/**
|
|
974
|
+
* Internal server error
|
|
975
|
+
*/
|
|
976
|
+
500: FlashStartErrorBody;
|
|
977
|
+
};
|
|
978
|
+
export type ListBlockedMalwareCategoriesError = ListBlockedMalwareCategoriesErrors[keyof ListBlockedMalwareCategoriesErrors];
|
|
979
|
+
export type ListBlockedMalwareCategoriesResponses = {
|
|
980
|
+
/**
|
|
981
|
+
* Blocked categories
|
|
982
|
+
*/
|
|
983
|
+
200: Array<BlockedCategoryWithSchedule>;
|
|
984
|
+
};
|
|
985
|
+
export type ListBlockedMalwareCategoriesResponse = ListBlockedMalwareCategoriesResponses[keyof ListBlockedMalwareCategoriesResponses];
|
|
986
|
+
export type BlockMalwareCategoriesData = {
|
|
987
|
+
body: CategoryIds;
|
|
988
|
+
path: {
|
|
989
|
+
policyId: Uuid;
|
|
990
|
+
};
|
|
991
|
+
query?: never;
|
|
992
|
+
url: '/v1/policies/{policyId}/malwares/blocked';
|
|
993
|
+
};
|
|
994
|
+
export type BlockMalwareCategoriesErrors = {
|
|
995
|
+
/**
|
|
996
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
997
|
+
*/
|
|
998
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
999
|
+
/**
|
|
1000
|
+
* Insufficient permission
|
|
1001
|
+
*/
|
|
1002
|
+
403: FlashStartErrorBody;
|
|
1003
|
+
/**
|
|
1004
|
+
* Resource not found
|
|
1005
|
+
*/
|
|
1006
|
+
404: FlashStartErrorBody;
|
|
1007
|
+
/**
|
|
1008
|
+
* Request validation failed
|
|
1009
|
+
*/
|
|
1010
|
+
422: FlashStartErrorBody;
|
|
1011
|
+
/**
|
|
1012
|
+
* Internal server error
|
|
1013
|
+
*/
|
|
1014
|
+
500: FlashStartErrorBody;
|
|
1015
|
+
};
|
|
1016
|
+
export type BlockMalwareCategoriesError = BlockMalwareCategoriesErrors[keyof BlockMalwareCategoriesErrors];
|
|
1017
|
+
export type BlockMalwareCategoriesResponses = {
|
|
1018
|
+
/**
|
|
1019
|
+
* Per-category results
|
|
1020
|
+
*/
|
|
1021
|
+
207: MultiStatusCategoryBlockedOnPolicy;
|
|
1022
|
+
};
|
|
1023
|
+
export type BlockMalwareCategoriesResponse = BlockMalwareCategoriesResponses[keyof BlockMalwareCategoriesResponses];
|
|
1024
|
+
export type ScheduleCategoryBlockData = {
|
|
1025
|
+
body: CategorySchedule;
|
|
1026
|
+
path: {
|
|
1027
|
+
policyId: Uuid;
|
|
1028
|
+
};
|
|
1029
|
+
query?: never;
|
|
1030
|
+
url: '/v1/policies/{policyId}/categories/blocked/schedule';
|
|
1031
|
+
};
|
|
1032
|
+
export type ScheduleCategoryBlockErrors = {
|
|
1033
|
+
/**
|
|
1034
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
1035
|
+
*/
|
|
1036
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1037
|
+
/**
|
|
1038
|
+
* Insufficient permission
|
|
1039
|
+
*/
|
|
1040
|
+
403: FlashStartErrorBody;
|
|
1041
|
+
/**
|
|
1042
|
+
* Resource not found
|
|
1043
|
+
*/
|
|
1044
|
+
404: FlashStartErrorBody;
|
|
1045
|
+
/**
|
|
1046
|
+
* Request validation failed
|
|
1047
|
+
*/
|
|
1048
|
+
422: FlashStartErrorBody;
|
|
1049
|
+
/**
|
|
1050
|
+
* Internal server error
|
|
1051
|
+
*/
|
|
1052
|
+
500: FlashStartErrorBody;
|
|
1053
|
+
};
|
|
1054
|
+
export type ScheduleCategoryBlockError = ScheduleCategoryBlockErrors[keyof ScheduleCategoryBlockErrors];
|
|
1055
|
+
export type ScheduleCategoryBlockResponses = {
|
|
1056
|
+
/**
|
|
1057
|
+
* Created category schedules
|
|
1058
|
+
*/
|
|
1059
|
+
201: Array<BlockedCategoryWithTimeBlock>;
|
|
1060
|
+
};
|
|
1061
|
+
export type ScheduleCategoryBlockResponse = ScheduleCategoryBlockResponses[keyof ScheduleCategoryBlockResponses];
|
|
1062
|
+
export type RemoveCategoryBlockScheduleData = {
|
|
1063
|
+
body?: never;
|
|
1064
|
+
path: {
|
|
1065
|
+
policyId: Uuid;
|
|
1066
|
+
schedulationId: Uuid;
|
|
1067
|
+
};
|
|
1068
|
+
query?: never;
|
|
1069
|
+
url: '/v1/policies/{policyId}/categories/blocked/schedule/{schedulationId}';
|
|
1070
|
+
};
|
|
1071
|
+
export type RemoveCategoryBlockScheduleErrors = {
|
|
1072
|
+
/**
|
|
1073
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
1074
|
+
*/
|
|
1075
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1076
|
+
/**
|
|
1077
|
+
* Insufficient permission
|
|
1078
|
+
*/
|
|
1079
|
+
403: FlashStartErrorBody;
|
|
1080
|
+
/**
|
|
1081
|
+
* Resource not found
|
|
1082
|
+
*/
|
|
1083
|
+
404: FlashStartErrorBody;
|
|
1084
|
+
/**
|
|
1085
|
+
* Internal server error
|
|
1086
|
+
*/
|
|
1087
|
+
500: FlashStartErrorBody;
|
|
1088
|
+
};
|
|
1089
|
+
export type RemoveCategoryBlockScheduleError = RemoveCategoryBlockScheduleErrors[keyof RemoveCategoryBlockScheduleErrors];
|
|
1090
|
+
export type RemoveCategoryBlockScheduleResponses = {
|
|
1091
|
+
/**
|
|
1092
|
+
* Removed category schedule
|
|
1093
|
+
*/
|
|
1094
|
+
200: BlockedCategoryWithTimeBlock;
|
|
1095
|
+
};
|
|
1096
|
+
export type RemoveCategoryBlockScheduleResponse = RemoveCategoryBlockScheduleResponses[keyof RemoveCategoryBlockScheduleResponses];
|
|
1097
|
+
export type ScheduleAppBlockerCategoryBlockData = {
|
|
1098
|
+
body: CategorySchedule;
|
|
1099
|
+
path: {
|
|
1100
|
+
policyId: Uuid;
|
|
1101
|
+
};
|
|
1102
|
+
query?: never;
|
|
1103
|
+
url: '/v1/policies/{policyId}/appblocker/blocked/schedule';
|
|
1104
|
+
};
|
|
1105
|
+
export type ScheduleAppBlockerCategoryBlockErrors = {
|
|
1106
|
+
/**
|
|
1107
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
1108
|
+
*/
|
|
1109
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1110
|
+
/**
|
|
1111
|
+
* Insufficient permission
|
|
1112
|
+
*/
|
|
1113
|
+
403: FlashStartErrorBody;
|
|
1114
|
+
/**
|
|
1115
|
+
* Resource not found
|
|
1116
|
+
*/
|
|
1117
|
+
404: FlashStartErrorBody;
|
|
1118
|
+
/**
|
|
1119
|
+
* Request validation failed
|
|
1120
|
+
*/
|
|
1121
|
+
422: FlashStartErrorBody;
|
|
1122
|
+
/**
|
|
1123
|
+
* Internal server error
|
|
1124
|
+
*/
|
|
1125
|
+
500: FlashStartErrorBody;
|
|
1126
|
+
};
|
|
1127
|
+
export type ScheduleAppBlockerCategoryBlockError = ScheduleAppBlockerCategoryBlockErrors[keyof ScheduleAppBlockerCategoryBlockErrors];
|
|
1128
|
+
export type ScheduleAppBlockerCategoryBlockResponses = {
|
|
1129
|
+
/**
|
|
1130
|
+
* Created category schedules
|
|
1131
|
+
*/
|
|
1132
|
+
201: Array<BlockedCategoryWithTimeBlock>;
|
|
1133
|
+
};
|
|
1134
|
+
export type ScheduleAppBlockerCategoryBlockResponse = ScheduleAppBlockerCategoryBlockResponses[keyof ScheduleAppBlockerCategoryBlockResponses];
|
|
1135
|
+
export type RemoveAppBlockerCategoryBlockScheduleData = {
|
|
1136
|
+
body?: never;
|
|
1137
|
+
path: {
|
|
1138
|
+
policyId: Uuid;
|
|
1139
|
+
schedulationId: Uuid;
|
|
1140
|
+
};
|
|
1141
|
+
query?: never;
|
|
1142
|
+
url: '/v1/policies/{policyId}/appblocker/blocked/schedule/{schedulationId}';
|
|
1143
|
+
};
|
|
1144
|
+
export type RemoveAppBlockerCategoryBlockScheduleErrors = {
|
|
1145
|
+
/**
|
|
1146
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
1147
|
+
*/
|
|
1148
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1149
|
+
/**
|
|
1150
|
+
* Insufficient permission
|
|
1151
|
+
*/
|
|
1152
|
+
403: FlashStartErrorBody;
|
|
1153
|
+
/**
|
|
1154
|
+
* Resource not found
|
|
1155
|
+
*/
|
|
1156
|
+
404: FlashStartErrorBody;
|
|
1157
|
+
/**
|
|
1158
|
+
* Internal server error
|
|
1159
|
+
*/
|
|
1160
|
+
500: FlashStartErrorBody;
|
|
1161
|
+
};
|
|
1162
|
+
export type RemoveAppBlockerCategoryBlockScheduleError = RemoveAppBlockerCategoryBlockScheduleErrors[keyof RemoveAppBlockerCategoryBlockScheduleErrors];
|
|
1163
|
+
export type RemoveAppBlockerCategoryBlockScheduleResponses = {
|
|
1164
|
+
/**
|
|
1165
|
+
* Removed category schedule
|
|
1166
|
+
*/
|
|
1167
|
+
200: BlockedCategoryWithTimeBlock;
|
|
1168
|
+
};
|
|
1169
|
+
export type RemoveAppBlockerCategoryBlockScheduleResponse = RemoveAppBlockerCategoryBlockScheduleResponses[keyof RemoveAppBlockerCategoryBlockScheduleResponses];
|
|
1170
|
+
export type ScheduleMalwareCategoryBlockData = {
|
|
1171
|
+
body: CategorySchedule;
|
|
1172
|
+
path: {
|
|
1173
|
+
policyId: Uuid;
|
|
1174
|
+
};
|
|
1175
|
+
query?: never;
|
|
1176
|
+
url: '/v1/policies/{policyId}/malwares/blocked/schedule';
|
|
1177
|
+
};
|
|
1178
|
+
export type ScheduleMalwareCategoryBlockErrors = {
|
|
1179
|
+
/**
|
|
1180
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
1181
|
+
*/
|
|
1182
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1183
|
+
/**
|
|
1184
|
+
* Insufficient permission
|
|
1185
|
+
*/
|
|
1186
|
+
403: FlashStartErrorBody;
|
|
1187
|
+
/**
|
|
1188
|
+
* Resource not found
|
|
1189
|
+
*/
|
|
1190
|
+
404: FlashStartErrorBody;
|
|
1191
|
+
/**
|
|
1192
|
+
* Request validation failed
|
|
1193
|
+
*/
|
|
1194
|
+
422: FlashStartErrorBody;
|
|
1195
|
+
/**
|
|
1196
|
+
* Internal server error
|
|
1197
|
+
*/
|
|
1198
|
+
500: FlashStartErrorBody;
|
|
1199
|
+
};
|
|
1200
|
+
export type ScheduleMalwareCategoryBlockError = ScheduleMalwareCategoryBlockErrors[keyof ScheduleMalwareCategoryBlockErrors];
|
|
1201
|
+
export type ScheduleMalwareCategoryBlockResponses = {
|
|
1202
|
+
/**
|
|
1203
|
+
* Created category schedules
|
|
1204
|
+
*/
|
|
1205
|
+
201: Array<BlockedCategoryWithTimeBlock>;
|
|
1206
|
+
};
|
|
1207
|
+
export type ScheduleMalwareCategoryBlockResponse = ScheduleMalwareCategoryBlockResponses[keyof ScheduleMalwareCategoryBlockResponses];
|
|
1208
|
+
export type RemoveMalwareCategoryBlockScheduleData = {
|
|
1209
|
+
body?: never;
|
|
1210
|
+
path: {
|
|
1211
|
+
policyId: Uuid;
|
|
1212
|
+
schedulationId: Uuid;
|
|
1213
|
+
};
|
|
1214
|
+
query?: never;
|
|
1215
|
+
url: '/v1/policies/{policyId}/malwares/blocked/schedule/{schedulationId}';
|
|
1216
|
+
};
|
|
1217
|
+
export type RemoveMalwareCategoryBlockScheduleErrors = {
|
|
1218
|
+
/**
|
|
1219
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
1220
|
+
*/
|
|
1221
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1222
|
+
/**
|
|
1223
|
+
* Insufficient permission
|
|
1224
|
+
*/
|
|
1225
|
+
403: FlashStartErrorBody;
|
|
1226
|
+
/**
|
|
1227
|
+
* Resource not found
|
|
1228
|
+
*/
|
|
1229
|
+
404: FlashStartErrorBody;
|
|
1230
|
+
/**
|
|
1231
|
+
* Internal server error
|
|
1232
|
+
*/
|
|
1233
|
+
500: FlashStartErrorBody;
|
|
1234
|
+
};
|
|
1235
|
+
export type RemoveMalwareCategoryBlockScheduleError = RemoveMalwareCategoryBlockScheduleErrors[keyof RemoveMalwareCategoryBlockScheduleErrors];
|
|
1236
|
+
export type RemoveMalwareCategoryBlockScheduleResponses = {
|
|
1237
|
+
/**
|
|
1238
|
+
* Removed category schedule
|
|
1239
|
+
*/
|
|
1240
|
+
200: BlockedCategoryWithTimeBlock;
|
|
1241
|
+
};
|
|
1242
|
+
export type RemoveMalwareCategoryBlockScheduleResponse = RemoveMalwareCategoryBlockScheduleResponses[keyof RemoveMalwareCategoryBlockScheduleResponses];
|
|
1243
|
+
export type AllowCountriesData = {
|
|
1244
|
+
body: CountryIds;
|
|
1245
|
+
path: {
|
|
1246
|
+
policyId: Uuid;
|
|
1247
|
+
};
|
|
1248
|
+
query?: never;
|
|
1249
|
+
url: '/v1/policies/{policyId}/countries/blocked';
|
|
1250
|
+
};
|
|
1251
|
+
export type AllowCountriesErrors = {
|
|
1252
|
+
/**
|
|
1253
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
1254
|
+
*/
|
|
1255
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1256
|
+
/**
|
|
1257
|
+
* Insufficient permission
|
|
1258
|
+
*/
|
|
1259
|
+
403: FlashStartErrorBody;
|
|
1260
|
+
/**
|
|
1261
|
+
* Resource not found
|
|
1262
|
+
*/
|
|
1263
|
+
404: FlashStartErrorBody;
|
|
1264
|
+
/**
|
|
1265
|
+
* Request validation failed
|
|
1266
|
+
*/
|
|
1267
|
+
422: FlashStartErrorBody;
|
|
1268
|
+
/**
|
|
1269
|
+
* Internal server error
|
|
1270
|
+
*/
|
|
1271
|
+
500: FlashStartErrorBody;
|
|
1272
|
+
};
|
|
1273
|
+
export type AllowCountriesError = AllowCountriesErrors[keyof AllowCountriesErrors];
|
|
1274
|
+
export type AllowCountriesResponses = {
|
|
1275
|
+
/**
|
|
1276
|
+
* Per-country results
|
|
1277
|
+
*/
|
|
1278
|
+
207: MultiStatusBlockedCountry;
|
|
1279
|
+
};
|
|
1280
|
+
export type AllowCountriesResponse = AllowCountriesResponses[keyof AllowCountriesResponses];
|
|
1281
|
+
export type ListBlockedCountriesData = {
|
|
1282
|
+
body?: never;
|
|
1283
|
+
path: {
|
|
1284
|
+
policyId: Uuid;
|
|
1285
|
+
};
|
|
1286
|
+
query?: never;
|
|
1287
|
+
url: '/v1/policies/{policyId}/countries/blocked';
|
|
1288
|
+
};
|
|
1289
|
+
export type ListBlockedCountriesErrors = {
|
|
1290
|
+
/**
|
|
1291
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
1292
|
+
*/
|
|
1293
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1294
|
+
/**
|
|
1295
|
+
* Insufficient permission
|
|
1296
|
+
*/
|
|
1297
|
+
403: FlashStartErrorBody;
|
|
1298
|
+
/**
|
|
1299
|
+
* Resource not found
|
|
1300
|
+
*/
|
|
1301
|
+
404: FlashStartErrorBody;
|
|
1302
|
+
/**
|
|
1303
|
+
* Internal server error
|
|
1304
|
+
*/
|
|
1305
|
+
500: FlashStartErrorBody;
|
|
1306
|
+
};
|
|
1307
|
+
export type ListBlockedCountriesError = ListBlockedCountriesErrors[keyof ListBlockedCountriesErrors];
|
|
1308
|
+
export type ListBlockedCountriesResponses = {
|
|
1309
|
+
/**
|
|
1310
|
+
* Countries
|
|
1311
|
+
*/
|
|
1312
|
+
200: Array<Country>;
|
|
1313
|
+
};
|
|
1314
|
+
export type ListBlockedCountriesResponse = ListBlockedCountriesResponses[keyof ListBlockedCountriesResponses];
|
|
1315
|
+
export type BlockCountriesData = {
|
|
1316
|
+
body: CountryIds;
|
|
1317
|
+
path: {
|
|
1318
|
+
policyId: Uuid;
|
|
1319
|
+
};
|
|
1320
|
+
query?: never;
|
|
1321
|
+
url: '/v1/policies/{policyId}/countries/blocked';
|
|
1322
|
+
};
|
|
1323
|
+
export type BlockCountriesErrors = {
|
|
1324
|
+
/**
|
|
1325
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
1326
|
+
*/
|
|
1327
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1328
|
+
/**
|
|
1329
|
+
* Insufficient permission
|
|
1330
|
+
*/
|
|
1331
|
+
403: FlashStartErrorBody;
|
|
1332
|
+
/**
|
|
1333
|
+
* Resource not found
|
|
1334
|
+
*/
|
|
1335
|
+
404: FlashStartErrorBody;
|
|
1336
|
+
/**
|
|
1337
|
+
* Request validation failed
|
|
1338
|
+
*/
|
|
1339
|
+
422: FlashStartErrorBody;
|
|
1340
|
+
/**
|
|
1341
|
+
* Internal server error
|
|
1342
|
+
*/
|
|
1343
|
+
500: FlashStartErrorBody;
|
|
1344
|
+
};
|
|
1345
|
+
export type BlockCountriesError = BlockCountriesErrors[keyof BlockCountriesErrors];
|
|
1346
|
+
export type BlockCountriesResponses = {
|
|
1347
|
+
/**
|
|
1348
|
+
* Per-country results
|
|
1349
|
+
*/
|
|
1350
|
+
207: MultiStatusBlockedCountry;
|
|
1351
|
+
};
|
|
1352
|
+
export type BlockCountriesResponse = BlockCountriesResponses[keyof BlockCountriesResponses];
|
|
1353
|
+
export type AllowTldsData = {
|
|
1354
|
+
body: TldIds;
|
|
1355
|
+
path: {
|
|
1356
|
+
policyId: Uuid;
|
|
1357
|
+
};
|
|
1358
|
+
query?: never;
|
|
1359
|
+
url: '/v1/policies/{policyId}/tlds/blocked';
|
|
1360
|
+
};
|
|
1361
|
+
export type AllowTldsErrors = {
|
|
1362
|
+
/**
|
|
1363
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
1364
|
+
*/
|
|
1365
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1366
|
+
/**
|
|
1367
|
+
* Insufficient permission
|
|
1368
|
+
*/
|
|
1369
|
+
403: FlashStartErrorBody;
|
|
1370
|
+
/**
|
|
1371
|
+
* Resource not found
|
|
1372
|
+
*/
|
|
1373
|
+
404: FlashStartErrorBody;
|
|
1374
|
+
/**
|
|
1375
|
+
* Request validation failed
|
|
1376
|
+
*/
|
|
1377
|
+
422: FlashStartErrorBody;
|
|
1378
|
+
/**
|
|
1379
|
+
* Internal server error
|
|
1380
|
+
*/
|
|
1381
|
+
500: FlashStartErrorBody;
|
|
1382
|
+
};
|
|
1383
|
+
export type AllowTldsError = AllowTldsErrors[keyof AllowTldsErrors];
|
|
1384
|
+
export type AllowTldsResponses = {
|
|
1385
|
+
/**
|
|
1386
|
+
* Per-TLD results
|
|
1387
|
+
*/
|
|
1388
|
+
207: MultiStatusTldBlockedOnPolicy;
|
|
1389
|
+
};
|
|
1390
|
+
export type AllowTldsResponse = AllowTldsResponses[keyof AllowTldsResponses];
|
|
1391
|
+
export type ListBlockedTldsData = {
|
|
1392
|
+
body?: never;
|
|
1393
|
+
path: {
|
|
1394
|
+
policyId: Uuid;
|
|
1395
|
+
};
|
|
1396
|
+
query?: never;
|
|
1397
|
+
url: '/v1/policies/{policyId}/tlds/blocked';
|
|
1398
|
+
};
|
|
1399
|
+
export type ListBlockedTldsErrors = {
|
|
1400
|
+
/**
|
|
1401
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
1402
|
+
*/
|
|
1403
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1404
|
+
/**
|
|
1405
|
+
* Insufficient permission
|
|
1406
|
+
*/
|
|
1407
|
+
403: FlashStartErrorBody;
|
|
1408
|
+
/**
|
|
1409
|
+
* Resource not found
|
|
1410
|
+
*/
|
|
1411
|
+
404: FlashStartErrorBody;
|
|
1412
|
+
/**
|
|
1413
|
+
* Internal server error
|
|
1414
|
+
*/
|
|
1415
|
+
500: FlashStartErrorBody;
|
|
1416
|
+
};
|
|
1417
|
+
export type ListBlockedTldsError = ListBlockedTldsErrors[keyof ListBlockedTldsErrors];
|
|
1418
|
+
export type ListBlockedTldsResponses = {
|
|
1419
|
+
/**
|
|
1420
|
+
* Blocked TLDs
|
|
1421
|
+
*/
|
|
1422
|
+
200: Array<TldBlockedOnPolicy>;
|
|
1423
|
+
};
|
|
1424
|
+
export type ListBlockedTldsResponse = ListBlockedTldsResponses[keyof ListBlockedTldsResponses];
|
|
1425
|
+
export type BlockTldsData = {
|
|
1426
|
+
body: TldIds;
|
|
1427
|
+
path: {
|
|
1428
|
+
policyId: Uuid;
|
|
1429
|
+
};
|
|
1430
|
+
query?: never;
|
|
1431
|
+
url: '/v1/policies/{policyId}/tlds/blocked';
|
|
1432
|
+
};
|
|
1433
|
+
export type BlockTldsErrors = {
|
|
1434
|
+
/**
|
|
1435
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
1436
|
+
*/
|
|
1437
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1438
|
+
/**
|
|
1439
|
+
* Insufficient permission
|
|
1440
|
+
*/
|
|
1441
|
+
403: FlashStartErrorBody;
|
|
1442
|
+
/**
|
|
1443
|
+
* Resource not found
|
|
1444
|
+
*/
|
|
1445
|
+
404: FlashStartErrorBody;
|
|
1446
|
+
/**
|
|
1447
|
+
* Request validation failed
|
|
1448
|
+
*/
|
|
1449
|
+
422: FlashStartErrorBody;
|
|
1450
|
+
/**
|
|
1451
|
+
* Internal server error
|
|
1452
|
+
*/
|
|
1453
|
+
500: FlashStartErrorBody;
|
|
1454
|
+
};
|
|
1455
|
+
export type BlockTldsError = BlockTldsErrors[keyof BlockTldsErrors];
|
|
1456
|
+
export type BlockTldsResponses = {
|
|
1457
|
+
/**
|
|
1458
|
+
* Per-TLD results
|
|
1459
|
+
*/
|
|
1460
|
+
207: MultiStatusTldBlockedOnPolicy;
|
|
1461
|
+
};
|
|
1462
|
+
export type BlockTldsResponse = BlockTldsResponses[keyof BlockTldsResponses];
|
|
1463
|
+
export type ListCategoriesData = {
|
|
1464
|
+
body?: never;
|
|
1465
|
+
path?: never;
|
|
1466
|
+
query?: {
|
|
1467
|
+
organizationId?: Uuid;
|
|
1468
|
+
lang?: string;
|
|
1469
|
+
};
|
|
1470
|
+
url: '/v1/categories';
|
|
1471
|
+
};
|
|
1472
|
+
export type ListCategoriesErrors = {
|
|
1473
|
+
/**
|
|
1474
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
1475
|
+
*/
|
|
1476
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1477
|
+
/**
|
|
1478
|
+
* Insufficient permission
|
|
1479
|
+
*/
|
|
1480
|
+
403: FlashStartErrorBody;
|
|
1481
|
+
/**
|
|
1482
|
+
* Resource not found
|
|
1483
|
+
*/
|
|
1484
|
+
404: FlashStartErrorBody;
|
|
1485
|
+
/**
|
|
1486
|
+
* Internal server error
|
|
1487
|
+
*/
|
|
1488
|
+
500: FlashStartErrorBody;
|
|
1489
|
+
};
|
|
1490
|
+
export type ListCategoriesError = ListCategoriesErrors[keyof ListCategoriesErrors];
|
|
1491
|
+
export type ListCategoriesResponses = {
|
|
1492
|
+
/**
|
|
1493
|
+
* Categories
|
|
1494
|
+
*/
|
|
1495
|
+
200: Array<Category>;
|
|
1496
|
+
};
|
|
1497
|
+
export type ListCategoriesResponse = ListCategoriesResponses[keyof ListCategoriesResponses];
|
|
1498
|
+
export type ListCategoryMacrosData = {
|
|
1499
|
+
body?: never;
|
|
1500
|
+
path?: never;
|
|
1501
|
+
query?: {
|
|
1502
|
+
organizationId?: Uuid;
|
|
1503
|
+
lang?: string;
|
|
1504
|
+
};
|
|
1505
|
+
url: '/v1/categories/macros';
|
|
1506
|
+
};
|
|
1507
|
+
export type ListCategoryMacrosErrors = {
|
|
1508
|
+
/**
|
|
1509
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
1510
|
+
*/
|
|
1511
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1512
|
+
/**
|
|
1513
|
+
* Insufficient permission
|
|
1514
|
+
*/
|
|
1515
|
+
403: FlashStartErrorBody;
|
|
1516
|
+
/**
|
|
1517
|
+
* Resource not found
|
|
1518
|
+
*/
|
|
1519
|
+
404: FlashStartErrorBody;
|
|
1520
|
+
/**
|
|
1521
|
+
* Internal server error
|
|
1522
|
+
*/
|
|
1523
|
+
500: FlashStartErrorBody;
|
|
1524
|
+
};
|
|
1525
|
+
export type ListCategoryMacrosError = ListCategoryMacrosErrors[keyof ListCategoryMacrosErrors];
|
|
1526
|
+
export type ListCategoryMacrosResponses = {
|
|
1527
|
+
/**
|
|
1528
|
+
* Macro categories
|
|
1529
|
+
*/
|
|
1530
|
+
200: Array<MacroCategoryWithCategories>;
|
|
1531
|
+
};
|
|
1532
|
+
export type ListCategoryMacrosResponse = ListCategoryMacrosResponses[keyof ListCategoryMacrosResponses];
|
|
1533
|
+
export type ListAppBlockerCategoriesData = {
|
|
1534
|
+
body?: never;
|
|
1535
|
+
path?: never;
|
|
1536
|
+
query?: {
|
|
1537
|
+
organizationId?: Uuid;
|
|
1538
|
+
lang?: string;
|
|
1539
|
+
};
|
|
1540
|
+
url: '/v1/appblocker/categories';
|
|
1541
|
+
};
|
|
1542
|
+
export type ListAppBlockerCategoriesErrors = {
|
|
1543
|
+
/**
|
|
1544
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
1545
|
+
*/
|
|
1546
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1547
|
+
/**
|
|
1548
|
+
* Insufficient permission
|
|
1549
|
+
*/
|
|
1550
|
+
403: FlashStartErrorBody;
|
|
1551
|
+
/**
|
|
1552
|
+
* Resource not found
|
|
1553
|
+
*/
|
|
1554
|
+
404: FlashStartErrorBody;
|
|
1555
|
+
/**
|
|
1556
|
+
* Internal server error
|
|
1557
|
+
*/
|
|
1558
|
+
500: FlashStartErrorBody;
|
|
1559
|
+
};
|
|
1560
|
+
export type ListAppBlockerCategoriesError = ListAppBlockerCategoriesErrors[keyof ListAppBlockerCategoriesErrors];
|
|
1561
|
+
export type ListAppBlockerCategoriesResponses = {
|
|
1562
|
+
/**
|
|
1563
|
+
* Categories
|
|
1564
|
+
*/
|
|
1565
|
+
200: Array<Category>;
|
|
1566
|
+
};
|
|
1567
|
+
export type ListAppBlockerCategoriesResponse = ListAppBlockerCategoriesResponses[keyof ListAppBlockerCategoriesResponses];
|
|
1568
|
+
export type ListAppBlockerCategoryMacrosData = {
|
|
1569
|
+
body?: never;
|
|
1570
|
+
path?: never;
|
|
1571
|
+
query?: {
|
|
1572
|
+
organizationId?: Uuid;
|
|
1573
|
+
lang?: string;
|
|
1574
|
+
};
|
|
1575
|
+
url: '/v1/appblocker/macros';
|
|
1576
|
+
};
|
|
1577
|
+
export type ListAppBlockerCategoryMacrosErrors = {
|
|
1578
|
+
/**
|
|
1579
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
1580
|
+
*/
|
|
1581
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1582
|
+
/**
|
|
1583
|
+
* Insufficient permission
|
|
1584
|
+
*/
|
|
1585
|
+
403: FlashStartErrorBody;
|
|
1586
|
+
/**
|
|
1587
|
+
* Resource not found
|
|
1588
|
+
*/
|
|
1589
|
+
404: FlashStartErrorBody;
|
|
1590
|
+
/**
|
|
1591
|
+
* Internal server error
|
|
1592
|
+
*/
|
|
1593
|
+
500: FlashStartErrorBody;
|
|
1594
|
+
};
|
|
1595
|
+
export type ListAppBlockerCategoryMacrosError = ListAppBlockerCategoryMacrosErrors[keyof ListAppBlockerCategoryMacrosErrors];
|
|
1596
|
+
export type ListAppBlockerCategoryMacrosResponses = {
|
|
1597
|
+
/**
|
|
1598
|
+
* Macro categories
|
|
1599
|
+
*/
|
|
1600
|
+
200: Array<MacroCategoryWithCategories>;
|
|
1601
|
+
};
|
|
1602
|
+
export type ListAppBlockerCategoryMacrosResponse = ListAppBlockerCategoryMacrosResponses[keyof ListAppBlockerCategoryMacrosResponses];
|
|
1603
|
+
export type ListMalwareCategoriesData = {
|
|
1604
|
+
body?: never;
|
|
1605
|
+
path?: never;
|
|
1606
|
+
query?: {
|
|
1607
|
+
organizationId?: Uuid;
|
|
1608
|
+
lang?: string;
|
|
1609
|
+
};
|
|
1610
|
+
url: '/v1/malwares/categories';
|
|
1611
|
+
};
|
|
1612
|
+
export type ListMalwareCategoriesErrors = {
|
|
1613
|
+
/**
|
|
1614
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
1615
|
+
*/
|
|
1616
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1617
|
+
/**
|
|
1618
|
+
* Insufficient permission
|
|
1619
|
+
*/
|
|
1620
|
+
403: FlashStartErrorBody;
|
|
1621
|
+
/**
|
|
1622
|
+
* Resource not found
|
|
1623
|
+
*/
|
|
1624
|
+
404: FlashStartErrorBody;
|
|
1625
|
+
/**
|
|
1626
|
+
* Internal server error
|
|
1627
|
+
*/
|
|
1628
|
+
500: FlashStartErrorBody;
|
|
1629
|
+
};
|
|
1630
|
+
export type ListMalwareCategoriesError = ListMalwareCategoriesErrors[keyof ListMalwareCategoriesErrors];
|
|
1631
|
+
export type ListMalwareCategoriesResponses = {
|
|
1632
|
+
/**
|
|
1633
|
+
* Categories
|
|
1634
|
+
*/
|
|
1635
|
+
200: Array<Category>;
|
|
1636
|
+
};
|
|
1637
|
+
export type ListMalwareCategoriesResponse = ListMalwareCategoriesResponses[keyof ListMalwareCategoriesResponses];
|
|
1638
|
+
export type ListMalwareCategoryMacrosData = {
|
|
1639
|
+
body?: never;
|
|
1640
|
+
path?: never;
|
|
1641
|
+
query?: {
|
|
1642
|
+
organizationId?: Uuid;
|
|
1643
|
+
lang?: string;
|
|
1644
|
+
};
|
|
1645
|
+
url: '/v1/malwares/macros';
|
|
1646
|
+
};
|
|
1647
|
+
export type ListMalwareCategoryMacrosErrors = {
|
|
1648
|
+
/**
|
|
1649
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
1650
|
+
*/
|
|
1651
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1652
|
+
/**
|
|
1653
|
+
* Insufficient permission
|
|
1654
|
+
*/
|
|
1655
|
+
403: FlashStartErrorBody;
|
|
1656
|
+
/**
|
|
1657
|
+
* Resource not found
|
|
1658
|
+
*/
|
|
1659
|
+
404: FlashStartErrorBody;
|
|
1660
|
+
/**
|
|
1661
|
+
* Internal server error
|
|
1662
|
+
*/
|
|
1663
|
+
500: FlashStartErrorBody;
|
|
1664
|
+
};
|
|
1665
|
+
export type ListMalwareCategoryMacrosError = ListMalwareCategoryMacrosErrors[keyof ListMalwareCategoryMacrosErrors];
|
|
1666
|
+
export type ListMalwareCategoryMacrosResponses = {
|
|
1667
|
+
/**
|
|
1668
|
+
* Macro categories
|
|
1669
|
+
*/
|
|
1670
|
+
200: Array<MacroCategoryWithCategories>;
|
|
1671
|
+
};
|
|
1672
|
+
export type ListMalwareCategoryMacrosResponse = ListMalwareCategoryMacrosResponses[keyof ListMalwareCategoryMacrosResponses];
|
|
1673
|
+
export type ListContinentsData = {
|
|
1674
|
+
body?: never;
|
|
1675
|
+
path?: never;
|
|
1676
|
+
query?: {
|
|
1677
|
+
lang?: string;
|
|
1678
|
+
};
|
|
1679
|
+
url: '/v1/continents';
|
|
1680
|
+
};
|
|
1681
|
+
export type ListContinentsErrors = {
|
|
1682
|
+
/**
|
|
1683
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
1684
|
+
*/
|
|
1685
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1686
|
+
/**
|
|
1687
|
+
* Insufficient permission
|
|
1688
|
+
*/
|
|
1689
|
+
403: FlashStartErrorBody;
|
|
1690
|
+
/**
|
|
1691
|
+
* Resource not found
|
|
1692
|
+
*/
|
|
1693
|
+
404: FlashStartErrorBody;
|
|
1694
|
+
/**
|
|
1695
|
+
* Internal server error
|
|
1696
|
+
*/
|
|
1697
|
+
500: FlashStartErrorBody;
|
|
1698
|
+
};
|
|
1699
|
+
export type ListContinentsError = ListContinentsErrors[keyof ListContinentsErrors];
|
|
1700
|
+
export type ListContinentsResponses = {
|
|
1701
|
+
/**
|
|
1702
|
+
* Continents
|
|
1703
|
+
*/
|
|
1704
|
+
200: Array<ContinentWithCountries>;
|
|
1705
|
+
};
|
|
1706
|
+
export type ListContinentsResponse = ListContinentsResponses[keyof ListContinentsResponses];
|
|
1707
|
+
export type ListCountriesData = {
|
|
1708
|
+
body?: never;
|
|
1709
|
+
path?: never;
|
|
1710
|
+
query?: never;
|
|
1711
|
+
url: '/v1/countries';
|
|
1712
|
+
};
|
|
1713
|
+
export type ListCountriesErrors = {
|
|
1714
|
+
/**
|
|
1715
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
1716
|
+
*/
|
|
1717
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1718
|
+
/**
|
|
1719
|
+
* Insufficient permission
|
|
1720
|
+
*/
|
|
1721
|
+
403: FlashStartErrorBody;
|
|
1722
|
+
/**
|
|
1723
|
+
* Resource not found
|
|
1724
|
+
*/
|
|
1725
|
+
404: FlashStartErrorBody;
|
|
1726
|
+
/**
|
|
1727
|
+
* Internal server error
|
|
1728
|
+
*/
|
|
1729
|
+
500: FlashStartErrorBody;
|
|
1730
|
+
};
|
|
1731
|
+
export type ListCountriesError = ListCountriesErrors[keyof ListCountriesErrors];
|
|
1732
|
+
export type ListCountriesResponses = {
|
|
1733
|
+
/**
|
|
1734
|
+
* Countries
|
|
1735
|
+
*/
|
|
1736
|
+
200: Array<Country>;
|
|
1737
|
+
};
|
|
1738
|
+
export type ListCountriesResponse = ListCountriesResponses[keyof ListCountriesResponses];
|
|
1739
|
+
export type ListExceptionGroupsData = {
|
|
1740
|
+
body?: never;
|
|
1741
|
+
path?: never;
|
|
1742
|
+
query?: {
|
|
1743
|
+
organizationId?: Uuid;
|
|
1744
|
+
includeAssociatedPolicies?: 'true' | 'false';
|
|
1745
|
+
};
|
|
1746
|
+
url: '/v1/exceptiongroups';
|
|
1747
|
+
};
|
|
1748
|
+
export type ListExceptionGroupsErrors = {
|
|
1749
|
+
/**
|
|
1750
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
1751
|
+
*/
|
|
1752
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1753
|
+
/**
|
|
1754
|
+
* Insufficient permission
|
|
1755
|
+
*/
|
|
1756
|
+
403: FlashStartErrorBody;
|
|
1757
|
+
/**
|
|
1758
|
+
* Resource not found
|
|
1759
|
+
*/
|
|
1760
|
+
404: FlashStartErrorBody;
|
|
1761
|
+
/**
|
|
1762
|
+
* Internal server error
|
|
1763
|
+
*/
|
|
1764
|
+
500: FlashStartErrorBody;
|
|
1765
|
+
};
|
|
1766
|
+
export type ListExceptionGroupsError = ListExceptionGroupsErrors[keyof ListExceptionGroupsErrors];
|
|
1767
|
+
export type ListExceptionGroupsResponses = {
|
|
1768
|
+
/**
|
|
1769
|
+
* Exception groups
|
|
1770
|
+
*/
|
|
1771
|
+
200: Array<ExceptionGroupWithDomains | ExceptionGroupWithDomainsAndPolicies>;
|
|
1772
|
+
};
|
|
1773
|
+
export type ListExceptionGroupsResponse = ListExceptionGroupsResponses[keyof ListExceptionGroupsResponses];
|
|
1774
|
+
export type CreateExceptionGroupData = {
|
|
1775
|
+
body: ExceptionGroupCreation2;
|
|
1776
|
+
path?: never;
|
|
1777
|
+
query?: never;
|
|
1778
|
+
url: '/v1/exceptiongroups';
|
|
1779
|
+
};
|
|
1780
|
+
export type CreateExceptionGroupErrors = {
|
|
1781
|
+
/**
|
|
1782
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
1783
|
+
*/
|
|
1784
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1785
|
+
/**
|
|
1786
|
+
* Insufficient permission
|
|
1787
|
+
*/
|
|
1788
|
+
403: FlashStartErrorBody;
|
|
1789
|
+
/**
|
|
1790
|
+
* Resource not found
|
|
1791
|
+
*/
|
|
1792
|
+
404: FlashStartErrorBody;
|
|
1793
|
+
/**
|
|
1794
|
+
* Request validation failed
|
|
1795
|
+
*/
|
|
1796
|
+
422: FlashStartErrorBody;
|
|
1797
|
+
/**
|
|
1798
|
+
* Internal server error
|
|
1799
|
+
*/
|
|
1800
|
+
500: FlashStartErrorBody;
|
|
1801
|
+
};
|
|
1802
|
+
export type CreateExceptionGroupError = CreateExceptionGroupErrors[keyof CreateExceptionGroupErrors];
|
|
1803
|
+
export type CreateExceptionGroupResponses = {
|
|
1804
|
+
/**
|
|
1805
|
+
* Exception group with domains
|
|
1806
|
+
*/
|
|
1807
|
+
201: ExceptionGroupWithDomains;
|
|
1808
|
+
};
|
|
1809
|
+
export type CreateExceptionGroupResponse = CreateExceptionGroupResponses[keyof CreateExceptionGroupResponses];
|
|
1810
|
+
export type DeleteExceptionGroupData = {
|
|
1811
|
+
body?: never;
|
|
1812
|
+
path: {
|
|
1813
|
+
exceptionGroupId: Uuid;
|
|
1814
|
+
};
|
|
1815
|
+
query?: never;
|
|
1816
|
+
url: '/v1/exceptiongroups/{exceptionGroupId}';
|
|
1817
|
+
};
|
|
1818
|
+
export type DeleteExceptionGroupErrors = {
|
|
1819
|
+
/**
|
|
1820
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
1821
|
+
*/
|
|
1822
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1823
|
+
/**
|
|
1824
|
+
* Insufficient permission
|
|
1825
|
+
*/
|
|
1826
|
+
403: FlashStartErrorBody;
|
|
1827
|
+
/**
|
|
1828
|
+
* Resource not found
|
|
1829
|
+
*/
|
|
1830
|
+
404: FlashStartErrorBody;
|
|
1831
|
+
/**
|
|
1832
|
+
* Internal server error
|
|
1833
|
+
*/
|
|
1834
|
+
500: FlashStartErrorBody;
|
|
1835
|
+
};
|
|
1836
|
+
export type DeleteExceptionGroupError = DeleteExceptionGroupErrors[keyof DeleteExceptionGroupErrors];
|
|
1837
|
+
export type DeleteExceptionGroupResponses = {
|
|
1838
|
+
/**
|
|
1839
|
+
* Exception group
|
|
1840
|
+
*/
|
|
1841
|
+
200: ExceptionGroup;
|
|
1842
|
+
};
|
|
1843
|
+
export type DeleteExceptionGroupResponse = DeleteExceptionGroupResponses[keyof DeleteExceptionGroupResponses];
|
|
1844
|
+
export type UpdateExceptionGroupData = {
|
|
1845
|
+
body: ExceptionGroupUpdate2;
|
|
1846
|
+
path: {
|
|
1847
|
+
exceptionGroupId: Uuid;
|
|
1848
|
+
};
|
|
1849
|
+
query?: never;
|
|
1850
|
+
url: '/v1/exceptiongroups/{exceptionGroupId}';
|
|
1851
|
+
};
|
|
1852
|
+
export type UpdateExceptionGroupErrors = {
|
|
1853
|
+
/**
|
|
1854
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
1855
|
+
*/
|
|
1856
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1857
|
+
/**
|
|
1858
|
+
* Insufficient permission
|
|
1859
|
+
*/
|
|
1860
|
+
403: FlashStartErrorBody;
|
|
1861
|
+
/**
|
|
1862
|
+
* Resource not found
|
|
1863
|
+
*/
|
|
1864
|
+
404: FlashStartErrorBody;
|
|
1865
|
+
/**
|
|
1866
|
+
* Request validation failed
|
|
1867
|
+
*/
|
|
1868
|
+
422: FlashStartErrorBody;
|
|
1869
|
+
/**
|
|
1870
|
+
* Internal server error
|
|
1871
|
+
*/
|
|
1872
|
+
500: FlashStartErrorBody;
|
|
1873
|
+
};
|
|
1874
|
+
export type UpdateExceptionGroupError = UpdateExceptionGroupErrors[keyof UpdateExceptionGroupErrors];
|
|
1875
|
+
export type UpdateExceptionGroupResponses = {
|
|
1876
|
+
/**
|
|
1877
|
+
* Exception group
|
|
1878
|
+
*/
|
|
1879
|
+
200: ExceptionGroup;
|
|
1880
|
+
};
|
|
1881
|
+
export type UpdateExceptionGroupResponse = UpdateExceptionGroupResponses[keyof UpdateExceptionGroupResponses];
|
|
1882
|
+
export type ListExceptionGroupDomainsData = {
|
|
1883
|
+
body?: never;
|
|
1884
|
+
path: {
|
|
1885
|
+
exceptionGroupId: Uuid;
|
|
1886
|
+
};
|
|
1887
|
+
query?: never;
|
|
1888
|
+
url: '/v1/exceptiongroups/{exceptionGroupId}/domains';
|
|
1889
|
+
};
|
|
1890
|
+
export type ListExceptionGroupDomainsErrors = {
|
|
1891
|
+
/**
|
|
1892
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
1893
|
+
*/
|
|
1894
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1895
|
+
/**
|
|
1896
|
+
* Insufficient permission
|
|
1897
|
+
*/
|
|
1898
|
+
403: FlashStartErrorBody;
|
|
1899
|
+
/**
|
|
1900
|
+
* Resource not found
|
|
1901
|
+
*/
|
|
1902
|
+
404: FlashStartErrorBody;
|
|
1903
|
+
/**
|
|
1904
|
+
* Internal server error
|
|
1905
|
+
*/
|
|
1906
|
+
500: FlashStartErrorBody;
|
|
1907
|
+
};
|
|
1908
|
+
export type ListExceptionGroupDomainsError = ListExceptionGroupDomainsErrors[keyof ListExceptionGroupDomainsErrors];
|
|
1909
|
+
export type ListExceptionGroupDomainsResponses = {
|
|
1910
|
+
/**
|
|
1911
|
+
* Domains
|
|
1912
|
+
*/
|
|
1913
|
+
200: Array<Domain>;
|
|
1914
|
+
};
|
|
1915
|
+
export type ListExceptionGroupDomainsResponse = ListExceptionGroupDomainsResponses[keyof ListExceptionGroupDomainsResponses];
|
|
1916
|
+
export type AddExceptionGroupDomainsData = {
|
|
1917
|
+
body: Domains;
|
|
1918
|
+
path: {
|
|
1919
|
+
exceptionGroupId: Uuid;
|
|
1920
|
+
};
|
|
1921
|
+
query?: never;
|
|
1922
|
+
url: '/v1/exceptiongroups/{exceptionGroupId}/domains';
|
|
1923
|
+
};
|
|
1924
|
+
export type AddExceptionGroupDomainsErrors = {
|
|
1925
|
+
/**
|
|
1926
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
1927
|
+
*/
|
|
1928
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1929
|
+
/**
|
|
1930
|
+
* Insufficient permission
|
|
1931
|
+
*/
|
|
1932
|
+
403: FlashStartErrorBody;
|
|
1933
|
+
/**
|
|
1934
|
+
* Resource not found
|
|
1935
|
+
*/
|
|
1936
|
+
404: FlashStartErrorBody;
|
|
1937
|
+
/**
|
|
1938
|
+
* Request validation failed
|
|
1939
|
+
*/
|
|
1940
|
+
422: FlashStartErrorBody;
|
|
1941
|
+
/**
|
|
1942
|
+
* Internal server error
|
|
1943
|
+
*/
|
|
1944
|
+
500: FlashStartErrorBody;
|
|
1945
|
+
};
|
|
1946
|
+
export type AddExceptionGroupDomainsError = AddExceptionGroupDomainsErrors[keyof AddExceptionGroupDomainsErrors];
|
|
1947
|
+
export type AddExceptionGroupDomainsResponses = {
|
|
1948
|
+
/**
|
|
1949
|
+
* Exception group domain associations
|
|
1950
|
+
*/
|
|
1951
|
+
201: Array<DomainInExceptionGroup>;
|
|
1952
|
+
};
|
|
1953
|
+
export type AddExceptionGroupDomainsResponse = AddExceptionGroupDomainsResponses[keyof AddExceptionGroupDomainsResponses];
|
|
1954
|
+
export type RemoveExceptionGroupDomainData = {
|
|
1955
|
+
body?: never;
|
|
1956
|
+
path: {
|
|
1957
|
+
exceptionGroupId: Uuid;
|
|
1958
|
+
domainId: Uuid;
|
|
1959
|
+
};
|
|
1960
|
+
query?: never;
|
|
1961
|
+
url: '/v1/exceptiongroups/{exceptionGroupId}/domains/{domainId}';
|
|
1962
|
+
};
|
|
1963
|
+
export type RemoveExceptionGroupDomainErrors = {
|
|
1964
|
+
/**
|
|
1965
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
1966
|
+
*/
|
|
1967
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
1968
|
+
/**
|
|
1969
|
+
* Insufficient permission
|
|
1970
|
+
*/
|
|
1971
|
+
403: FlashStartErrorBody;
|
|
1972
|
+
/**
|
|
1973
|
+
* Resource not found
|
|
1974
|
+
*/
|
|
1975
|
+
404: FlashStartErrorBody;
|
|
1976
|
+
/**
|
|
1977
|
+
* Internal server error
|
|
1978
|
+
*/
|
|
1979
|
+
500: FlashStartErrorBody;
|
|
1980
|
+
};
|
|
1981
|
+
export type RemoveExceptionGroupDomainError = RemoveExceptionGroupDomainErrors[keyof RemoveExceptionGroupDomainErrors];
|
|
1982
|
+
export type RemoveExceptionGroupDomainResponses = {
|
|
1983
|
+
/**
|
|
1984
|
+
* Exception group domain association
|
|
1985
|
+
*/
|
|
1986
|
+
200: DomainInExceptionGroup;
|
|
1987
|
+
};
|
|
1988
|
+
export type RemoveExceptionGroupDomainResponse = RemoveExceptionGroupDomainResponses[keyof RemoveExceptionGroupDomainResponses];
|
|
1989
|
+
export type UpdateExceptionGroupDomainNoteData = {
|
|
1990
|
+
body: DomainNote;
|
|
1991
|
+
path: {
|
|
1992
|
+
exceptionGroupId: Uuid;
|
|
1993
|
+
domainId: Uuid;
|
|
1994
|
+
};
|
|
1995
|
+
query?: never;
|
|
1996
|
+
url: '/v1/exceptiongroups/{exceptionGroupId}/domains/{domainId}';
|
|
1997
|
+
};
|
|
1998
|
+
export type UpdateExceptionGroupDomainNoteErrors = {
|
|
1999
|
+
/**
|
|
2000
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
2001
|
+
*/
|
|
2002
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
2003
|
+
/**
|
|
2004
|
+
* Insufficient permission
|
|
2005
|
+
*/
|
|
2006
|
+
403: FlashStartErrorBody;
|
|
2007
|
+
/**
|
|
2008
|
+
* Resource not found
|
|
2009
|
+
*/
|
|
2010
|
+
404: FlashStartErrorBody;
|
|
2011
|
+
/**
|
|
2012
|
+
* Request validation failed
|
|
2013
|
+
*/
|
|
2014
|
+
422: FlashStartErrorBody;
|
|
2015
|
+
/**
|
|
2016
|
+
* Internal server error
|
|
2017
|
+
*/
|
|
2018
|
+
500: FlashStartErrorBody;
|
|
2019
|
+
};
|
|
2020
|
+
export type UpdateExceptionGroupDomainNoteError = UpdateExceptionGroupDomainNoteErrors[keyof UpdateExceptionGroupDomainNoteErrors];
|
|
2021
|
+
export type UpdateExceptionGroupDomainNoteResponses = {
|
|
2022
|
+
/**
|
|
2023
|
+
* Exception group domain association
|
|
2024
|
+
*/
|
|
2025
|
+
200: DomainInExceptionGroup;
|
|
2026
|
+
};
|
|
2027
|
+
export type UpdateExceptionGroupDomainNoteResponse = UpdateExceptionGroupDomainNoteResponses[keyof UpdateExceptionGroupDomainNoteResponses];
|
|
2028
|
+
export type ListProtectionTemplatesData = {
|
|
2029
|
+
body?: never;
|
|
2030
|
+
path?: never;
|
|
2031
|
+
query?: {
|
|
2032
|
+
organizationId?: Uuid;
|
|
2033
|
+
lang?: string;
|
|
2034
|
+
};
|
|
2035
|
+
url: '/v1/templates';
|
|
2036
|
+
};
|
|
2037
|
+
export type ListProtectionTemplatesErrors = {
|
|
2038
|
+
/**
|
|
2039
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
2040
|
+
*/
|
|
2041
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
2042
|
+
/**
|
|
2043
|
+
* Insufficient permission
|
|
2044
|
+
*/
|
|
2045
|
+
403: FlashStartErrorBody;
|
|
2046
|
+
/**
|
|
2047
|
+
* Resource not found
|
|
2048
|
+
*/
|
|
2049
|
+
404: FlashStartErrorBody;
|
|
2050
|
+
/**
|
|
2051
|
+
* Internal server error
|
|
2052
|
+
*/
|
|
2053
|
+
500: FlashStartErrorBody;
|
|
2054
|
+
};
|
|
2055
|
+
export type ListProtectionTemplatesError = ListProtectionTemplatesErrors[keyof ListProtectionTemplatesErrors];
|
|
2056
|
+
export type ListProtectionTemplatesResponses = {
|
|
2057
|
+
/**
|
|
2058
|
+
* Protection templates
|
|
2059
|
+
*/
|
|
2060
|
+
200: Array<TemplateWithConfigData>;
|
|
2061
|
+
};
|
|
2062
|
+
export type ListProtectionTemplatesResponse = ListProtectionTemplatesResponses[keyof ListProtectionTemplatesResponses];
|
|
2063
|
+
export type ListTemplateCategoriesData = {
|
|
2064
|
+
body?: never;
|
|
2065
|
+
path: {
|
|
2066
|
+
templateId: Uuid;
|
|
2067
|
+
};
|
|
2068
|
+
query?: {
|
|
2069
|
+
organizationId?: Uuid;
|
|
2070
|
+
lang?: string;
|
|
2071
|
+
};
|
|
2072
|
+
url: '/v1/templates/{templateId}/categories';
|
|
2073
|
+
};
|
|
2074
|
+
export type ListTemplateCategoriesErrors = {
|
|
2075
|
+
/**
|
|
2076
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
2077
|
+
*/
|
|
2078
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
2079
|
+
/**
|
|
2080
|
+
* Insufficient permission
|
|
2081
|
+
*/
|
|
2082
|
+
403: FlashStartErrorBody;
|
|
2083
|
+
/**
|
|
2084
|
+
* Resource not found
|
|
2085
|
+
*/
|
|
2086
|
+
404: FlashStartErrorBody;
|
|
2087
|
+
/**
|
|
2088
|
+
* Internal server error
|
|
2089
|
+
*/
|
|
2090
|
+
500: FlashStartErrorBody;
|
|
2091
|
+
};
|
|
2092
|
+
export type ListTemplateCategoriesError = ListTemplateCategoriesErrors[keyof ListTemplateCategoriesErrors];
|
|
2093
|
+
export type ListTemplateCategoriesResponses = {
|
|
2094
|
+
/**
|
|
2095
|
+
* Categories
|
|
2096
|
+
*/
|
|
2097
|
+
200: Array<Category>;
|
|
2098
|
+
};
|
|
2099
|
+
export type ListTemplateCategoriesResponse = ListTemplateCategoriesResponses[keyof ListTemplateCategoriesResponses];
|
|
2100
|
+
export type ListTldsData = {
|
|
2101
|
+
body?: never;
|
|
2102
|
+
path?: never;
|
|
2103
|
+
query?: never;
|
|
2104
|
+
url: '/v1/tlds';
|
|
2105
|
+
};
|
|
2106
|
+
export type ListTldsErrors = {
|
|
2107
|
+
/**
|
|
2108
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
2109
|
+
*/
|
|
2110
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
2111
|
+
/**
|
|
2112
|
+
* Insufficient permission
|
|
2113
|
+
*/
|
|
2114
|
+
403: FlashStartErrorBody;
|
|
2115
|
+
/**
|
|
2116
|
+
* Resource not found
|
|
2117
|
+
*/
|
|
2118
|
+
404: FlashStartErrorBody;
|
|
2119
|
+
/**
|
|
2120
|
+
* Internal server error
|
|
2121
|
+
*/
|
|
2122
|
+
500: FlashStartErrorBody;
|
|
2123
|
+
};
|
|
2124
|
+
export type ListTldsError = ListTldsErrors[keyof ListTldsErrors];
|
|
2125
|
+
export type ListTldsResponses = {
|
|
2126
|
+
/**
|
|
2127
|
+
* TLDs
|
|
2128
|
+
*/
|
|
2129
|
+
200: Array<Tld>;
|
|
2130
|
+
};
|
|
2131
|
+
export type ListTldsResponse = ListTldsResponses[keyof ListTldsResponses];
|
|
2132
|
+
export type ListTldMacrosData = {
|
|
2133
|
+
body?: never;
|
|
2134
|
+
path?: never;
|
|
2135
|
+
query?: {
|
|
2136
|
+
lang?: string;
|
|
2137
|
+
};
|
|
2138
|
+
url: '/v1/tlds/macro';
|
|
2139
|
+
};
|
|
2140
|
+
export type ListTldMacrosErrors = {
|
|
2141
|
+
/**
|
|
2142
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
2143
|
+
*/
|
|
2144
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
2145
|
+
/**
|
|
2146
|
+
* Insufficient permission
|
|
2147
|
+
*/
|
|
2148
|
+
403: FlashStartErrorBody;
|
|
2149
|
+
/**
|
|
2150
|
+
* Resource not found
|
|
2151
|
+
*/
|
|
2152
|
+
404: FlashStartErrorBody;
|
|
2153
|
+
/**
|
|
2154
|
+
* Internal server error
|
|
2155
|
+
*/
|
|
2156
|
+
500: FlashStartErrorBody;
|
|
2157
|
+
};
|
|
2158
|
+
export type ListTldMacrosError = ListTldMacrosErrors[keyof ListTldMacrosErrors];
|
|
2159
|
+
export type ListTldMacrosResponses = {
|
|
2160
|
+
/**
|
|
2161
|
+
* TLD macros
|
|
2162
|
+
*/
|
|
2163
|
+
200: Array<MacroTldWithTlds>;
|
|
2164
|
+
};
|
|
2165
|
+
export type ListTldMacrosResponse = ListTldMacrosResponses[keyof ListTldMacrosResponses];
|
|
2166
|
+
export type GetTldData = {
|
|
2167
|
+
body?: never;
|
|
2168
|
+
path: {
|
|
2169
|
+
tldName: string;
|
|
2170
|
+
};
|
|
2171
|
+
query?: never;
|
|
2172
|
+
url: '/v1/tlds/{tldName}';
|
|
2173
|
+
};
|
|
2174
|
+
export type GetTldErrors = {
|
|
2175
|
+
/**
|
|
2176
|
+
* Missing or invalid API key or bearer credentials; missing credentials return a message, invalid credentials return a standard error
|
|
2177
|
+
*/
|
|
2178
|
+
401: MissingCredentialsErrorBody | FlashStartErrorBody;
|
|
2179
|
+
/**
|
|
2180
|
+
* Insufficient permission
|
|
2181
|
+
*/
|
|
2182
|
+
403: FlashStartErrorBody;
|
|
2183
|
+
/**
|
|
2184
|
+
* Resource not found
|
|
2185
|
+
*/
|
|
2186
|
+
404: FlashStartErrorBody;
|
|
2187
|
+
/**
|
|
2188
|
+
* Internal server error
|
|
2189
|
+
*/
|
|
2190
|
+
500: FlashStartErrorBody;
|
|
2191
|
+
};
|
|
2192
|
+
export type GetTldError = GetTldErrors[keyof GetTldErrors];
|
|
2193
|
+
export type GetTldResponses = {
|
|
2194
|
+
/**
|
|
2195
|
+
* TLD
|
|
2196
|
+
*/
|
|
2197
|
+
200: Tld;
|
|
2198
|
+
};
|
|
2199
|
+
export type GetTldResponse = GetTldResponses[keyof GetTldResponses];
|