re-uploading work
This commit is contained in:
433
web/src/api/services/ActionsService.ts
Normal file
433
web/src/api/services/ActionsService.ts
Normal file
@@ -0,0 +1,433 @@
|
||||
/* generated using openapi-typescript-codegen -- do not edit */
|
||||
/* istanbul ignore file */
|
||||
/* tslint:disable */
|
||||
/* eslint-disable */
|
||||
import type { CreateActionRequest } from '../models/CreateActionRequest';
|
||||
import type { PaginatedResponse_ActionSummary } from '../models/PaginatedResponse_ActionSummary';
|
||||
import type { SuccessResponse } from '../models/SuccessResponse';
|
||||
import type { UpdateActionRequest } from '../models/UpdateActionRequest';
|
||||
import type { CancelablePromise } from '../core/CancelablePromise';
|
||||
import { OpenAPI } from '../core/OpenAPI';
|
||||
import { request as __request } from '../core/request';
|
||||
export class ActionsService {
|
||||
/**
|
||||
* List all actions with pagination
|
||||
* @returns PaginatedResponse_ActionSummary List of actions
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static listActions({
|
||||
page,
|
||||
pageSize,
|
||||
}: {
|
||||
/**
|
||||
* Page number (1-based)
|
||||
*/
|
||||
page?: number,
|
||||
/**
|
||||
* Number of items per page
|
||||
*/
|
||||
pageSize?: number,
|
||||
}): CancelablePromise<PaginatedResponse_ActionSummary> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/actions',
|
||||
query: {
|
||||
'page': page,
|
||||
'page_size': pageSize,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Create a new action
|
||||
* @returns any Action created successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static createAction({
|
||||
requestBody,
|
||||
}: {
|
||||
requestBody: CreateActionRequest,
|
||||
}): CancelablePromise<{
|
||||
/**
|
||||
* Response DTO for action information
|
||||
*/
|
||||
data: {
|
||||
/**
|
||||
* Creation timestamp
|
||||
*/
|
||||
created: string;
|
||||
/**
|
||||
* Action description
|
||||
*/
|
||||
description: string;
|
||||
/**
|
||||
* Entry point
|
||||
*/
|
||||
entrypoint: string;
|
||||
/**
|
||||
* Action ID
|
||||
*/
|
||||
id: number;
|
||||
/**
|
||||
* Whether this is an ad-hoc action (not from pack installation)
|
||||
*/
|
||||
is_adhoc: boolean;
|
||||
/**
|
||||
* Human-readable label
|
||||
*/
|
||||
label: string;
|
||||
/**
|
||||
* Output schema
|
||||
*/
|
||||
out_schema: any | null;
|
||||
/**
|
||||
* Pack ID
|
||||
*/
|
||||
pack: number;
|
||||
/**
|
||||
* Pack reference
|
||||
*/
|
||||
pack_ref: string;
|
||||
/**
|
||||
* Parameter schema
|
||||
*/
|
||||
param_schema: any | null;
|
||||
/**
|
||||
* Unique reference identifier
|
||||
*/
|
||||
ref: string;
|
||||
/**
|
||||
* Runtime ID
|
||||
*/
|
||||
runtime?: number | null;
|
||||
/**
|
||||
* Last update timestamp
|
||||
*/
|
||||
updated: string;
|
||||
};
|
||||
/**
|
||||
* Optional message
|
||||
*/
|
||||
message?: string | null;
|
||||
}> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/api/v1/actions',
|
||||
body: requestBody,
|
||||
mediaType: 'application/json',
|
||||
errors: {
|
||||
400: `Validation error`,
|
||||
404: `Pack not found`,
|
||||
409: `Action with same ref already exists`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Get a single action by reference
|
||||
* @returns any Action details
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static getAction({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Action reference identifier
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<{
|
||||
/**
|
||||
* Response DTO for action information
|
||||
*/
|
||||
data: {
|
||||
/**
|
||||
* Creation timestamp
|
||||
*/
|
||||
created: string;
|
||||
/**
|
||||
* Action description
|
||||
*/
|
||||
description: string;
|
||||
/**
|
||||
* Entry point
|
||||
*/
|
||||
entrypoint: string;
|
||||
/**
|
||||
* Action ID
|
||||
*/
|
||||
id: number;
|
||||
/**
|
||||
* Whether this is an ad-hoc action (not from pack installation)
|
||||
*/
|
||||
is_adhoc: boolean;
|
||||
/**
|
||||
* Human-readable label
|
||||
*/
|
||||
label: string;
|
||||
/**
|
||||
* Output schema
|
||||
*/
|
||||
out_schema: any | null;
|
||||
/**
|
||||
* Pack ID
|
||||
*/
|
||||
pack: number;
|
||||
/**
|
||||
* Pack reference
|
||||
*/
|
||||
pack_ref: string;
|
||||
/**
|
||||
* Parameter schema
|
||||
*/
|
||||
param_schema: any | null;
|
||||
/**
|
||||
* Unique reference identifier
|
||||
*/
|
||||
ref: string;
|
||||
/**
|
||||
* Runtime ID
|
||||
*/
|
||||
runtime?: number | null;
|
||||
/**
|
||||
* Last update timestamp
|
||||
*/
|
||||
updated: string;
|
||||
};
|
||||
/**
|
||||
* Optional message
|
||||
*/
|
||||
message?: string | null;
|
||||
}> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/actions/{ref}',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
404: `Action not found`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Update an existing action
|
||||
* @returns any Action updated successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static updateAction({
|
||||
ref,
|
||||
requestBody,
|
||||
}: {
|
||||
/**
|
||||
* Action reference identifier
|
||||
*/
|
||||
ref: string,
|
||||
requestBody: UpdateActionRequest,
|
||||
}): CancelablePromise<{
|
||||
/**
|
||||
* Response DTO for action information
|
||||
*/
|
||||
data: {
|
||||
/**
|
||||
* Creation timestamp
|
||||
*/
|
||||
created: string;
|
||||
/**
|
||||
* Action description
|
||||
*/
|
||||
description: string;
|
||||
/**
|
||||
* Entry point
|
||||
*/
|
||||
entrypoint: string;
|
||||
/**
|
||||
* Action ID
|
||||
*/
|
||||
id: number;
|
||||
/**
|
||||
* Whether this is an ad-hoc action (not from pack installation)
|
||||
*/
|
||||
is_adhoc: boolean;
|
||||
/**
|
||||
* Human-readable label
|
||||
*/
|
||||
label: string;
|
||||
/**
|
||||
* Output schema
|
||||
*/
|
||||
out_schema: any | null;
|
||||
/**
|
||||
* Pack ID
|
||||
*/
|
||||
pack: number;
|
||||
/**
|
||||
* Pack reference
|
||||
*/
|
||||
pack_ref: string;
|
||||
/**
|
||||
* Parameter schema
|
||||
*/
|
||||
param_schema: any | null;
|
||||
/**
|
||||
* Unique reference identifier
|
||||
*/
|
||||
ref: string;
|
||||
/**
|
||||
* Runtime ID
|
||||
*/
|
||||
runtime?: number | null;
|
||||
/**
|
||||
* Last update timestamp
|
||||
*/
|
||||
updated: string;
|
||||
};
|
||||
/**
|
||||
* Optional message
|
||||
*/
|
||||
message?: string | null;
|
||||
}> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'PUT',
|
||||
url: '/api/v1/actions/{ref}',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
body: requestBody,
|
||||
mediaType: 'application/json',
|
||||
errors: {
|
||||
400: `Validation error`,
|
||||
404: `Action not found`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Delete an action
|
||||
* @returns SuccessResponse Action deleted successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static deleteAction({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Action reference identifier
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<SuccessResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'DELETE',
|
||||
url: '/api/v1/actions/{ref}',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
404: `Action not found`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Get queue statistics for an action
|
||||
* @returns any Queue statistics
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static getQueueStats({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Action reference identifier
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<{
|
||||
/**
|
||||
* Response DTO for queue statistics
|
||||
*/
|
||||
data: {
|
||||
/**
|
||||
* Action ID
|
||||
*/
|
||||
action_id: number;
|
||||
/**
|
||||
* Action reference
|
||||
*/
|
||||
action_ref: string;
|
||||
/**
|
||||
* Number of currently running executions
|
||||
*/
|
||||
active_count: number;
|
||||
/**
|
||||
* Timestamp of last statistics update
|
||||
*/
|
||||
last_updated: string;
|
||||
/**
|
||||
* Maximum concurrent executions allowed
|
||||
*/
|
||||
max_concurrent: number;
|
||||
/**
|
||||
* Timestamp of oldest queued execution (if any)
|
||||
*/
|
||||
oldest_enqueued_at?: string | null;
|
||||
/**
|
||||
* Number of executions waiting in queue
|
||||
*/
|
||||
queue_length: number;
|
||||
/**
|
||||
* Total executions completed since queue creation
|
||||
*/
|
||||
total_completed: number;
|
||||
/**
|
||||
* Total executions enqueued since queue creation
|
||||
*/
|
||||
total_enqueued: number;
|
||||
};
|
||||
/**
|
||||
* Optional message
|
||||
*/
|
||||
message?: string | null;
|
||||
}> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/actions/{ref}/queue-stats',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
404: `Action not found or no queue statistics available`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* List actions by pack reference
|
||||
* @returns PaginatedResponse_ActionSummary List of actions for pack
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static listActionsByPack({
|
||||
packRef,
|
||||
page,
|
||||
pageSize,
|
||||
}: {
|
||||
/**
|
||||
* Pack reference identifier
|
||||
*/
|
||||
packRef: string,
|
||||
/**
|
||||
* Page number (1-based)
|
||||
*/
|
||||
page?: number,
|
||||
/**
|
||||
* Number of items per page
|
||||
*/
|
||||
pageSize?: number,
|
||||
}): CancelablePromise<PaginatedResponse_ActionSummary> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/packs/{pack_ref}/actions',
|
||||
path: {
|
||||
'pack_ref': packRef,
|
||||
},
|
||||
query: {
|
||||
'page': page,
|
||||
'page_size': pageSize,
|
||||
},
|
||||
errors: {
|
||||
404: `Pack not found`,
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
240
web/src/api/services/AuthService.ts
Normal file
240
web/src/api/services/AuthService.ts
Normal file
@@ -0,0 +1,240 @@
|
||||
/* generated using openapi-typescript-codegen -- do not edit */
|
||||
/* istanbul ignore file */
|
||||
/* tslint:disable */
|
||||
/* eslint-disable */
|
||||
import type { ChangePasswordRequest } from '../models/ChangePasswordRequest';
|
||||
import type { LoginRequest } from '../models/LoginRequest';
|
||||
import type { RefreshTokenRequest } from '../models/RefreshTokenRequest';
|
||||
import type { RegisterRequest } from '../models/RegisterRequest';
|
||||
import type { UserInfo } from '../models/UserInfo';
|
||||
import type { CancelablePromise } from '../core/CancelablePromise';
|
||||
import { OpenAPI } from '../core/OpenAPI';
|
||||
import { request as __request } from '../core/request';
|
||||
export class AuthService {
|
||||
/**
|
||||
* Change password endpoint
|
||||
* POST /auth/change-password
|
||||
* @returns any Password changed successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static changePassword({
|
||||
requestBody,
|
||||
}: {
|
||||
requestBody: ChangePasswordRequest,
|
||||
}): CancelablePromise<{
|
||||
/**
|
||||
* Success message response (for operations that don't return data)
|
||||
*/
|
||||
data: {
|
||||
/**
|
||||
* Message describing the operation
|
||||
*/
|
||||
message: string;
|
||||
/**
|
||||
* Success indicator
|
||||
*/
|
||||
success: boolean;
|
||||
};
|
||||
/**
|
||||
* Optional message
|
||||
*/
|
||||
message?: string | null;
|
||||
}> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/auth/change-password',
|
||||
body: requestBody,
|
||||
mediaType: 'application/json',
|
||||
errors: {
|
||||
400: `Validation error`,
|
||||
401: `Invalid current password or unauthorized`,
|
||||
404: `Identity not found`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Login endpoint
|
||||
* POST /auth/login
|
||||
* @returns any Successfully logged in
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static login({
|
||||
requestBody,
|
||||
}: {
|
||||
requestBody: LoginRequest,
|
||||
}): CancelablePromise<{
|
||||
/**
|
||||
* Token response
|
||||
*/
|
||||
data: {
|
||||
/**
|
||||
* Access token (JWT)
|
||||
*/
|
||||
access_token: string;
|
||||
/**
|
||||
* Access token expiration in seconds
|
||||
*/
|
||||
expires_in: number;
|
||||
/**
|
||||
* Refresh token
|
||||
*/
|
||||
refresh_token: string;
|
||||
/**
|
||||
* Token type (always "Bearer")
|
||||
*/
|
||||
token_type: string;
|
||||
user?: (null | UserInfo);
|
||||
};
|
||||
/**
|
||||
* Optional message
|
||||
*/
|
||||
message?: string | null;
|
||||
}> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/auth/login',
|
||||
body: requestBody,
|
||||
mediaType: 'application/json',
|
||||
errors: {
|
||||
400: `Validation error`,
|
||||
401: `Invalid credentials`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Get current user endpoint
|
||||
* GET /auth/me
|
||||
* @returns any Current user information
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static getCurrentUser(): CancelablePromise<{
|
||||
/**
|
||||
* Current user response
|
||||
*/
|
||||
data: {
|
||||
/**
|
||||
* Display name
|
||||
*/
|
||||
display_name?: string | null;
|
||||
/**
|
||||
* Identity ID
|
||||
*/
|
||||
id: number;
|
||||
/**
|
||||
* Identity login
|
||||
*/
|
||||
login: string;
|
||||
};
|
||||
/**
|
||||
* Optional message
|
||||
*/
|
||||
message?: string | null;
|
||||
}> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/auth/me',
|
||||
errors: {
|
||||
401: `Unauthorized`,
|
||||
404: `Identity not found`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Refresh token endpoint
|
||||
* POST /auth/refresh
|
||||
* @returns any Successfully refreshed token
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static refreshToken({
|
||||
requestBody,
|
||||
}: {
|
||||
requestBody: RefreshTokenRequest,
|
||||
}): CancelablePromise<{
|
||||
/**
|
||||
* Token response
|
||||
*/
|
||||
data: {
|
||||
/**
|
||||
* Access token (JWT)
|
||||
*/
|
||||
access_token: string;
|
||||
/**
|
||||
* Access token expiration in seconds
|
||||
*/
|
||||
expires_in: number;
|
||||
/**
|
||||
* Refresh token
|
||||
*/
|
||||
refresh_token: string;
|
||||
/**
|
||||
* Token type (always "Bearer")
|
||||
*/
|
||||
token_type: string;
|
||||
user?: (null | UserInfo);
|
||||
};
|
||||
/**
|
||||
* Optional message
|
||||
*/
|
||||
message?: string | null;
|
||||
}> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/auth/refresh',
|
||||
body: requestBody,
|
||||
mediaType: 'application/json',
|
||||
errors: {
|
||||
400: `Validation error`,
|
||||
401: `Invalid or expired refresh token`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Register endpoint
|
||||
* POST /auth/register
|
||||
* @returns any Successfully registered
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static register({
|
||||
requestBody,
|
||||
}: {
|
||||
requestBody: RegisterRequest,
|
||||
}): CancelablePromise<{
|
||||
/**
|
||||
* Token response
|
||||
*/
|
||||
data: {
|
||||
/**
|
||||
* Access token (JWT)
|
||||
*/
|
||||
access_token: string;
|
||||
/**
|
||||
* Access token expiration in seconds
|
||||
*/
|
||||
expires_in: number;
|
||||
/**
|
||||
* Refresh token
|
||||
*/
|
||||
refresh_token: string;
|
||||
/**
|
||||
* Token type (always "Bearer")
|
||||
*/
|
||||
token_type: string;
|
||||
user?: (null | UserInfo);
|
||||
};
|
||||
/**
|
||||
* Optional message
|
||||
*/
|
||||
message?: string | null;
|
||||
}> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/auth/register',
|
||||
body: requestBody,
|
||||
mediaType: 'application/json',
|
||||
errors: {
|
||||
400: `Validation error`,
|
||||
409: `User already exists`,
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
94
web/src/api/services/EnforcementsService.ts
Normal file
94
web/src/api/services/EnforcementsService.ts
Normal file
@@ -0,0 +1,94 @@
|
||||
/* generated using openapi-typescript-codegen -- do not edit */
|
||||
/* istanbul ignore file */
|
||||
/* tslint:disable */
|
||||
/* eslint-disable */
|
||||
import type { ApiResponse_EnforcementResponse } from '../models/ApiResponse_EnforcementResponse';
|
||||
import type { EnforcementStatus } from '../models/EnforcementStatus';
|
||||
import type { i64 } from '../models/i64';
|
||||
import type { PaginatedResponse_EnforcementSummary } from '../models/PaginatedResponse_EnforcementSummary';
|
||||
import type { CancelablePromise } from '../core/CancelablePromise';
|
||||
import { OpenAPI } from '../core/OpenAPI';
|
||||
import { request as __request } from '../core/request';
|
||||
export class EnforcementsService {
|
||||
/**
|
||||
* List all enforcements with pagination and optional filters
|
||||
* @returns PaginatedResponse_EnforcementSummary List of enforcements
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static listEnforcements({
|
||||
rule,
|
||||
event,
|
||||
status,
|
||||
triggerRef,
|
||||
page,
|
||||
perPage,
|
||||
}: {
|
||||
/**
|
||||
* Filter by rule ID
|
||||
*/
|
||||
rule?: (null | i64),
|
||||
/**
|
||||
* Filter by event ID
|
||||
*/
|
||||
event?: (null | i64),
|
||||
/**
|
||||
* Filter by status
|
||||
*/
|
||||
status?: (null | EnforcementStatus),
|
||||
/**
|
||||
* Filter by trigger reference
|
||||
*/
|
||||
triggerRef?: string | null,
|
||||
/**
|
||||
* Page number (1-indexed)
|
||||
*/
|
||||
page?: number,
|
||||
/**
|
||||
* Items per page
|
||||
*/
|
||||
perPage?: number,
|
||||
}): CancelablePromise<PaginatedResponse_EnforcementSummary> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/enforcements',
|
||||
query: {
|
||||
'rule': rule,
|
||||
'event': event,
|
||||
'status': status,
|
||||
'trigger_ref': triggerRef,
|
||||
'page': page,
|
||||
'per_page': perPage,
|
||||
},
|
||||
errors: {
|
||||
401: `Unauthorized`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Get a single enforcement by ID
|
||||
* @returns ApiResponse_EnforcementResponse Enforcement details
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static getEnforcement({
|
||||
id,
|
||||
}: {
|
||||
/**
|
||||
* Enforcement ID
|
||||
*/
|
||||
id: number,
|
||||
}): CancelablePromise<ApiResponse_EnforcementResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/enforcements/{id}',
|
||||
path: {
|
||||
'id': id,
|
||||
},
|
||||
errors: {
|
||||
401: `Unauthorized`,
|
||||
404: `Enforcement not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
87
web/src/api/services/EventsService.ts
Normal file
87
web/src/api/services/EventsService.ts
Normal file
@@ -0,0 +1,87 @@
|
||||
/* generated using openapi-typescript-codegen -- do not edit */
|
||||
/* istanbul ignore file */
|
||||
/* tslint:disable */
|
||||
/* eslint-disable */
|
||||
import type { ApiResponse_EventResponse } from '../models/ApiResponse_EventResponse';
|
||||
import type { i64 } from '../models/i64';
|
||||
import type { PaginatedResponse_EventSummary } from '../models/PaginatedResponse_EventSummary';
|
||||
import type { CancelablePromise } from '../core/CancelablePromise';
|
||||
import { OpenAPI } from '../core/OpenAPI';
|
||||
import { request as __request } from '../core/request';
|
||||
export class EventsService {
|
||||
/**
|
||||
* List all events with pagination and optional filters
|
||||
* @returns PaginatedResponse_EventSummary List of events
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static listEvents({
|
||||
trigger,
|
||||
triggerRef,
|
||||
source,
|
||||
page,
|
||||
perPage,
|
||||
}: {
|
||||
/**
|
||||
* Filter by trigger ID
|
||||
*/
|
||||
trigger?: (null | i64),
|
||||
/**
|
||||
* Filter by trigger reference
|
||||
*/
|
||||
triggerRef?: string | null,
|
||||
/**
|
||||
* Filter by source ID
|
||||
*/
|
||||
source?: (null | i64),
|
||||
/**
|
||||
* Page number (1-indexed)
|
||||
*/
|
||||
page?: number,
|
||||
/**
|
||||
* Items per page
|
||||
*/
|
||||
perPage?: number,
|
||||
}): CancelablePromise<PaginatedResponse_EventSummary> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/events',
|
||||
query: {
|
||||
'trigger': trigger,
|
||||
'trigger_ref': triggerRef,
|
||||
'source': source,
|
||||
'page': page,
|
||||
'per_page': perPage,
|
||||
},
|
||||
errors: {
|
||||
401: `Unauthorized`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Get a single event by ID
|
||||
* @returns ApiResponse_EventResponse Event details
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static getEvent({
|
||||
id,
|
||||
}: {
|
||||
/**
|
||||
* Event ID
|
||||
*/
|
||||
id: number,
|
||||
}): CancelablePromise<ApiResponse_EventResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/events/{id}',
|
||||
path: {
|
||||
'id': id,
|
||||
},
|
||||
errors: {
|
||||
401: `Unauthorized`,
|
||||
404: `Event not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
261
web/src/api/services/ExecutionsService.ts
Normal file
261
web/src/api/services/ExecutionsService.ts
Normal file
@@ -0,0 +1,261 @@
|
||||
/* generated using openapi-typescript-codegen -- do not edit */
|
||||
/* istanbul ignore file */
|
||||
/* tslint:disable */
|
||||
/* eslint-disable */
|
||||
import type { ExecutionStatus } from '../models/ExecutionStatus';
|
||||
import type { PaginatedResponse_ExecutionSummary } from '../models/PaginatedResponse_ExecutionSummary';
|
||||
import type { CancelablePromise } from '../core/CancelablePromise';
|
||||
import { OpenAPI } from '../core/OpenAPI';
|
||||
import { request as __request } from '../core/request';
|
||||
export class ExecutionsService {
|
||||
/**
|
||||
* List all executions with pagination and optional filters
|
||||
* @returns PaginatedResponse_ExecutionSummary List of executions
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static listExecutions({
|
||||
status,
|
||||
actionRef,
|
||||
packName,
|
||||
ruleRef,
|
||||
triggerRef,
|
||||
executor,
|
||||
resultContains,
|
||||
enforcement,
|
||||
parent,
|
||||
page,
|
||||
perPage,
|
||||
}: {
|
||||
/**
|
||||
* Filter by execution status
|
||||
*/
|
||||
status?: (null | ExecutionStatus),
|
||||
/**
|
||||
* Filter by action reference
|
||||
*/
|
||||
actionRef?: string | null,
|
||||
/**
|
||||
* Filter by pack name
|
||||
*/
|
||||
packName?: string | null,
|
||||
/**
|
||||
* Filter by rule reference
|
||||
*/
|
||||
ruleRef?: string | null,
|
||||
/**
|
||||
* Filter by trigger reference
|
||||
*/
|
||||
triggerRef?: string | null,
|
||||
/**
|
||||
* Filter by executor ID
|
||||
*/
|
||||
executor?: number | null,
|
||||
/**
|
||||
* Search in result JSON (case-insensitive substring match)
|
||||
*/
|
||||
resultContains?: string | null,
|
||||
/**
|
||||
* Filter by enforcement ID
|
||||
*/
|
||||
enforcement?: number | null,
|
||||
/**
|
||||
* Filter by parent execution ID
|
||||
*/
|
||||
parent?: number | null,
|
||||
/**
|
||||
* Page number (for pagination)
|
||||
*/
|
||||
page?: number,
|
||||
/**
|
||||
* Items per page (for pagination)
|
||||
*/
|
||||
perPage?: number,
|
||||
}): CancelablePromise<PaginatedResponse_ExecutionSummary> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/executions',
|
||||
query: {
|
||||
'status': status,
|
||||
'action_ref': actionRef,
|
||||
'pack_name': packName,
|
||||
'rule_ref': ruleRef,
|
||||
'trigger_ref': triggerRef,
|
||||
'executor': executor,
|
||||
'result_contains': resultContains,
|
||||
'enforcement': enforcement,
|
||||
'parent': parent,
|
||||
'page': page,
|
||||
'per_page': perPage,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* List executions by enforcement ID
|
||||
* @returns PaginatedResponse_ExecutionSummary List of executions for enforcement
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static listExecutionsByEnforcement({
|
||||
enforcementId,
|
||||
page,
|
||||
pageSize,
|
||||
}: {
|
||||
/**
|
||||
* Enforcement ID
|
||||
*/
|
||||
enforcementId: number,
|
||||
/**
|
||||
* Page number (1-based)
|
||||
*/
|
||||
page?: number,
|
||||
/**
|
||||
* Number of items per page
|
||||
*/
|
||||
pageSize?: number,
|
||||
}): CancelablePromise<PaginatedResponse_ExecutionSummary> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/executions/enforcement/{enforcement_id}',
|
||||
path: {
|
||||
'enforcement_id': enforcementId,
|
||||
},
|
||||
query: {
|
||||
'page': page,
|
||||
'page_size': pageSize,
|
||||
},
|
||||
errors: {
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Get execution statistics
|
||||
* @returns any Execution statistics
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static getExecutionStats(): CancelablePromise<Record<string, any>> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/executions/stats',
|
||||
errors: {
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* List executions by status
|
||||
* @returns PaginatedResponse_ExecutionSummary List of executions with specified status
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static listExecutionsByStatus({
|
||||
status,
|
||||
page,
|
||||
pageSize,
|
||||
}: {
|
||||
/**
|
||||
* Execution status (requested, scheduling, scheduled, running, completed, failed, canceling, cancelled, timeout, abandoned)
|
||||
*/
|
||||
status: string,
|
||||
/**
|
||||
* Page number (1-based)
|
||||
*/
|
||||
page?: number,
|
||||
/**
|
||||
* Number of items per page
|
||||
*/
|
||||
pageSize?: number,
|
||||
}): CancelablePromise<PaginatedResponse_ExecutionSummary> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/executions/status/{status}',
|
||||
path: {
|
||||
'status': status,
|
||||
},
|
||||
query: {
|
||||
'page': page,
|
||||
'page_size': pageSize,
|
||||
},
|
||||
errors: {
|
||||
400: `Invalid status`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Get a single execution by ID
|
||||
* @returns any Execution details
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static getExecution({
|
||||
id,
|
||||
}: {
|
||||
/**
|
||||
* Execution ID
|
||||
*/
|
||||
id: number,
|
||||
}): CancelablePromise<{
|
||||
/**
|
||||
* Response DTO for execution information
|
||||
*/
|
||||
data: {
|
||||
/**
|
||||
* Action ID (optional, may be null for ad-hoc executions)
|
||||
*/
|
||||
action?: number | null;
|
||||
/**
|
||||
* Action reference
|
||||
*/
|
||||
action_ref: string;
|
||||
/**
|
||||
* Execution configuration/parameters
|
||||
*/
|
||||
config: Record<string, any>;
|
||||
/**
|
||||
* Creation timestamp
|
||||
*/
|
||||
created: string;
|
||||
/**
|
||||
* Enforcement ID (rule enforcement that triggered this)
|
||||
*/
|
||||
enforcement?: number | null;
|
||||
/**
|
||||
* Executor ID (worker/executor that ran this)
|
||||
*/
|
||||
executor?: number | null;
|
||||
/**
|
||||
* Execution ID
|
||||
*/
|
||||
id: number;
|
||||
/**
|
||||
* Parent execution ID (for nested/child executions)
|
||||
*/
|
||||
parent?: number | null;
|
||||
/**
|
||||
* Execution result/output
|
||||
*/
|
||||
result: Record<string, any>;
|
||||
/**
|
||||
* Execution status
|
||||
*/
|
||||
status: ExecutionStatus;
|
||||
/**
|
||||
* Last update timestamp
|
||||
*/
|
||||
updated: string;
|
||||
};
|
||||
/**
|
||||
* Optional message
|
||||
*/
|
||||
message?: string | null;
|
||||
}> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/executions/{id}',
|
||||
path: {
|
||||
'id': id,
|
||||
},
|
||||
errors: {
|
||||
404: `Execution not found`,
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
64
web/src/api/services/HealthService.ts
Normal file
64
web/src/api/services/HealthService.ts
Normal file
@@ -0,0 +1,64 @@
|
||||
/* generated using openapi-typescript-codegen -- do not edit */
|
||||
/* istanbul ignore file */
|
||||
/* tslint:disable */
|
||||
/* eslint-disable */
|
||||
import type { HealthResponse } from '../models/HealthResponse';
|
||||
import type { CancelablePromise } from '../core/CancelablePromise';
|
||||
import { OpenAPI } from '../core/OpenAPI';
|
||||
import { request as __request } from '../core/request';
|
||||
export class HealthService {
|
||||
/**
|
||||
* Basic health check endpoint
|
||||
* Returns 200 OK if the service is running
|
||||
* @returns any Service is healthy
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static health(): CancelablePromise<Record<string, any>> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/health',
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Detailed health check endpoint
|
||||
* Checks database connectivity and returns detailed status
|
||||
* @returns HealthResponse Service is healthy with details
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static healthDetailed(): CancelablePromise<HealthResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/health/detailed',
|
||||
errors: {
|
||||
503: `Service unavailable`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Liveness check endpoint
|
||||
* Returns 200 OK if the service process is alive
|
||||
* @returns any Service is alive
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static liveness(): CancelablePromise<any> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/health/live',
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Readiness check endpoint
|
||||
* Returns 200 OK if the service is ready to accept requests
|
||||
* @returns any Service is ready
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static readiness(): CancelablePromise<any> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/health/ready',
|
||||
errors: {
|
||||
503: `Service not ready`,
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
284
web/src/api/services/InquiriesService.ts
Normal file
284
web/src/api/services/InquiriesService.ts
Normal file
@@ -0,0 +1,284 @@
|
||||
/* generated using openapi-typescript-codegen -- do not edit */
|
||||
/* istanbul ignore file */
|
||||
/* tslint:disable */
|
||||
/* eslint-disable */
|
||||
import type { ApiResponse_InquiryResponse } from '../models/ApiResponse_InquiryResponse';
|
||||
import type { CreateInquiryRequest } from '../models/CreateInquiryRequest';
|
||||
import type { i64 } from '../models/i64';
|
||||
import type { InquiryRespondRequest } from '../models/InquiryRespondRequest';
|
||||
import type { InquiryStatus } from '../models/InquiryStatus';
|
||||
import type { PaginatedResponse_InquirySummary } from '../models/PaginatedResponse_InquirySummary';
|
||||
import type { SuccessResponse } from '../models/SuccessResponse';
|
||||
import type { UpdateInquiryRequest } from '../models/UpdateInquiryRequest';
|
||||
import type { CancelablePromise } from '../core/CancelablePromise';
|
||||
import { OpenAPI } from '../core/OpenAPI';
|
||||
import { request as __request } from '../core/request';
|
||||
export class InquiriesService {
|
||||
/**
|
||||
* List inquiries for a specific execution
|
||||
* @returns PaginatedResponse_InquirySummary List of inquiries for execution
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static listInquiriesByExecution({
|
||||
executionId,
|
||||
page,
|
||||
pageSize,
|
||||
}: {
|
||||
/**
|
||||
* Execution ID
|
||||
*/
|
||||
executionId: number,
|
||||
/**
|
||||
* Page number (1-based)
|
||||
*/
|
||||
page?: number,
|
||||
/**
|
||||
* Number of items per page
|
||||
*/
|
||||
pageSize?: number,
|
||||
}): CancelablePromise<PaginatedResponse_InquirySummary> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/executions/{execution_id}/inquiries',
|
||||
path: {
|
||||
'execution_id': executionId,
|
||||
},
|
||||
query: {
|
||||
'page': page,
|
||||
'page_size': pageSize,
|
||||
},
|
||||
errors: {
|
||||
401: `Unauthorized`,
|
||||
404: `Execution not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* List all inquiries with pagination and optional filters
|
||||
* @returns PaginatedResponse_InquirySummary List of inquiries
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static listInquiries({
|
||||
status,
|
||||
execution,
|
||||
assignedTo,
|
||||
offset,
|
||||
limit,
|
||||
}: {
|
||||
/**
|
||||
* Filter by status
|
||||
*/
|
||||
status?: (null | InquiryStatus),
|
||||
/**
|
||||
* Filter by execution ID
|
||||
*/
|
||||
execution?: (null | i64),
|
||||
/**
|
||||
* Filter by assigned identity
|
||||
*/
|
||||
assignedTo?: (null | i64),
|
||||
/**
|
||||
* Pagination offset
|
||||
*/
|
||||
offset?: number | null,
|
||||
/**
|
||||
* Pagination limit
|
||||
*/
|
||||
limit?: number | null,
|
||||
}): CancelablePromise<PaginatedResponse_InquirySummary> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/inquiries',
|
||||
query: {
|
||||
'status': status,
|
||||
'execution': execution,
|
||||
'assigned_to': assignedTo,
|
||||
'offset': offset,
|
||||
'limit': limit,
|
||||
},
|
||||
errors: {
|
||||
401: `Unauthorized`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Create a new inquiry
|
||||
* @returns ApiResponse_InquiryResponse Inquiry created successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static createInquiry({
|
||||
requestBody,
|
||||
}: {
|
||||
requestBody: CreateInquiryRequest,
|
||||
}): CancelablePromise<ApiResponse_InquiryResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/api/v1/inquiries',
|
||||
body: requestBody,
|
||||
mediaType: 'application/json',
|
||||
errors: {
|
||||
400: `Invalid request`,
|
||||
401: `Unauthorized`,
|
||||
404: `Execution not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* List inquiries by status
|
||||
* @returns PaginatedResponse_InquirySummary List of inquiries with specified status
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static listInquiriesByStatus({
|
||||
status,
|
||||
page,
|
||||
pageSize,
|
||||
}: {
|
||||
/**
|
||||
* Inquiry status (pending, responded, timeout, canceled)
|
||||
*/
|
||||
status: string,
|
||||
/**
|
||||
* Page number (1-based)
|
||||
*/
|
||||
page?: number,
|
||||
/**
|
||||
* Number of items per page
|
||||
*/
|
||||
pageSize?: number,
|
||||
}): CancelablePromise<PaginatedResponse_InquirySummary> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/inquiries/status/{status}',
|
||||
path: {
|
||||
'status': status,
|
||||
},
|
||||
query: {
|
||||
'page': page,
|
||||
'page_size': pageSize,
|
||||
},
|
||||
errors: {
|
||||
400: `Invalid status`,
|
||||
401: `Unauthorized`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Get a single inquiry by ID
|
||||
* @returns ApiResponse_InquiryResponse Inquiry details
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static getInquiry({
|
||||
id,
|
||||
}: {
|
||||
/**
|
||||
* Inquiry ID
|
||||
*/
|
||||
id: number,
|
||||
}): CancelablePromise<ApiResponse_InquiryResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/inquiries/{id}',
|
||||
path: {
|
||||
'id': id,
|
||||
},
|
||||
errors: {
|
||||
401: `Unauthorized`,
|
||||
404: `Inquiry not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Update an existing inquiry
|
||||
* @returns ApiResponse_InquiryResponse Inquiry updated successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static updateInquiry({
|
||||
id,
|
||||
requestBody,
|
||||
}: {
|
||||
/**
|
||||
* Inquiry ID
|
||||
*/
|
||||
id: number,
|
||||
requestBody: UpdateInquiryRequest,
|
||||
}): CancelablePromise<ApiResponse_InquiryResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'PUT',
|
||||
url: '/api/v1/inquiries/{id}',
|
||||
path: {
|
||||
'id': id,
|
||||
},
|
||||
body: requestBody,
|
||||
mediaType: 'application/json',
|
||||
errors: {
|
||||
400: `Invalid request`,
|
||||
401: `Unauthorized`,
|
||||
404: `Inquiry not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Delete an inquiry
|
||||
* @returns SuccessResponse Inquiry deleted successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static deleteInquiry({
|
||||
id,
|
||||
}: {
|
||||
/**
|
||||
* Inquiry ID
|
||||
*/
|
||||
id: number,
|
||||
}): CancelablePromise<SuccessResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'DELETE',
|
||||
url: '/api/v1/inquiries/{id}',
|
||||
path: {
|
||||
'id': id,
|
||||
},
|
||||
errors: {
|
||||
401: `Unauthorized`,
|
||||
404: `Inquiry not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Respond to an inquiry (user-facing endpoint)
|
||||
* @returns ApiResponse_InquiryResponse Response submitted successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static respondToInquiry({
|
||||
id,
|
||||
requestBody,
|
||||
}: {
|
||||
/**
|
||||
* Inquiry ID
|
||||
*/
|
||||
id: number,
|
||||
requestBody: InquiryRespondRequest,
|
||||
}): CancelablePromise<ApiResponse_InquiryResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/api/v1/inquiries/{id}/respond',
|
||||
path: {
|
||||
'id': id,
|
||||
},
|
||||
body: requestBody,
|
||||
mediaType: 'application/json',
|
||||
errors: {
|
||||
400: `Invalid request or inquiry cannot be responded to`,
|
||||
401: `Unauthorized`,
|
||||
403: `Not authorized to respond to this inquiry`,
|
||||
404: `Inquiry not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
612
web/src/api/services/PacksService.ts
Normal file
612
web/src/api/services/PacksService.ts
Normal file
@@ -0,0 +1,612 @@
|
||||
/* generated using openapi-typescript-codegen -- do not edit */
|
||||
/* istanbul ignore file */
|
||||
/* tslint:disable */
|
||||
/* eslint-disable */
|
||||
import type { ApiResponse_PackInstallResponse } from '../models/ApiResponse_PackInstallResponse';
|
||||
import type { CreatePackRequest } from '../models/CreatePackRequest';
|
||||
import type { i64 } from '../models/i64';
|
||||
import type { InstallPackRequest } from '../models/InstallPackRequest';
|
||||
import type { PaginatedResponse_PackSummary } from '../models/PaginatedResponse_PackSummary';
|
||||
import type { PaginationMeta } from '../models/PaginationMeta';
|
||||
import type { RegisterPackRequest } from '../models/RegisterPackRequest';
|
||||
import type { SuccessResponse } from '../models/SuccessResponse';
|
||||
import type { TestSuiteResult } from '../models/TestSuiteResult';
|
||||
import type { UpdatePackRequest } from '../models/UpdatePackRequest';
|
||||
import type { Value } from '../models/Value';
|
||||
import type { WorkflowSyncResult } from '../models/WorkflowSyncResult';
|
||||
import type { CancelablePromise } from '../core/CancelablePromise';
|
||||
import { OpenAPI } from '../core/OpenAPI';
|
||||
import { request as __request } from '../core/request';
|
||||
export class PacksService {
|
||||
/**
|
||||
* List all packs with pagination
|
||||
* @returns PaginatedResponse_PackSummary List of packs
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static listPacks({
|
||||
page,
|
||||
pageSize,
|
||||
}: {
|
||||
/**
|
||||
* Page number (1-based)
|
||||
*/
|
||||
page?: number,
|
||||
/**
|
||||
* Number of items per page
|
||||
*/
|
||||
pageSize?: number,
|
||||
}): CancelablePromise<PaginatedResponse_PackSummary> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/packs',
|
||||
query: {
|
||||
'page': page,
|
||||
'page_size': pageSize,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Create a new pack
|
||||
* @returns any Pack created successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static createPack({
|
||||
requestBody,
|
||||
}: {
|
||||
requestBody: CreatePackRequest,
|
||||
}): CancelablePromise<{
|
||||
/**
|
||||
* Response DTO for pack information
|
||||
*/
|
||||
data: {
|
||||
/**
|
||||
* Configuration schema
|
||||
*/
|
||||
conf_schema: Record<string, any>;
|
||||
/**
|
||||
* Pack configuration
|
||||
*/
|
||||
config: Record<string, any>;
|
||||
/**
|
||||
* Creation timestamp
|
||||
*/
|
||||
created: string;
|
||||
/**
|
||||
* Pack description
|
||||
*/
|
||||
description?: string | null;
|
||||
/**
|
||||
* Pack ID
|
||||
*/
|
||||
id: number;
|
||||
/**
|
||||
* Is standard pack
|
||||
*/
|
||||
is_standard: boolean;
|
||||
/**
|
||||
* Human-readable label
|
||||
*/
|
||||
label: string;
|
||||
/**
|
||||
* Pack metadata
|
||||
*/
|
||||
meta: Record<string, any>;
|
||||
/**
|
||||
* Unique reference identifier
|
||||
*/
|
||||
ref: string;
|
||||
/**
|
||||
* Runtime dependencies
|
||||
*/
|
||||
runtime_deps: Array<string>;
|
||||
/**
|
||||
* Tags
|
||||
*/
|
||||
tags: Array<string>;
|
||||
/**
|
||||
* Last update timestamp
|
||||
*/
|
||||
updated: string;
|
||||
/**
|
||||
* Pack version
|
||||
*/
|
||||
version: string;
|
||||
};
|
||||
/**
|
||||
* Optional message
|
||||
*/
|
||||
message?: string | null;
|
||||
}> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/api/v1/packs',
|
||||
body: requestBody,
|
||||
mediaType: 'application/json',
|
||||
errors: {
|
||||
400: `Validation error`,
|
||||
409: `Pack with same ref already exists`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Install a pack from remote source (git repository)
|
||||
* @returns ApiResponse_PackInstallResponse Pack installed successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static installPack({
|
||||
requestBody,
|
||||
}: {
|
||||
requestBody: InstallPackRequest,
|
||||
}): CancelablePromise<ApiResponse_PackInstallResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/api/v1/packs/install',
|
||||
body: requestBody,
|
||||
mediaType: 'application/json',
|
||||
errors: {
|
||||
400: `Invalid request or tests failed`,
|
||||
409: `Pack already exists`,
|
||||
501: `Not implemented yet`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Register a pack from local filesystem
|
||||
* @returns ApiResponse_PackInstallResponse Pack registered successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static registerPack({
|
||||
requestBody,
|
||||
}: {
|
||||
requestBody: RegisterPackRequest,
|
||||
}): CancelablePromise<ApiResponse_PackInstallResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/api/v1/packs/register',
|
||||
body: requestBody,
|
||||
mediaType: 'application/json',
|
||||
errors: {
|
||||
400: `Invalid request or tests failed`,
|
||||
409: `Pack already exists`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Get a single pack by reference
|
||||
* @returns any Pack details
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static getPack({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Pack reference identifier
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<{
|
||||
/**
|
||||
* Response DTO for pack information
|
||||
*/
|
||||
data: {
|
||||
/**
|
||||
* Configuration schema
|
||||
*/
|
||||
conf_schema: Record<string, any>;
|
||||
/**
|
||||
* Pack configuration
|
||||
*/
|
||||
config: Record<string, any>;
|
||||
/**
|
||||
* Creation timestamp
|
||||
*/
|
||||
created: string;
|
||||
/**
|
||||
* Pack description
|
||||
*/
|
||||
description?: string | null;
|
||||
/**
|
||||
* Pack ID
|
||||
*/
|
||||
id: number;
|
||||
/**
|
||||
* Is standard pack
|
||||
*/
|
||||
is_standard: boolean;
|
||||
/**
|
||||
* Human-readable label
|
||||
*/
|
||||
label: string;
|
||||
/**
|
||||
* Pack metadata
|
||||
*/
|
||||
meta: Record<string, any>;
|
||||
/**
|
||||
* Unique reference identifier
|
||||
*/
|
||||
ref: string;
|
||||
/**
|
||||
* Runtime dependencies
|
||||
*/
|
||||
runtime_deps: Array<string>;
|
||||
/**
|
||||
* Tags
|
||||
*/
|
||||
tags: Array<string>;
|
||||
/**
|
||||
* Last update timestamp
|
||||
*/
|
||||
updated: string;
|
||||
/**
|
||||
* Pack version
|
||||
*/
|
||||
version: string;
|
||||
};
|
||||
/**
|
||||
* Optional message
|
||||
*/
|
||||
message?: string | null;
|
||||
}> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/packs/{ref}',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
404: `Pack not found`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Update an existing pack
|
||||
* @returns any Pack updated successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static updatePack({
|
||||
ref,
|
||||
requestBody,
|
||||
}: {
|
||||
/**
|
||||
* Pack reference identifier
|
||||
*/
|
||||
ref: string,
|
||||
requestBody: UpdatePackRequest,
|
||||
}): CancelablePromise<{
|
||||
/**
|
||||
* Response DTO for pack information
|
||||
*/
|
||||
data: {
|
||||
/**
|
||||
* Configuration schema
|
||||
*/
|
||||
conf_schema: Record<string, any>;
|
||||
/**
|
||||
* Pack configuration
|
||||
*/
|
||||
config: Record<string, any>;
|
||||
/**
|
||||
* Creation timestamp
|
||||
*/
|
||||
created: string;
|
||||
/**
|
||||
* Pack description
|
||||
*/
|
||||
description?: string | null;
|
||||
/**
|
||||
* Pack ID
|
||||
*/
|
||||
id: number;
|
||||
/**
|
||||
* Is standard pack
|
||||
*/
|
||||
is_standard: boolean;
|
||||
/**
|
||||
* Human-readable label
|
||||
*/
|
||||
label: string;
|
||||
/**
|
||||
* Pack metadata
|
||||
*/
|
||||
meta: Record<string, any>;
|
||||
/**
|
||||
* Unique reference identifier
|
||||
*/
|
||||
ref: string;
|
||||
/**
|
||||
* Runtime dependencies
|
||||
*/
|
||||
runtime_deps: Array<string>;
|
||||
/**
|
||||
* Tags
|
||||
*/
|
||||
tags: Array<string>;
|
||||
/**
|
||||
* Last update timestamp
|
||||
*/
|
||||
updated: string;
|
||||
/**
|
||||
* Pack version
|
||||
*/
|
||||
version: string;
|
||||
};
|
||||
/**
|
||||
* Optional message
|
||||
*/
|
||||
message?: string | null;
|
||||
}> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'PUT',
|
||||
url: '/api/v1/packs/{ref}',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
body: requestBody,
|
||||
mediaType: 'application/json',
|
||||
errors: {
|
||||
400: `Validation error`,
|
||||
404: `Pack not found`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Delete a pack
|
||||
* @returns SuccessResponse Pack deleted successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static deletePack({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Pack reference identifier
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<SuccessResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'DELETE',
|
||||
url: '/api/v1/packs/{ref}',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
404: `Pack not found`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Execute tests for a pack
|
||||
* @returns any Tests executed successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static testPack({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Pack reference identifier
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<{
|
||||
/**
|
||||
* Pack test result structure (not from DB, used for test execution)
|
||||
*/
|
||||
data: {
|
||||
durationMs: number;
|
||||
executionTime: string;
|
||||
failed: number;
|
||||
packRef: string;
|
||||
packVersion: string;
|
||||
passRate: number;
|
||||
passed: number;
|
||||
skipped: number;
|
||||
status: string;
|
||||
testSuites: Array<TestSuiteResult>;
|
||||
totalTests: number;
|
||||
};
|
||||
/**
|
||||
* Optional message
|
||||
*/
|
||||
message?: string | null;
|
||||
}> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/api/v1/packs/{ref}/test',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
404: `Pack not found`,
|
||||
500: `Test execution failed`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Get test history for a pack
|
||||
* @returns any Test history retrieved
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static getPackTestHistory({
|
||||
ref,
|
||||
page,
|
||||
pageSize,
|
||||
}: {
|
||||
/**
|
||||
* Pack reference identifier
|
||||
*/
|
||||
ref: string,
|
||||
/**
|
||||
* Page number (1-based)
|
||||
*/
|
||||
page?: number,
|
||||
/**
|
||||
* Number of items per page
|
||||
*/
|
||||
pageSize?: number,
|
||||
}): CancelablePromise<{
|
||||
/**
|
||||
* The data items
|
||||
*/
|
||||
data: Array<{
|
||||
created: string;
|
||||
durationMs: number;
|
||||
executionTime: string;
|
||||
failed: number;
|
||||
id: i64;
|
||||
packId: i64;
|
||||
packVersion: string;
|
||||
passRate: number;
|
||||
passed: number;
|
||||
result: Value;
|
||||
skipped: number;
|
||||
totalTests: number;
|
||||
triggerReason: string;
|
||||
}>;
|
||||
/**
|
||||
* Pagination metadata
|
||||
*/
|
||||
pagination: PaginationMeta;
|
||||
}> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/packs/{ref}/tests',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
query: {
|
||||
'page': page,
|
||||
'page_size': pageSize,
|
||||
},
|
||||
errors: {
|
||||
404: `Pack not found`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Get latest test result for a pack
|
||||
* @returns any Latest test result retrieved
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static getPackLatestTest({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Pack reference identifier
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<any> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/packs/{ref}/tests/latest',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
404: `Pack not found or no tests available`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Sync workflows from filesystem to database for a pack
|
||||
* @returns any Workflows synced successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static syncPackWorkflows({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Pack reference identifier
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<{
|
||||
/**
|
||||
* Response for pack workflow sync operation
|
||||
*/
|
||||
data: {
|
||||
/**
|
||||
* Any errors encountered during sync
|
||||
*/
|
||||
errors: Array<string>;
|
||||
/**
|
||||
* Number of workflows loaded from filesystem
|
||||
*/
|
||||
loaded_count: number;
|
||||
/**
|
||||
* Pack reference
|
||||
*/
|
||||
pack_ref: string;
|
||||
/**
|
||||
* Number of workflows registered/updated in database
|
||||
*/
|
||||
registered_count: number;
|
||||
/**
|
||||
* Individual workflow registration results
|
||||
*/
|
||||
workflows: Array<WorkflowSyncResult>;
|
||||
};
|
||||
/**
|
||||
* Optional message
|
||||
*/
|
||||
message?: string | null;
|
||||
}> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/api/v1/packs/{ref}/workflows/sync',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
404: `Pack not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Validate workflows for a pack without syncing
|
||||
* @returns any Workflows validated
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static validatePackWorkflows({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Pack reference identifier
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<{
|
||||
/**
|
||||
* Response for pack workflow validation operation
|
||||
*/
|
||||
data: {
|
||||
/**
|
||||
* Number of workflows with errors
|
||||
*/
|
||||
error_count: number;
|
||||
/**
|
||||
* Validation errors by workflow reference
|
||||
*/
|
||||
errors: Record<string, Array<string>>;
|
||||
/**
|
||||
* Pack reference
|
||||
*/
|
||||
pack_ref: string;
|
||||
/**
|
||||
* Number of workflows validated
|
||||
*/
|
||||
validated_count: number;
|
||||
};
|
||||
/**
|
||||
* Optional message
|
||||
*/
|
||||
message?: string | null;
|
||||
}> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/api/v1/packs/{ref}/workflows/validate',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
404: `Pack not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
344
web/src/api/services/RulesService.ts
Normal file
344
web/src/api/services/RulesService.ts
Normal file
@@ -0,0 +1,344 @@
|
||||
/* generated using openapi-typescript-codegen -- do not edit */
|
||||
/* istanbul ignore file */
|
||||
/* tslint:disable */
|
||||
/* eslint-disable */
|
||||
import type { ApiResponse_RuleResponse } from '../models/ApiResponse_RuleResponse';
|
||||
import type { CreateRuleRequest } from '../models/CreateRuleRequest';
|
||||
import type { PaginatedResponse_RuleSummary } from '../models/PaginatedResponse_RuleSummary';
|
||||
import type { SuccessResponse } from '../models/SuccessResponse';
|
||||
import type { UpdateRuleRequest } from '../models/UpdateRuleRequest';
|
||||
import type { CancelablePromise } from '../core/CancelablePromise';
|
||||
import { OpenAPI } from '../core/OpenAPI';
|
||||
import { request as __request } from '../core/request';
|
||||
export class RulesService {
|
||||
/**
|
||||
* List rules by action reference
|
||||
* @returns PaginatedResponse_RuleSummary List of rules using this action
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static listRulesByAction({
|
||||
actionRef,
|
||||
page,
|
||||
pageSize,
|
||||
}: {
|
||||
/**
|
||||
* Action reference
|
||||
*/
|
||||
actionRef: string,
|
||||
/**
|
||||
* Page number (1-based)
|
||||
*/
|
||||
page?: number,
|
||||
/**
|
||||
* Number of items per page
|
||||
*/
|
||||
pageSize?: number,
|
||||
}): CancelablePromise<PaginatedResponse_RuleSummary> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/actions/{action_ref}/rules',
|
||||
path: {
|
||||
'action_ref': actionRef,
|
||||
},
|
||||
query: {
|
||||
'page': page,
|
||||
'page_size': pageSize,
|
||||
},
|
||||
errors: {
|
||||
404: `Action not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* List rules by pack reference
|
||||
* @returns PaginatedResponse_RuleSummary List of rules in pack
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static listRulesByPack({
|
||||
packRef,
|
||||
page,
|
||||
pageSize,
|
||||
}: {
|
||||
/**
|
||||
* Pack reference
|
||||
*/
|
||||
packRef: string,
|
||||
/**
|
||||
* Page number (1-based)
|
||||
*/
|
||||
page?: number,
|
||||
/**
|
||||
* Number of items per page
|
||||
*/
|
||||
pageSize?: number,
|
||||
}): CancelablePromise<PaginatedResponse_RuleSummary> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/packs/{pack_ref}/rules',
|
||||
path: {
|
||||
'pack_ref': packRef,
|
||||
},
|
||||
query: {
|
||||
'page': page,
|
||||
'page_size': pageSize,
|
||||
},
|
||||
errors: {
|
||||
404: `Pack not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* List all rules with pagination
|
||||
* @returns PaginatedResponse_RuleSummary List of rules
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static listRules({
|
||||
page,
|
||||
pageSize,
|
||||
}: {
|
||||
/**
|
||||
* Page number (1-based)
|
||||
*/
|
||||
page?: number,
|
||||
/**
|
||||
* Number of items per page
|
||||
*/
|
||||
pageSize?: number,
|
||||
}): CancelablePromise<PaginatedResponse_RuleSummary> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/rules',
|
||||
query: {
|
||||
'page': page,
|
||||
'page_size': pageSize,
|
||||
},
|
||||
errors: {
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Create a new rule
|
||||
* @returns ApiResponse_RuleResponse Rule created successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static createRule({
|
||||
requestBody,
|
||||
}: {
|
||||
requestBody: CreateRuleRequest,
|
||||
}): CancelablePromise<ApiResponse_RuleResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/api/v1/rules',
|
||||
body: requestBody,
|
||||
mediaType: 'application/json',
|
||||
errors: {
|
||||
400: `Invalid request`,
|
||||
404: `Pack, action, or trigger not found`,
|
||||
409: `Rule with same ref already exists`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* List enabled rules
|
||||
* @returns PaginatedResponse_RuleSummary List of enabled rules
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static listEnabledRules({
|
||||
page,
|
||||
pageSize,
|
||||
}: {
|
||||
/**
|
||||
* Page number (1-based)
|
||||
*/
|
||||
page?: number,
|
||||
/**
|
||||
* Number of items per page
|
||||
*/
|
||||
pageSize?: number,
|
||||
}): CancelablePromise<PaginatedResponse_RuleSummary> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/rules/enabled',
|
||||
query: {
|
||||
'page': page,
|
||||
'page_size': pageSize,
|
||||
},
|
||||
errors: {
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Get a single rule by reference
|
||||
* @returns ApiResponse_RuleResponse Rule details
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static getRule({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Rule reference
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<ApiResponse_RuleResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/rules/{ref}',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
404: `Rule not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Update an existing rule
|
||||
* @returns ApiResponse_RuleResponse Rule updated successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static updateRule({
|
||||
ref,
|
||||
requestBody,
|
||||
}: {
|
||||
/**
|
||||
* Rule reference
|
||||
*/
|
||||
ref: string,
|
||||
requestBody: UpdateRuleRequest,
|
||||
}): CancelablePromise<ApiResponse_RuleResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'PUT',
|
||||
url: '/api/v1/rules/{ref}',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
body: requestBody,
|
||||
mediaType: 'application/json',
|
||||
errors: {
|
||||
400: `Invalid request`,
|
||||
404: `Rule not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Delete a rule
|
||||
* @returns SuccessResponse Rule deleted successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static deleteRule({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Rule reference
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<SuccessResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'DELETE',
|
||||
url: '/api/v1/rules/{ref}',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
404: `Rule not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Disable a rule
|
||||
* @returns ApiResponse_RuleResponse Rule disabled successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static disableRule({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Rule reference
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<ApiResponse_RuleResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/api/v1/rules/{ref}/disable',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
404: `Rule not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Enable a rule
|
||||
* @returns ApiResponse_RuleResponse Rule enabled successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static enableRule({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Rule reference
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<ApiResponse_RuleResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/api/v1/rules/{ref}/enable',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
404: `Rule not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* List rules by trigger reference
|
||||
* @returns PaginatedResponse_RuleSummary List of rules using this trigger
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static listRulesByTrigger({
|
||||
triggerRef,
|
||||
page,
|
||||
pageSize,
|
||||
}: {
|
||||
/**
|
||||
* Trigger reference
|
||||
*/
|
||||
triggerRef: string,
|
||||
/**
|
||||
* Page number (1-based)
|
||||
*/
|
||||
page?: number,
|
||||
/**
|
||||
* Number of items per page
|
||||
*/
|
||||
pageSize?: number,
|
||||
}): CancelablePromise<PaginatedResponse_RuleSummary> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/triggers/{trigger_ref}/rules',
|
||||
path: {
|
||||
'trigger_ref': triggerRef,
|
||||
},
|
||||
query: {
|
||||
'page': page,
|
||||
'page_size': pageSize,
|
||||
},
|
||||
errors: {
|
||||
404: `Trigger not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
338
web/src/api/services/SecretsService.ts
Normal file
338
web/src/api/services/SecretsService.ts
Normal file
@@ -0,0 +1,338 @@
|
||||
/* generated using openapi-typescript-codegen -- do not edit */
|
||||
/* istanbul ignore file */
|
||||
/* tslint:disable */
|
||||
/* eslint-disable */
|
||||
import type { CreateKeyRequest } from '../models/CreateKeyRequest';
|
||||
import type { i64 } from '../models/i64';
|
||||
import type { OwnerType } from '../models/OwnerType';
|
||||
import type { PaginatedResponse_KeySummary } from '../models/PaginatedResponse_KeySummary';
|
||||
import type { SuccessResponse } from '../models/SuccessResponse';
|
||||
import type { UpdateKeyRequest } from '../models/UpdateKeyRequest';
|
||||
import type { CancelablePromise } from '../core/CancelablePromise';
|
||||
import { OpenAPI } from '../core/OpenAPI';
|
||||
import { request as __request } from '../core/request';
|
||||
export class SecretsService {
|
||||
/**
|
||||
* List all keys with pagination and optional filters (values redacted)
|
||||
* @returns PaginatedResponse_KeySummary List of keys (values redacted)
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static listKeys({
|
||||
ownerType,
|
||||
owner,
|
||||
page,
|
||||
perPage,
|
||||
}: {
|
||||
/**
|
||||
* Filter by owner type
|
||||
*/
|
||||
ownerType?: (null | OwnerType),
|
||||
/**
|
||||
* Filter by owner string
|
||||
*/
|
||||
owner?: string | null,
|
||||
/**
|
||||
* Page number (1-indexed)
|
||||
*/
|
||||
page?: number,
|
||||
/**
|
||||
* Items per page
|
||||
*/
|
||||
perPage?: number,
|
||||
}): CancelablePromise<PaginatedResponse_KeySummary> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/keys',
|
||||
query: {
|
||||
'owner_type': ownerType,
|
||||
'owner': owner,
|
||||
'page': page,
|
||||
'per_page': perPage,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Create a new key/secret
|
||||
* @returns any Key created successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static createKey({
|
||||
requestBody,
|
||||
}: {
|
||||
requestBody: CreateKeyRequest,
|
||||
}): CancelablePromise<{
|
||||
/**
|
||||
* Full key response with all details (value redacted in list views)
|
||||
*/
|
||||
data: {
|
||||
/**
|
||||
* Creation timestamp
|
||||
*/
|
||||
created: string;
|
||||
/**
|
||||
* Whether the value is encrypted
|
||||
*/
|
||||
encrypted: boolean;
|
||||
/**
|
||||
* Unique key ID
|
||||
*/
|
||||
id: i64;
|
||||
/**
|
||||
* Human-readable name
|
||||
*/
|
||||
name: string;
|
||||
/**
|
||||
* Owner identifier
|
||||
*/
|
||||
owner?: string | null;
|
||||
owner_action?: (null | i64);
|
||||
/**
|
||||
* Owner action reference
|
||||
*/
|
||||
owner_action_ref?: string | null;
|
||||
owner_identity?: (null | i64);
|
||||
owner_pack?: (null | i64);
|
||||
/**
|
||||
* Owner pack reference
|
||||
*/
|
||||
owner_pack_ref?: string | null;
|
||||
owner_sensor?: (null | i64);
|
||||
/**
|
||||
* Owner sensor reference
|
||||
*/
|
||||
owner_sensor_ref?: string | null;
|
||||
/**
|
||||
* Type of owner
|
||||
*/
|
||||
owner_type: OwnerType;
|
||||
/**
|
||||
* Unique reference identifier
|
||||
*/
|
||||
ref: string;
|
||||
/**
|
||||
* Last update timestamp
|
||||
*/
|
||||
updated: string;
|
||||
/**
|
||||
* The secret value (decrypted if encrypted)
|
||||
*/
|
||||
value: string;
|
||||
};
|
||||
/**
|
||||
* Optional message
|
||||
*/
|
||||
message?: string | null;
|
||||
}> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/api/v1/keys',
|
||||
body: requestBody,
|
||||
mediaType: 'application/json',
|
||||
errors: {
|
||||
400: `Validation error`,
|
||||
409: `Key with same ref already exists`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Get a single key by reference (includes decrypted value)
|
||||
* @returns any Key details with decrypted value
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static getKey({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Key reference identifier
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<{
|
||||
/**
|
||||
* Full key response with all details (value redacted in list views)
|
||||
*/
|
||||
data: {
|
||||
/**
|
||||
* Creation timestamp
|
||||
*/
|
||||
created: string;
|
||||
/**
|
||||
* Whether the value is encrypted
|
||||
*/
|
||||
encrypted: boolean;
|
||||
/**
|
||||
* Unique key ID
|
||||
*/
|
||||
id: i64;
|
||||
/**
|
||||
* Human-readable name
|
||||
*/
|
||||
name: string;
|
||||
/**
|
||||
* Owner identifier
|
||||
*/
|
||||
owner?: string | null;
|
||||
owner_action?: (null | i64);
|
||||
/**
|
||||
* Owner action reference
|
||||
*/
|
||||
owner_action_ref?: string | null;
|
||||
owner_identity?: (null | i64);
|
||||
owner_pack?: (null | i64);
|
||||
/**
|
||||
* Owner pack reference
|
||||
*/
|
||||
owner_pack_ref?: string | null;
|
||||
owner_sensor?: (null | i64);
|
||||
/**
|
||||
* Owner sensor reference
|
||||
*/
|
||||
owner_sensor_ref?: string | null;
|
||||
/**
|
||||
* Type of owner
|
||||
*/
|
||||
owner_type: OwnerType;
|
||||
/**
|
||||
* Unique reference identifier
|
||||
*/
|
||||
ref: string;
|
||||
/**
|
||||
* Last update timestamp
|
||||
*/
|
||||
updated: string;
|
||||
/**
|
||||
* The secret value (decrypted if encrypted)
|
||||
*/
|
||||
value: string;
|
||||
};
|
||||
/**
|
||||
* Optional message
|
||||
*/
|
||||
message?: string | null;
|
||||
}> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/keys/{ref}',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
404: `Key not found`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Update an existing key/secret
|
||||
* @returns any Key updated successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static updateKey({
|
||||
ref,
|
||||
requestBody,
|
||||
}: {
|
||||
/**
|
||||
* Key reference identifier
|
||||
*/
|
||||
ref: string,
|
||||
requestBody: UpdateKeyRequest,
|
||||
}): CancelablePromise<{
|
||||
/**
|
||||
* Full key response with all details (value redacted in list views)
|
||||
*/
|
||||
data: {
|
||||
/**
|
||||
* Creation timestamp
|
||||
*/
|
||||
created: string;
|
||||
/**
|
||||
* Whether the value is encrypted
|
||||
*/
|
||||
encrypted: boolean;
|
||||
/**
|
||||
* Unique key ID
|
||||
*/
|
||||
id: i64;
|
||||
/**
|
||||
* Human-readable name
|
||||
*/
|
||||
name: string;
|
||||
/**
|
||||
* Owner identifier
|
||||
*/
|
||||
owner?: string | null;
|
||||
owner_action?: (null | i64);
|
||||
/**
|
||||
* Owner action reference
|
||||
*/
|
||||
owner_action_ref?: string | null;
|
||||
owner_identity?: (null | i64);
|
||||
owner_pack?: (null | i64);
|
||||
/**
|
||||
* Owner pack reference
|
||||
*/
|
||||
owner_pack_ref?: string | null;
|
||||
owner_sensor?: (null | i64);
|
||||
/**
|
||||
* Owner sensor reference
|
||||
*/
|
||||
owner_sensor_ref?: string | null;
|
||||
/**
|
||||
* Type of owner
|
||||
*/
|
||||
owner_type: OwnerType;
|
||||
/**
|
||||
* Unique reference identifier
|
||||
*/
|
||||
ref: string;
|
||||
/**
|
||||
* Last update timestamp
|
||||
*/
|
||||
updated: string;
|
||||
/**
|
||||
* The secret value (decrypted if encrypted)
|
||||
*/
|
||||
value: string;
|
||||
};
|
||||
/**
|
||||
* Optional message
|
||||
*/
|
||||
message?: string | null;
|
||||
}> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'PUT',
|
||||
url: '/api/v1/keys/{ref}',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
body: requestBody,
|
||||
mediaType: 'application/json',
|
||||
errors: {
|
||||
400: `Validation error`,
|
||||
404: `Key not found`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Delete a key/secret
|
||||
* @returns SuccessResponse Key deleted successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static deleteKey({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Key reference identifier
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<SuccessResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'DELETE',
|
||||
url: '/api/v1/keys/{ref}',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
404: `Key not found`,
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
305
web/src/api/services/SensorsService.ts
Normal file
305
web/src/api/services/SensorsService.ts
Normal file
@@ -0,0 +1,305 @@
|
||||
/* generated using openapi-typescript-codegen -- do not edit */
|
||||
/* istanbul ignore file */
|
||||
/* tslint:disable */
|
||||
/* eslint-disable */
|
||||
import type { ApiResponse_SensorResponse } from '../models/ApiResponse_SensorResponse';
|
||||
import type { CreateSensorRequest } from '../models/CreateSensorRequest';
|
||||
import type { PaginatedResponse_SensorSummary } from '../models/PaginatedResponse_SensorSummary';
|
||||
import type { SuccessResponse } from '../models/SuccessResponse';
|
||||
import type { UpdateSensorRequest } from '../models/UpdateSensorRequest';
|
||||
import type { CancelablePromise } from '../core/CancelablePromise';
|
||||
import { OpenAPI } from '../core/OpenAPI';
|
||||
import { request as __request } from '../core/request';
|
||||
export class SensorsService {
|
||||
/**
|
||||
* List sensors by pack reference
|
||||
* @returns PaginatedResponse_SensorSummary List of sensors in pack
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static listSensorsByPack({
|
||||
packRef,
|
||||
page,
|
||||
pageSize,
|
||||
}: {
|
||||
/**
|
||||
* Pack reference
|
||||
*/
|
||||
packRef: string,
|
||||
/**
|
||||
* Page number (1-based)
|
||||
*/
|
||||
page?: number,
|
||||
/**
|
||||
* Number of items per page
|
||||
*/
|
||||
pageSize?: number,
|
||||
}): CancelablePromise<PaginatedResponse_SensorSummary> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/packs/{pack_ref}/sensors',
|
||||
path: {
|
||||
'pack_ref': packRef,
|
||||
},
|
||||
query: {
|
||||
'page': page,
|
||||
'page_size': pageSize,
|
||||
},
|
||||
errors: {
|
||||
404: `Pack not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* List all sensors with pagination
|
||||
* @returns PaginatedResponse_SensorSummary List of sensors
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static listSensors({
|
||||
page,
|
||||
pageSize,
|
||||
}: {
|
||||
/**
|
||||
* Page number (1-based)
|
||||
*/
|
||||
page?: number,
|
||||
/**
|
||||
* Number of items per page
|
||||
*/
|
||||
pageSize?: number,
|
||||
}): CancelablePromise<PaginatedResponse_SensorSummary> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/sensors',
|
||||
query: {
|
||||
'page': page,
|
||||
'page_size': pageSize,
|
||||
},
|
||||
errors: {
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Create a new sensor
|
||||
* @returns ApiResponse_SensorResponse Sensor created successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static createSensor({
|
||||
requestBody,
|
||||
}: {
|
||||
requestBody: CreateSensorRequest,
|
||||
}): CancelablePromise<ApiResponse_SensorResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/api/v1/sensors',
|
||||
body: requestBody,
|
||||
mediaType: 'application/json',
|
||||
errors: {
|
||||
400: `Invalid request`,
|
||||
404: `Pack, runtime, or trigger not found`,
|
||||
409: `Sensor with same ref already exists`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* List enabled sensors
|
||||
* @returns PaginatedResponse_SensorSummary List of enabled sensors
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static listEnabledSensors({
|
||||
page,
|
||||
pageSize,
|
||||
}: {
|
||||
/**
|
||||
* Page number (1-based)
|
||||
*/
|
||||
page?: number,
|
||||
/**
|
||||
* Number of items per page
|
||||
*/
|
||||
pageSize?: number,
|
||||
}): CancelablePromise<PaginatedResponse_SensorSummary> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/sensors/enabled',
|
||||
query: {
|
||||
'page': page,
|
||||
'page_size': pageSize,
|
||||
},
|
||||
errors: {
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Get a single sensor by reference
|
||||
* @returns ApiResponse_SensorResponse Sensor details
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static getSensor({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Sensor reference
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<ApiResponse_SensorResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/sensors/{ref}',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
404: `Sensor not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Update an existing sensor
|
||||
* @returns ApiResponse_SensorResponse Sensor updated successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static updateSensor({
|
||||
ref,
|
||||
requestBody,
|
||||
}: {
|
||||
/**
|
||||
* Sensor reference
|
||||
*/
|
||||
ref: string,
|
||||
requestBody: UpdateSensorRequest,
|
||||
}): CancelablePromise<ApiResponse_SensorResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'PUT',
|
||||
url: '/api/v1/sensors/{ref}',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
body: requestBody,
|
||||
mediaType: 'application/json',
|
||||
errors: {
|
||||
400: `Invalid request`,
|
||||
404: `Sensor not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Delete a sensor
|
||||
* @returns SuccessResponse Sensor deleted successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static deleteSensor({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Sensor reference
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<SuccessResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'DELETE',
|
||||
url: '/api/v1/sensors/{ref}',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
404: `Sensor not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Disable a sensor
|
||||
* @returns ApiResponse_SensorResponse Sensor disabled successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static disableSensor({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Sensor reference
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<ApiResponse_SensorResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/api/v1/sensors/{ref}/disable',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
404: `Sensor not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Enable a sensor
|
||||
* @returns ApiResponse_SensorResponse Sensor enabled successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static enableSensor({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Sensor reference
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<ApiResponse_SensorResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/api/v1/sensors/{ref}/enable',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
404: `Sensor not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* List sensors by trigger reference
|
||||
* @returns PaginatedResponse_SensorSummary List of sensors for trigger
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static listSensorsByTrigger({
|
||||
triggerRef,
|
||||
page,
|
||||
pageSize,
|
||||
}: {
|
||||
/**
|
||||
* Trigger reference
|
||||
*/
|
||||
triggerRef: string,
|
||||
/**
|
||||
* Page number (1-based)
|
||||
*/
|
||||
page?: number,
|
||||
/**
|
||||
* Number of items per page
|
||||
*/
|
||||
pageSize?: number,
|
||||
}): CancelablePromise<PaginatedResponse_SensorSummary> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/triggers/{trigger_ref}/sensors',
|
||||
path: {
|
||||
'trigger_ref': triggerRef,
|
||||
},
|
||||
query: {
|
||||
'page': page,
|
||||
'page_size': pageSize,
|
||||
},
|
||||
errors: {
|
||||
404: `Trigger not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
266
web/src/api/services/TriggersService.ts
Normal file
266
web/src/api/services/TriggersService.ts
Normal file
@@ -0,0 +1,266 @@
|
||||
/* generated using openapi-typescript-codegen -- do not edit */
|
||||
/* istanbul ignore file */
|
||||
/* tslint:disable */
|
||||
/* eslint-disable */
|
||||
import type { ApiResponse_TriggerResponse } from '../models/ApiResponse_TriggerResponse';
|
||||
import type { CreateTriggerRequest } from '../models/CreateTriggerRequest';
|
||||
import type { PaginatedResponse_TriggerSummary } from '../models/PaginatedResponse_TriggerSummary';
|
||||
import type { SuccessResponse } from '../models/SuccessResponse';
|
||||
import type { UpdateTriggerRequest } from '../models/UpdateTriggerRequest';
|
||||
import type { CancelablePromise } from '../core/CancelablePromise';
|
||||
import { OpenAPI } from '../core/OpenAPI';
|
||||
import { request as __request } from '../core/request';
|
||||
export class TriggersService {
|
||||
/**
|
||||
* List triggers by pack reference
|
||||
* @returns PaginatedResponse_TriggerSummary List of triggers in pack
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static listTriggersByPack({
|
||||
packRef,
|
||||
page,
|
||||
pageSize,
|
||||
}: {
|
||||
/**
|
||||
* Pack reference
|
||||
*/
|
||||
packRef: string,
|
||||
/**
|
||||
* Page number (1-based)
|
||||
*/
|
||||
page?: number,
|
||||
/**
|
||||
* Number of items per page
|
||||
*/
|
||||
pageSize?: number,
|
||||
}): CancelablePromise<PaginatedResponse_TriggerSummary> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/packs/{pack_ref}/triggers',
|
||||
path: {
|
||||
'pack_ref': packRef,
|
||||
},
|
||||
query: {
|
||||
'page': page,
|
||||
'page_size': pageSize,
|
||||
},
|
||||
errors: {
|
||||
404: `Pack not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* List all triggers with pagination
|
||||
* @returns PaginatedResponse_TriggerSummary List of triggers
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static listTriggers({
|
||||
page,
|
||||
pageSize,
|
||||
}: {
|
||||
/**
|
||||
* Page number (1-based)
|
||||
*/
|
||||
page?: number,
|
||||
/**
|
||||
* Number of items per page
|
||||
*/
|
||||
pageSize?: number,
|
||||
}): CancelablePromise<PaginatedResponse_TriggerSummary> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/triggers',
|
||||
query: {
|
||||
'page': page,
|
||||
'page_size': pageSize,
|
||||
},
|
||||
errors: {
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Create a new trigger
|
||||
* @returns ApiResponse_TriggerResponse Trigger created successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static createTrigger({
|
||||
requestBody,
|
||||
}: {
|
||||
requestBody: CreateTriggerRequest,
|
||||
}): CancelablePromise<ApiResponse_TriggerResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/api/v1/triggers',
|
||||
body: requestBody,
|
||||
mediaType: 'application/json',
|
||||
errors: {
|
||||
400: `Invalid request`,
|
||||
404: `Pack not found`,
|
||||
409: `Trigger with same ref already exists`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* List enabled triggers
|
||||
* @returns PaginatedResponse_TriggerSummary List of enabled triggers
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static listEnabledTriggers({
|
||||
page,
|
||||
pageSize,
|
||||
}: {
|
||||
/**
|
||||
* Page number (1-based)
|
||||
*/
|
||||
page?: number,
|
||||
/**
|
||||
* Number of items per page
|
||||
*/
|
||||
pageSize?: number,
|
||||
}): CancelablePromise<PaginatedResponse_TriggerSummary> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/triggers/enabled',
|
||||
query: {
|
||||
'page': page,
|
||||
'page_size': pageSize,
|
||||
},
|
||||
errors: {
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Get a single trigger by reference
|
||||
* @returns ApiResponse_TriggerResponse Trigger details
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static getTrigger({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Trigger reference
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<ApiResponse_TriggerResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/triggers/{ref}',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
404: `Trigger not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Update an existing trigger
|
||||
* @returns ApiResponse_TriggerResponse Trigger updated successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static updateTrigger({
|
||||
ref,
|
||||
requestBody,
|
||||
}: {
|
||||
/**
|
||||
* Trigger reference
|
||||
*/
|
||||
ref: string,
|
||||
requestBody: UpdateTriggerRequest,
|
||||
}): CancelablePromise<ApiResponse_TriggerResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'PUT',
|
||||
url: '/api/v1/triggers/{ref}',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
body: requestBody,
|
||||
mediaType: 'application/json',
|
||||
errors: {
|
||||
400: `Invalid request`,
|
||||
404: `Trigger not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Delete a trigger
|
||||
* @returns SuccessResponse Trigger deleted successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static deleteTrigger({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Trigger reference
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<SuccessResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'DELETE',
|
||||
url: '/api/v1/triggers/{ref}',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
404: `Trigger not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Disable a trigger
|
||||
* @returns ApiResponse_TriggerResponse Trigger disabled successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static disableTrigger({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Trigger reference
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<ApiResponse_TriggerResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/api/v1/triggers/{ref}/disable',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
404: `Trigger not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Enable a trigger
|
||||
* @returns ApiResponse_TriggerResponse Trigger enabled successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static enableTrigger({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Trigger reference
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<ApiResponse_TriggerResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/api/v1/triggers/{ref}/enable',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
404: `Trigger not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
118
web/src/api/services/WebhooksService.ts
Normal file
118
web/src/api/services/WebhooksService.ts
Normal file
@@ -0,0 +1,118 @@
|
||||
/* generated using openapi-typescript-codegen -- do not edit */
|
||||
/* istanbul ignore file */
|
||||
/* tslint:disable */
|
||||
/* eslint-disable */
|
||||
import type { TriggerResponse } from '../models/TriggerResponse';
|
||||
import type { WebhookReceiverRequest } from '../models/WebhookReceiverRequest';
|
||||
import type { WebhookReceiverResponse } from '../models/WebhookReceiverResponse';
|
||||
import type { CancelablePromise } from '../core/CancelablePromise';
|
||||
import { OpenAPI } from '../core/OpenAPI';
|
||||
import { request as __request } from '../core/request';
|
||||
export class WebhooksService {
|
||||
/**
|
||||
* Disable webhooks for a trigger
|
||||
* @returns TriggerResponse Webhooks disabled
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static disableWebhook({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Trigger reference (pack.name)
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<TriggerResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/api/v1/triggers/{ref}/webhooks/disable',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
404: `Trigger not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Enable webhooks for a trigger
|
||||
* @returns TriggerResponse Webhooks enabled
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static enableWebhook({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Trigger reference (pack.name)
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<TriggerResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/api/v1/triggers/{ref}/webhooks/enable',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
404: `Trigger not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Regenerate webhook key for a trigger
|
||||
* @returns TriggerResponse Webhook key regenerated
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static regenerateWebhookKey({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Trigger reference (pack.name)
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<TriggerResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/api/v1/triggers/{ref}/webhooks/regenerate',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
400: `Webhooks not enabled for this trigger`,
|
||||
404: `Trigger not found`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Webhook receiver endpoint - receives webhook events and creates events
|
||||
* @returns WebhookReceiverResponse Webhook received and event created
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static receiveWebhook({
|
||||
webhookKey,
|
||||
requestBody,
|
||||
}: {
|
||||
/**
|
||||
* Webhook key
|
||||
*/
|
||||
webhookKey: string,
|
||||
requestBody: WebhookReceiverRequest,
|
||||
}): CancelablePromise<WebhookReceiverResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/api/v1/webhooks/{webhook_key}',
|
||||
path: {
|
||||
'webhook_key': webhookKey,
|
||||
},
|
||||
body: requestBody,
|
||||
mediaType: 'application/json',
|
||||
errors: {
|
||||
404: `Invalid webhook key`,
|
||||
429: `Rate limit exceeded`,
|
||||
500: `Internal server error`,
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
399
web/src/api/services/WorkflowsService.ts
Normal file
399
web/src/api/services/WorkflowsService.ts
Normal file
@@ -0,0 +1,399 @@
|
||||
/* generated using openapi-typescript-codegen -- do not edit */
|
||||
/* istanbul ignore file */
|
||||
/* tslint:disable */
|
||||
/* eslint-disable */
|
||||
import type { CreateWorkflowRequest } from '../models/CreateWorkflowRequest';
|
||||
import type { PaginatedResponse_WorkflowSummary } from '../models/PaginatedResponse_WorkflowSummary';
|
||||
import type { SuccessResponse } from '../models/SuccessResponse';
|
||||
import type { UpdateWorkflowRequest } from '../models/UpdateWorkflowRequest';
|
||||
import type { CancelablePromise } from '../core/CancelablePromise';
|
||||
import { OpenAPI } from '../core/OpenAPI';
|
||||
import { request as __request } from '../core/request';
|
||||
export class WorkflowsService {
|
||||
/**
|
||||
* List workflows by pack reference
|
||||
* @returns PaginatedResponse_WorkflowSummary List of workflows for pack
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static listWorkflowsByPack({
|
||||
packRef,
|
||||
page,
|
||||
pageSize,
|
||||
}: {
|
||||
/**
|
||||
* Pack reference identifier
|
||||
*/
|
||||
packRef: string,
|
||||
/**
|
||||
* Page number (1-based)
|
||||
*/
|
||||
page?: number,
|
||||
/**
|
||||
* Number of items per page
|
||||
*/
|
||||
pageSize?: number,
|
||||
}): CancelablePromise<PaginatedResponse_WorkflowSummary> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/packs/{pack_ref}/workflows',
|
||||
path: {
|
||||
'pack_ref': packRef,
|
||||
},
|
||||
query: {
|
||||
'page': page,
|
||||
'page_size': pageSize,
|
||||
},
|
||||
errors: {
|
||||
404: `Pack not found`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* List all workflows with pagination and filtering
|
||||
* @returns PaginatedResponse_WorkflowSummary List of workflows
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static listWorkflows({
|
||||
page,
|
||||
pageSize,
|
||||
tags,
|
||||
enabled,
|
||||
search,
|
||||
packRef,
|
||||
}: {
|
||||
/**
|
||||
* Page number (1-based)
|
||||
*/
|
||||
page?: number,
|
||||
/**
|
||||
* Number of items per page
|
||||
*/
|
||||
pageSize?: number,
|
||||
/**
|
||||
* Filter by tag(s) - comma-separated list
|
||||
*/
|
||||
tags?: string | null,
|
||||
/**
|
||||
* Filter by enabled status
|
||||
*/
|
||||
enabled?: boolean | null,
|
||||
/**
|
||||
* Search term for label/description (case-insensitive)
|
||||
*/
|
||||
search?: string | null,
|
||||
/**
|
||||
* Filter by pack reference
|
||||
*/
|
||||
packRef?: string | null,
|
||||
}): CancelablePromise<PaginatedResponse_WorkflowSummary> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/workflows',
|
||||
query: {
|
||||
'page': page,
|
||||
'page_size': pageSize,
|
||||
'tags': tags,
|
||||
'enabled': enabled,
|
||||
'search': search,
|
||||
'pack_ref': packRef,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Create a new workflow
|
||||
* @returns any Workflow created successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static createWorkflow({
|
||||
requestBody,
|
||||
}: {
|
||||
requestBody: CreateWorkflowRequest,
|
||||
}): CancelablePromise<{
|
||||
/**
|
||||
* Response DTO for workflow information
|
||||
*/
|
||||
data: {
|
||||
/**
|
||||
* Creation timestamp
|
||||
*/
|
||||
created: string;
|
||||
/**
|
||||
* Workflow definition
|
||||
*/
|
||||
definition: Record<string, any>;
|
||||
/**
|
||||
* Workflow description
|
||||
*/
|
||||
description?: string | null;
|
||||
/**
|
||||
* Whether the workflow is enabled
|
||||
*/
|
||||
enabled: boolean;
|
||||
/**
|
||||
* Workflow ID
|
||||
*/
|
||||
id: number;
|
||||
/**
|
||||
* Human-readable label
|
||||
*/
|
||||
label: string;
|
||||
/**
|
||||
* Output schema
|
||||
*/
|
||||
out_schema: any | null;
|
||||
/**
|
||||
* Pack ID
|
||||
*/
|
||||
pack: number;
|
||||
/**
|
||||
* Pack reference
|
||||
*/
|
||||
pack_ref: string;
|
||||
/**
|
||||
* Parameter schema
|
||||
*/
|
||||
param_schema: any | null;
|
||||
/**
|
||||
* Unique reference identifier
|
||||
*/
|
||||
ref: string;
|
||||
/**
|
||||
* Tags
|
||||
*/
|
||||
tags: Array<string>;
|
||||
/**
|
||||
* Last update timestamp
|
||||
*/
|
||||
updated: string;
|
||||
/**
|
||||
* Workflow version
|
||||
*/
|
||||
version: string;
|
||||
};
|
||||
/**
|
||||
* Optional message
|
||||
*/
|
||||
message?: string | null;
|
||||
}> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'POST',
|
||||
url: '/api/v1/workflows',
|
||||
body: requestBody,
|
||||
mediaType: 'application/json',
|
||||
errors: {
|
||||
400: `Validation error`,
|
||||
404: `Pack not found`,
|
||||
409: `Workflow with same ref already exists`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Get a single workflow by reference
|
||||
* @returns any Workflow details
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static getWorkflow({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Workflow reference identifier
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<{
|
||||
/**
|
||||
* Response DTO for workflow information
|
||||
*/
|
||||
data: {
|
||||
/**
|
||||
* Creation timestamp
|
||||
*/
|
||||
created: string;
|
||||
/**
|
||||
* Workflow definition
|
||||
*/
|
||||
definition: Record<string, any>;
|
||||
/**
|
||||
* Workflow description
|
||||
*/
|
||||
description?: string | null;
|
||||
/**
|
||||
* Whether the workflow is enabled
|
||||
*/
|
||||
enabled: boolean;
|
||||
/**
|
||||
* Workflow ID
|
||||
*/
|
||||
id: number;
|
||||
/**
|
||||
* Human-readable label
|
||||
*/
|
||||
label: string;
|
||||
/**
|
||||
* Output schema
|
||||
*/
|
||||
out_schema: any | null;
|
||||
/**
|
||||
* Pack ID
|
||||
*/
|
||||
pack: number;
|
||||
/**
|
||||
* Pack reference
|
||||
*/
|
||||
pack_ref: string;
|
||||
/**
|
||||
* Parameter schema
|
||||
*/
|
||||
param_schema: any | null;
|
||||
/**
|
||||
* Unique reference identifier
|
||||
*/
|
||||
ref: string;
|
||||
/**
|
||||
* Tags
|
||||
*/
|
||||
tags: Array<string>;
|
||||
/**
|
||||
* Last update timestamp
|
||||
*/
|
||||
updated: string;
|
||||
/**
|
||||
* Workflow version
|
||||
*/
|
||||
version: string;
|
||||
};
|
||||
/**
|
||||
* Optional message
|
||||
*/
|
||||
message?: string | null;
|
||||
}> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'GET',
|
||||
url: '/api/v1/workflows/{ref}',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
404: `Workflow not found`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Update an existing workflow
|
||||
* @returns any Workflow updated successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static updateWorkflow({
|
||||
ref,
|
||||
requestBody,
|
||||
}: {
|
||||
/**
|
||||
* Workflow reference identifier
|
||||
*/
|
||||
ref: string,
|
||||
requestBody: UpdateWorkflowRequest,
|
||||
}): CancelablePromise<{
|
||||
/**
|
||||
* Response DTO for workflow information
|
||||
*/
|
||||
data: {
|
||||
/**
|
||||
* Creation timestamp
|
||||
*/
|
||||
created: string;
|
||||
/**
|
||||
* Workflow definition
|
||||
*/
|
||||
definition: Record<string, any>;
|
||||
/**
|
||||
* Workflow description
|
||||
*/
|
||||
description?: string | null;
|
||||
/**
|
||||
* Whether the workflow is enabled
|
||||
*/
|
||||
enabled: boolean;
|
||||
/**
|
||||
* Workflow ID
|
||||
*/
|
||||
id: number;
|
||||
/**
|
||||
* Human-readable label
|
||||
*/
|
||||
label: string;
|
||||
/**
|
||||
* Output schema
|
||||
*/
|
||||
out_schema: any | null;
|
||||
/**
|
||||
* Pack ID
|
||||
*/
|
||||
pack: number;
|
||||
/**
|
||||
* Pack reference
|
||||
*/
|
||||
pack_ref: string;
|
||||
/**
|
||||
* Parameter schema
|
||||
*/
|
||||
param_schema: any | null;
|
||||
/**
|
||||
* Unique reference identifier
|
||||
*/
|
||||
ref: string;
|
||||
/**
|
||||
* Tags
|
||||
*/
|
||||
tags: Array<string>;
|
||||
/**
|
||||
* Last update timestamp
|
||||
*/
|
||||
updated: string;
|
||||
/**
|
||||
* Workflow version
|
||||
*/
|
||||
version: string;
|
||||
};
|
||||
/**
|
||||
* Optional message
|
||||
*/
|
||||
message?: string | null;
|
||||
}> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'PUT',
|
||||
url: '/api/v1/workflows/{ref}',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
body: requestBody,
|
||||
mediaType: 'application/json',
|
||||
errors: {
|
||||
400: `Validation error`,
|
||||
404: `Workflow not found`,
|
||||
},
|
||||
});
|
||||
}
|
||||
/**
|
||||
* Delete a workflow
|
||||
* @returns SuccessResponse Workflow deleted successfully
|
||||
* @throws ApiError
|
||||
*/
|
||||
public static deleteWorkflow({
|
||||
ref,
|
||||
}: {
|
||||
/**
|
||||
* Workflow reference identifier
|
||||
*/
|
||||
ref: string,
|
||||
}): CancelablePromise<SuccessResponse> {
|
||||
return __request(OpenAPI, {
|
||||
method: 'DELETE',
|
||||
url: '/api/v1/workflows/{ref}',
|
||||
path: {
|
||||
'ref': ref,
|
||||
},
|
||||
errors: {
|
||||
404: `Workflow not found`,
|
||||
},
|
||||
});
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user