@taico/client 0.0.2 → 0.2.0

package/dist/src/{client → v1/client}/services/AgentTokensService.js

@@ -8,8 +8,8 @@ export class AgentTokensService {
      * @returns IssueAccessTokenResponseDto
      * @throws ApiError
      */
-    static agentTokensControllerIssueToken(slug, requestBody) {
-        return __request(OpenAPI, {
+    static agentTokensControllerIssueToken(slug, requestBody, config = OpenAPI) {
+        return __request(config, {
             method: 'POST',
             url: '/api/v1/agents/{slug}/tokens',
             path: {
@@ -25,8 +25,8 @@ export class AgentTokensService {
      * @returns IssuedAccessTokenResponseDto
      * @throws ApiError
      */
-    static agentTokensControllerListTokens(slug) {
-        return __request(OpenAPI, {
+    static agentTokensControllerListTokens(slug, config = OpenAPI) {
+        return __request(config, {
             method: 'GET',
             url: '/api/v1/agents/{slug}/tokens',
             path: {
@@ -41,8 +41,8 @@ export class AgentTokensService {
      * @returns IssuedAccessTokenResponseDto
      * @throws ApiError
      */
-    static agentTokensControllerRevokeToken(slug, tokenId) {
-        return __request(OpenAPI, {
+    static agentTokensControllerRevokeToken(slug, tokenId, config = OpenAPI) {
+        return __request(config, {
             method: 'DELETE',
             url: '/api/v1/agents/{slug}/tokens/{tokenId}',
             path: {

package/dist/src/{client → v1/client}/services/AppService.d.ts

@@ -1,9 +1,10 @@
 import type { CancelablePromise } from '../core/CancelablePromise.js';
+import type { OpenAPIConfig } from '../core/OpenAPI.js';
 export declare class AppService {
     /**
      * Health check endpoint
      * @returns string Returns a greeting message
      * @throws ApiError
      */
-    static appControllerGetHello(): CancelablePromise<string>;
+    static appControllerGetHello(config?: OpenAPIConfig): CancelablePromise<string>;
 }

package/dist/src/{client → v1/client}/services/AppService.js

@@ -6,8 +6,8 @@ export class AppService {
      * @returns string Returns a greeting message
      * @throws ApiError
      */
-    static appControllerGetHello() {
-        return __request(OpenAPI, {
+    static appControllerGetHello(config = OpenAPI) {
+        return __request(config, {
             method: 'GET',
             url: '/api/v1',
         });

package/dist/src/{client → v1/client}/services/AuthorizationJourneysService.d.ts

@@ -1,5 +1,6 @@
 import type { AuthJourneyResponseDto } from '../models/AuthJourneyResponseDto.js';
 import type { CancelablePromise } from '../core/CancelablePromise.js';
+import type { OpenAPIConfig } from '../core/OpenAPI.js';
 export declare class AuthorizationJourneysService {
     /**
      * Get authorization journeys for an MCP server (debug/monitoring)
@@ -7,5 +8,5 @@ export declare class AuthorizationJourneysService {
      * @returns AuthJourneyResponseDto List of authorization journeys
      * @throws ApiError
      */
-    static authJourneysControllerGetAuthJourneys(serverId: string): CancelablePromise<Array<AuthJourneyResponseDto>>;
+    static authJourneysControllerGetAuthJourneys(serverId: string, config?: OpenAPIConfig): CancelablePromise<Array<AuthJourneyResponseDto>>;
 }

package/dist/src/{client → v1/client}/services/AuthorizationJourneysService.js

@@ -7,8 +7,8 @@ export class AuthorizationJourneysService {
      * @returns AuthJourneyResponseDto List of authorization journeys
      * @throws ApiError
      */
-    static authJourneysControllerGetAuthJourneys(serverId) {
-        return __request(OpenAPI, {
+    static authJourneysControllerGetAuthJourneys(serverId, config = OpenAPI) {
+        return __request(config, {
             method: 'GET',
             url: '/api/v1/auth-journeys/servers/{serverId}',
             path: {

package/dist/src/{client → v1/client}/services/AuthorizationServerService.d.ts

@@ -10,6 +10,7 @@ import type { TokenExchangeResponseDto } from '../models/TokenExchangeResponseDt
 import type { TokenRequestDto } from '../models/TokenRequestDto.js';
 import type { TokenResponseDto } from '../models/TokenResponseDto.js';
 import type { CancelablePromise } from '../core/CancelablePromise.js';
+import type { OpenAPIConfig } from '../core/OpenAPI.js';
 export declare class AuthorizationServerService {
     /**
      * Register a new OAuth 2.0 client (Dynamic Client Registration)
@@ -20,7 +21,7 @@ export declare class AuthorizationServerService {
      * @returns ClientRegistrationResponseDto Client registered successfully with generated credentials
      * @throws ApiError
      */
-    static clientRegistrationControllerRegisterClient(serverId: string, version: string, requestBody: RegisterClientDto): CancelablePromise<ClientRegistrationResponseDto>;
+    static clientRegistrationControllerRegisterClient(serverId: string, version: string, requestBody: RegisterClientDto, config?: OpenAPIConfig): CancelablePromise<ClientRegistrationResponseDto>;
     /**
      * Retrieve client registration information
      * Returns the registration metadata for a client. The client_secret is NOT included in the response for security reasons.
@@ -28,14 +29,14 @@ export declare class AuthorizationServerService {
      * @returns ClientRegistrationResponseDto Client registration information retrieved successfully
      * @throws ApiError
      */
-    static clientRegistrationControllerGetClient(clientId: string): CancelablePromise<ClientRegistrationResponseDto>;
+    static clientRegistrationControllerGetClient(clientId: string, config?: OpenAPIConfig): CancelablePromise<ClientRegistrationResponseDto>;
     /**
      * List all registered clients (Admin)
      * Returns a list of all registered OAuth clients. Intended for administrative purposes. Client secrets are not included.
      * @returns ClientRegistrationResponseDto List of registered clients
      * @throws ApiError
      */
-    static clientRegistrationControllerListClients(): CancelablePromise<Array<ClientRegistrationResponseDto>>;
+    static clientRegistrationControllerListClients(config?: OpenAPIConfig): CancelablePromise<Array<ClientRegistrationResponseDto>>;
     /**
      * OAuth 2.0 Authorization Endpoint
      * Handles authorization requests from MCP clients. Validates the request, stores PKCE parameters, and redirects to the consent screen UI.
@@ -45,14 +46,14 @@ export declare class AuthorizationServerService {
      * @param codeChallengeMethod PKCE code challenge method (S256 for SHA-256)
      * @param redirectUri Redirect URI where the authorization response will be sent
      * @param state Opaque state value for CSRF protection
-     * @param resource Resource server URL that the client wants to access
      * @param serverIdentifier
      * @param version
      * @param scope Space-delimited list of scopes being requested
+     * @param resource Resource server URL that the client wants to access
      * @returns void
      * @throws ApiError
      */
-    static authorizationControllerAuthorize(responseType: 'code', clientId: string, codeChallenge: string, codeChallengeMethod: string, redirectUri: string, state: string, resource: string, serverIdentifier: string, version: string, scope?: string): CancelablePromise<void>;
+    static authorizationControllerAuthorize(responseType: 'code', clientId: string, codeChallenge: string, codeChallengeMethod: string, redirectUri: string, state: string, serverIdentifier: string, version: string, scope?: string, resource?: string, config?: OpenAPIConfig): CancelablePromise<void>;
     /**
      * OAuth 2.0 Authorization Consent Handler
      * Handles user consent decision. Validates the flow ID (CSRF token), generates an authorization code if approved, and redirects back to the client with the code or error.
@@ -62,7 +63,7 @@ export declare class AuthorizationServerService {
      * @returns void
      * @throws ApiError
      */
-    static authorizationControllerAuthorizeConsent(serverIdentifier: string, version: string, requestBody: ConsentDecisionDto): CancelablePromise<void>;
+    static authorizationControllerAuthorizeConsent(serverIdentifier: string, version: string, requestBody: ConsentDecisionDto, config?: OpenAPIConfig): CancelablePromise<void>;
     /**
      * Get metadata for the consent screen from flow ID
      * Retrieves authorization flow details for the consent screen
@@ -70,7 +71,7 @@ export declare class AuthorizationServerService {
      * @returns GetConsentMetadataResponseDto Consent metadata retrieved successfully
      * @throws ApiError
      */
-    static authorizationControllerGetConsentMetadata(flowId: string): CancelablePromise<GetConsentMetadataResponseDto>;
+    static authorizationControllerGetConsentMetadata(flowId: string, config?: OpenAPIConfig): CancelablePromise<GetConsentMetadataResponseDto>;
     /**
      * OAuth 2.0 Token Endpoint
      * Exchanges authorization code for access token. Validates PKCE code_verifier, issues signed JWT access token and refresh token.
@@ -80,7 +81,7 @@ export declare class AuthorizationServerService {
      * @returns TokenResponseDto Access token issued successfully
      * @throws ApiError
      */
-    static authorizationControllerToken(serverIdentifier: string, version: string, requestBody: TokenRequestDto): CancelablePromise<TokenResponseDto>;
+    static authorizationControllerToken(serverIdentifier: string, version: string, requestBody: TokenRequestDto, config?: OpenAPIConfig): CancelablePromise<TokenResponseDto>;
     /**
      * OAuth 2.0 Token Introspection Endpoint
      * Introspects an access token to validate it and retrieve its metadata. Verifies JWT signature, expiration, and claims according to RFC 7662.
@@ -90,7 +91,7 @@ export declare class AuthorizationServerService {
      * @returns IntrospectTokenResponseDto Token introspection response (active true/false with metadata)
      * @throws ApiError
      */
-    static authorizationControllerIntrospect(serverIdentifier: string, version: string, requestBody: IntrospectTokenRequestDto): CancelablePromise<IntrospectTokenResponseDto>;
+    static authorizationControllerIntrospect(serverIdentifier: string, version: string, requestBody: IntrospectTokenRequestDto, config?: OpenAPIConfig): CancelablePromise<IntrospectTokenResponseDto>;
     /**
      * RFC 8693 Token Exchange Endpoint
      * Exchanges MCP JWT access token for downstream system tokens. Validates MCP token, resolves scope mappings, and returns downstream access token with automatic refresh if needed.
@@ -100,7 +101,7 @@ export declare class AuthorizationServerService {
      * @returns TokenExchangeResponseDto Token exchange successful - returns downstream access token
      * @throws ApiError
      */
-    static authorizationControllerTokenExchange(serverIdentifier: string, version: string, requestBody: TokenExchangeRequestDto): CancelablePromise<TokenExchangeResponseDto>;
+    static authorizationControllerTokenExchange(serverIdentifier: string, version: string, requestBody: TokenExchangeRequestDto, config?: OpenAPIConfig): CancelablePromise<TokenExchangeResponseDto>;
     /**
      * OAuth 2.0 Callback Endpoint for Downstream Systems
      * Handles callbacks from downstream OAuth providers. Validates the state, exchanges authorization code for tokens, and continues the auth flow.
@@ -112,12 +113,12 @@ export declare class AuthorizationServerService {
      * @returns void
      * @throws ApiError
      */
-    static authorizationControllerCallback(code: string, state: string, error?: string, scope?: string, errorDescription?: string): CancelablePromise<void>;
+    static authorizationControllerCallback(code: string, state: string, error?: string, scope?: string, errorDescription?: string, config?: OpenAPIConfig): CancelablePromise<void>;
     /**
      * List All Available Scopes
      * Returns a list of all scopes available in the system. Each scope includes its identifier string and a human-readable description.
      * @returns ScopesResponseDto List of all available scopes
      * @throws ApiError
      */
-    static authorizationControllerGetScopes(): CancelablePromise<ScopesResponseDto>;
+    static authorizationControllerGetScopes(config?: OpenAPIConfig): CancelablePromise<ScopesResponseDto>;
 }

package/dist/src/{client → v1/client}/services/AuthorizationServerService.js

@@ -10,8 +10,8 @@ export class AuthorizationServerService {
      * @returns ClientRegistrationResponseDto Client registered successfully with generated credentials
      * @throws ApiError
      */
-    static clientRegistrationControllerRegisterClient(serverId, version, requestBody) {
-        return __request(OpenAPI, {
+    static clientRegistrationControllerRegisterClient(serverId, version, requestBody, config = OpenAPI) {
+        return __request(config, {
             method: 'POST',
             url: '/api/v1/auth/clients/register/mcp/{serverId}/{version}',
             path: {
@@ -33,8 +33,8 @@ export class AuthorizationServerService {
      * @returns ClientRegistrationResponseDto Client registration information retrieved successfully
      * @throws ApiError
      */
-    static clientRegistrationControllerGetClient(clientId) {
-        return __request(OpenAPI, {
+    static clientRegistrationControllerGetClient(clientId, config = OpenAPI) {
+        return __request(config, {
             method: 'GET',
             url: '/api/v1/auth/clients/{clientId}',
             path: {
@@ -51,8 +51,8 @@ export class AuthorizationServerService {
      * @returns ClientRegistrationResponseDto List of registered clients
      * @throws ApiError
      */
-    static clientRegistrationControllerListClients() {
-        return __request(OpenAPI, {
+    static clientRegistrationControllerListClients(config = OpenAPI) {
+        return __request(config, {
             method: 'GET',
             url: '/api/v1/auth/clients',
         });
@@ -66,15 +66,15 @@ export class AuthorizationServerService {
      * @param codeChallengeMethod PKCE code challenge method (S256 for SHA-256)
      * @param redirectUri Redirect URI where the authorization response will be sent
      * @param state Opaque state value for CSRF protection
-     * @param resource Resource server URL that the client wants to access
      * @param serverIdentifier
      * @param version
      * @param scope Space-delimited list of scopes being requested
+     * @param resource Resource server URL that the client wants to access
      * @returns void
      * @throws ApiError
      */
-    static authorizationControllerAuthorize(responseType, clientId, codeChallenge, codeChallengeMethod, redirectUri, state, resource, serverIdentifier, version, scope) {
-        return __request(OpenAPI, {
+    static authorizationControllerAuthorize(responseType, clientId, codeChallenge, codeChallengeMethod, redirectUri, state, serverIdentifier, version, scope, resource, config = OpenAPI) {
+        return __request(config, {
             method: 'GET',
             url: '/api/v1/auth/authorize/mcp/{serverIdentifier}/{version}',
             path: {
@@ -107,8 +107,8 @@ export class AuthorizationServerService {
      * @returns void
      * @throws ApiError
      */
-    static authorizationControllerAuthorizeConsent(serverIdentifier, version, requestBody) {
-        return __request(OpenAPI, {
+    static authorizationControllerAuthorizeConsent(serverIdentifier, version, requestBody, config = OpenAPI) {
+        return __request(config, {
             method: 'POST',
             url: '/api/v1/auth/authorize/mcp/{serverIdentifier}/{version}',
             path: {
@@ -132,8 +132,8 @@ export class AuthorizationServerService {
      * @returns GetConsentMetadataResponseDto Consent metadata retrieved successfully
      * @throws ApiError
      */
-    static authorizationControllerGetConsentMetadata(flowId) {
-        return __request(OpenAPI, {
+    static authorizationControllerGetConsentMetadata(flowId, config = OpenAPI) {
+        return __request(config, {
             method: 'GET',
             url: '/api/v1/auth/consent/{flowId}',
             path: {
@@ -154,8 +154,8 @@ export class AuthorizationServerService {
      * @returns TokenResponseDto Access token issued successfully
      * @throws ApiError
      */
-    static authorizationControllerToken(serverIdentifier, version, requestBody) {
-        return __request(OpenAPI, {
+    static authorizationControllerToken(serverIdentifier, version, requestBody, config = OpenAPI) {
+        return __request(config, {
             method: 'POST',
             url: '/api/v1/auth/token/mcp/{serverIdentifier}/{version}',
             path: {
@@ -179,8 +179,8 @@ export class AuthorizationServerService {
      * @returns IntrospectTokenResponseDto Token introspection response (active true/false with metadata)
      * @throws ApiError
      */
-    static authorizationControllerIntrospect(serverIdentifier, version, requestBody) {
-        return __request(OpenAPI, {
+    static authorizationControllerIntrospect(serverIdentifier, version, requestBody, config = OpenAPI) {
+        return __request(config, {
             method: 'POST',
             url: '/api/v1/auth/introspect/mcp/{serverIdentifier}/{version}',
             path: {
@@ -203,8 +203,8 @@ export class AuthorizationServerService {
      * @returns TokenExchangeResponseDto Token exchange successful - returns downstream access token
      * @throws ApiError
      */
-    static authorizationControllerTokenExchange(serverIdentifier, version, requestBody) {
-        return __request(OpenAPI, {
+    static authorizationControllerTokenExchange(serverIdentifier, version, requestBody, config = OpenAPI) {
+        return __request(config, {
             method: 'POST',
             url: '/api/v1/auth/token-exchange/mcp/{serverIdentifier}/{version}',
             path: {
@@ -232,8 +232,8 @@ export class AuthorizationServerService {
      * @returns void
      * @throws ApiError
      */
-    static authorizationControllerCallback(code, state, error, scope, errorDescription) {
-        return __request(OpenAPI, {
+    static authorizationControllerCallback(code, state, error, scope, errorDescription, config = OpenAPI) {
+        return __request(config, {
             method: 'GET',
             url: '/api/v1/auth/callback',
             query: {
@@ -256,8 +256,8 @@ export class AuthorizationServerService {
      * @returns ScopesResponseDto List of all available scopes
      * @throws ApiError
      */
-    static authorizationControllerGetScopes() {
-        return __request(OpenAPI, {
+    static authorizationControllerGetScopes(config = OpenAPI) {
+        return __request(config, {
             method: 'GET',
             url: '/api/v1/auth/scopes',
         });

package/dist/src/v1/client/services/ChatProvidersService.d.ts

@@ -0,0 +1,56 @@
+import type { ChatProviderResponseDto } from '../models/ChatProviderResponseDto.js';
+import type { CreateChatProviderDto } from '../models/CreateChatProviderDto.js';
+import type { SetActiveChatProviderDto } from '../models/SetActiveChatProviderDto.js';
+import type { UpdateChatProviderDto } from '../models/UpdateChatProviderDto.js';
+import type { CancelablePromise } from '../core/CancelablePromise.js';
+import type { OpenAPIConfig } from '../core/OpenAPI.js';
+export declare class ChatProvidersService {
+    /**
+     * Create a new chat provider
+     * @param requestBody
+     * @returns ChatProviderResponseDto Chat provider created successfully
+     * @throws ApiError
+     */
+    static chatProvidersControllerCreateChatProvider(requestBody: CreateChatProviderDto, config?: OpenAPIConfig): CancelablePromise<ChatProviderResponseDto>;
+    /**
+     * List all chat providers
+     * @returns ChatProviderResponseDto List of chat providers
+     * @throws ApiError
+     */
+    static chatProvidersControllerListChatProviders(config?: OpenAPIConfig): CancelablePromise<Array<ChatProviderResponseDto>>;
+    /**
+     * Get chat provider by ID
+     * @param id Chat provider identifier
+     * @returns ChatProviderResponseDto Chat provider details
+     * @throws ApiError
+     */
+    static chatProvidersControllerGetChatProvider(id: string, config?: OpenAPIConfig): CancelablePromise<ChatProviderResponseDto>;
+    /**
+     * Update a chat provider
+     * @param id Chat provider identifier
+     * @param requestBody
+     * @returns ChatProviderResponseDto Chat provider updated successfully
+     * @throws ApiError
+     */
+    static chatProvidersControllerUpdateChatProvider(id: string, requestBody: UpdateChatProviderDto, config?: OpenAPIConfig): CancelablePromise<ChatProviderResponseDto>;
+    /**
+     * Delete a chat provider
+     * @param id Chat provider identifier
+     * @returns void
+     * @throws ApiError
+     */
+    static chatProvidersControllerDeleteChatProvider(id: string, config?: OpenAPIConfig): CancelablePromise<void>;
+    /**
+     * Set the active chat provider
+     * @param requestBody
+     * @returns ChatProviderResponseDto Active chat provider set successfully
+     * @throws ApiError
+     */
+    static chatProvidersControllerSetActiveChatProvider(requestBody: SetActiveChatProviderDto, config?: OpenAPIConfig): CancelablePromise<ChatProviderResponseDto>;
+    /**
+     * Deactivate the active chat provider
+     * @returns void
+     * @throws ApiError
+     */
+    static chatProvidersControllerDeactivateActiveChatProvider(config?: OpenAPIConfig): CancelablePromise<void>;
+}

package/dist/src/v1/client/services/ChatProvidersService.js

@@ -0,0 +1,114 @@
+import { OpenAPI } from '../core/OpenAPI.js';
+import { request as __request } from '../core/request.js';
+export class ChatProvidersService {
+    /**
+     * Create a new chat provider
+     * @param requestBody
+     * @returns ChatProviderResponseDto Chat provider created successfully
+     * @throws ApiError
+     */
+    static chatProvidersControllerCreateChatProvider(requestBody, config = OpenAPI) {
+        return __request(config, {
+            method: 'POST',
+            url: '/api/v1/chat-providers',
+            body: requestBody,
+            mediaType: 'application/json',
+        });
+    }
+    /**
+     * List all chat providers
+     * @returns ChatProviderResponseDto List of chat providers
+     * @throws ApiError
+     */
+    static chatProvidersControllerListChatProviders(config = OpenAPI) {
+        return __request(config, {
+            method: 'GET',
+            url: '/api/v1/chat-providers',
+        });
+    }
+    /**
+     * Get chat provider by ID
+     * @param id Chat provider identifier
+     * @returns ChatProviderResponseDto Chat provider details
+     * @throws ApiError
+     */
+    static chatProvidersControllerGetChatProvider(id, config = OpenAPI) {
+        return __request(config, {
+            method: 'GET',
+            url: '/api/v1/chat-providers/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                404: `Chat provider not found`,
+            },
+        });
+    }
+    /**
+     * Update a chat provider
+     * @param id Chat provider identifier
+     * @param requestBody
+     * @returns ChatProviderResponseDto Chat provider updated successfully
+     * @throws ApiError
+     */
+    static chatProvidersControllerUpdateChatProvider(id, requestBody, config = OpenAPI) {
+        return __request(config, {
+            method: 'PATCH',
+            url: '/api/v1/chat-providers/{id}',
+            path: {
+                'id': id,
+            },
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                404: `Chat provider not found`,
+            },
+        });
+    }
+    /**
+     * Delete a chat provider
+     * @param id Chat provider identifier
+     * @returns void
+     * @throws ApiError
+     */
+    static chatProvidersControllerDeleteChatProvider(id, config = OpenAPI) {
+        return __request(config, {
+            method: 'DELETE',
+            url: '/api/v1/chat-providers/{id}',
+            path: {
+                'id': id,
+            },
+            errors: {
+                404: `Chat provider not found`,
+            },
+        });
+    }
+    /**
+     * Set the active chat provider
+     * @param requestBody
+     * @returns ChatProviderResponseDto Active chat provider set successfully
+     * @throws ApiError
+     */
+    static chatProvidersControllerSetActiveChatProvider(requestBody, config = OpenAPI) {
+        return __request(config, {
+            method: 'POST',
+            url: '/api/v1/chat-providers/set-active',
+            body: requestBody,
+            mediaType: 'application/json',
+            errors: {
+                404: `Chat provider not found`,
+            },
+        });
+    }
+    /**
+     * Deactivate the active chat provider
+     * @returns void
+     * @throws ApiError
+     */
+    static chatProvidersControllerDeactivateActiveChatProvider(config = OpenAPI) {
+        return __request(config, {
+            method: 'POST',
+            url: '/api/v1/chat-providers/deactivate',
+        });
+    }
+}

package/dist/src/{client → v1/client}/services/ContextService.d.ts

@@ -1,6 +1,7 @@
 import type { AppendBlockDto } from '../models/AppendBlockDto.js';
 import type { BlockListResponseDto } from '../models/BlockListResponseDto.js';
 import type { BlockResponseDto } from '../models/BlockResponseDto.js';
+import type { BlockSearchResultDto } from '../models/BlockSearchResultDto.js';
 import type { BlockTreeResponseDto } from '../models/BlockTreeResponseDto.js';
 import type { CreateBlockDto } from '../models/CreateBlockDto.js';
 import type { CreateTagDto } from '../models/CreateTagDto.js';
@@ -8,6 +9,7 @@ import type { MoveBlockDto } from '../models/MoveBlockDto.js';
 import type { ReorderBlockDto } from '../models/ReorderBlockDto.js';
 import type { UpdateBlockDto } from '../models/UpdateBlockDto.js';
 import type { CancelablePromise } from '../core/CancelablePromise.js';
+import type { OpenAPIConfig } from '../core/OpenAPI.js';
 export declare class ContextService {
     /**
      * Create a new wiki page
@@ -15,27 +17,36 @@ export declare class ContextService {
      * @returns BlockResponseDto Context page created successfully
      * @throws ApiError
      */
-    static contextControllerCreateBlock(requestBody: CreateBlockDto): CancelablePromise<BlockResponseDto>;
+    static contextControllerCreateBlock(requestBody: CreateBlockDto, config?: OpenAPIConfig): CancelablePromise<BlockResponseDto>;
     /**
      * List wiki pages without content
      * @param tag Filter blocks by tag name
      * @returns BlockListResponseDto List of wiki pages
      * @throws ApiError
      */
-    static contextControllerListBlocks(tag?: string): CancelablePromise<BlockListResponseDto>;
+    static contextControllerListBlocks(tag?: string, config?: OpenAPIConfig): CancelablePromise<BlockListResponseDto>;
+    /**
+     * Search blocks by query string
+     * @param query Search query string
+     * @param limit Maximum number of results to return
+     * @param threshold Minimum score threshold (0-1, higher is stricter)
+     * @returns BlockSearchResultDto Search results sorted by relevance
+     * @throws ApiError
+     */
+    static contextControllerSearchBlocks(query: string, limit?: number, threshold?: number, config?: OpenAPIConfig): CancelablePromise<Array<BlockSearchResultDto>>;
     /**
      * Get page hierarchy tree
      * @returns BlockTreeResponseDto Page hierarchy tree
      * @throws ApiError
      */
-    static contextControllerGetBlockTree(): CancelablePromise<Array<BlockTreeResponseDto>>;
+    static contextControllerGetBlockTree(config?: OpenAPIConfig): CancelablePromise<Array<BlockTreeResponseDto>>;
     /**
      * Fetch a wiki page by ID
      * @param id Context block identifier
      * @returns BlockResponseDto Context page retrieved successfully
      * @throws ApiError
      */
-    static contextControllerGetBlock(id: string): CancelablePromise<BlockResponseDto>;
+    static contextControllerGetBlock(id: string, config?: OpenAPIConfig): CancelablePromise<BlockResponseDto>;
     /**
      * Update an existing wiki page
      * @param id Context block identifier
@@ -43,14 +54,14 @@ export declare class ContextService {
      * @returns BlockResponseDto Context page updated successfully
      * @throws ApiError
      */
-    static contextControllerUpdateBlock(id: string, requestBody: UpdateBlockDto): CancelablePromise<BlockResponseDto>;
+    static contextControllerUpdateBlock(id: string, requestBody: UpdateBlockDto, config?: OpenAPIConfig): CancelablePromise<BlockResponseDto>;
     /**
      * Delete a wiki page
      * @param id Context block identifier
      * @returns void
      * @throws ApiError
      */
-    static contextControllerDeleteBlock(id: string): CancelablePromise<void>;
+    static contextControllerDeleteBlock(id: string, config?: OpenAPIConfig): CancelablePromise<void>;
     /**
      * Append content to an existing wiki page
      * @param id Context block identifier
@@ -58,7 +69,7 @@ export declare class ContextService {
      * @returns BlockResponseDto Context page content appended successfully
      * @throws ApiError
      */
-    static contextControllerAppendToBlock(id: string, requestBody: AppendBlockDto): CancelablePromise<BlockResponseDto>;
+    static contextControllerAppendToBlock(id: string, requestBody: AppendBlockDto, config?: OpenAPIConfig): CancelablePromise<BlockResponseDto>;
     /**
      * Reorder a page within siblings
      * @param id Context block identifier
@@ -66,7 +77,7 @@ export declare class ContextService {
      * @returns BlockResponseDto Page reordered successfully
      * @throws ApiError
      */
-    static contextControllerReorderBlock(id: string, requestBody: ReorderBlockDto): CancelablePromise<BlockResponseDto>;
+    static contextControllerReorderBlock(id: string, requestBody: ReorderBlockDto, config?: OpenAPIConfig): CancelablePromise<BlockResponseDto>;
     /**
      * Move page to different parent
      * @param id Context block identifier
@@ -74,7 +85,7 @@ export declare class ContextService {
      * @returns BlockResponseDto Page moved successfully
      * @throws ApiError
      */
-    static contextControllerMoveBlock(id: string, requestBody: MoveBlockDto): CancelablePromise<BlockResponseDto>;
+    static contextControllerMoveBlock(id: string, requestBody: MoveBlockDto, config?: OpenAPIConfig): CancelablePromise<BlockResponseDto>;
     /**
      * Add a tag to a wiki page
      * @param id Context block identifier
@@ -82,7 +93,7 @@ export declare class ContextService {
      * @returns BlockResponseDto Tag added to page successfully
      * @throws ApiError
      */
-    static contextControllerAddTagToBlock(id: string, requestBody: CreateTagDto): CancelablePromise<BlockResponseDto>;
+    static contextControllerAddTagToBlock(id: string, requestBody: CreateTagDto, config?: OpenAPIConfig): CancelablePromise<BlockResponseDto>;
     /**
      * Remove a tag from a wiki page
      * @param id
@@ -90,40 +101,40 @@ export declare class ContextService {
      * @returns BlockResponseDto Tag removed from page successfully
      * @throws ApiError
      */
-    static contextControllerRemoveTagFromBlock(id: string, tagId: string): CancelablePromise<BlockResponseDto>;
+    static contextControllerRemoveTagFromBlock(id: string, tagId: string, config?: OpenAPIConfig): CancelablePromise<BlockResponseDto>;
     /**
      * @returns any
      * @throws ApiError
      */
-    static contextControllerHandleMcpGet(): CancelablePromise<any>;
+    static contextControllerHandleMcpGet(config?: OpenAPIConfig): CancelablePromise<any>;
     /**
      * @returns any
      * @throws ApiError
      */
-    static contextControllerHandleMcpPost(): CancelablePromise<any>;
+    static contextControllerHandleMcpPost(config?: OpenAPIConfig): CancelablePromise<any>;
     /**
      * @returns any
      * @throws ApiError
      */
-    static contextControllerHandleMcpPut(): CancelablePromise<any>;
+    static contextControllerHandleMcpPut(config?: OpenAPIConfig): CancelablePromise<any>;
     /**
      * @returns any
      * @throws ApiError
      */
-    static contextControllerHandleMcpDelete(): CancelablePromise<any>;
+    static contextControllerHandleMcpDelete(config?: OpenAPIConfig): CancelablePromise<any>;
     /**
      * @returns any
      * @throws ApiError
      */
-    static contextControllerHandleMcpPatch(): CancelablePromise<any>;
+    static contextControllerHandleMcpPatch(config?: OpenAPIConfig): CancelablePromise<any>;
     /**
      * @returns any
      * @throws ApiError
      */
-    static contextControllerHandleMcpOptions(): CancelablePromise<any>;
+    static contextControllerHandleMcpOptions(config?: OpenAPIConfig): CancelablePromise<any>;
     /**
      * @returns any
      * @throws ApiError
      */
-    static contextControllerHandleMcpHead(): CancelablePromise<any>;
+    static contextControllerHandleMcpHead(config?: OpenAPIConfig): CancelablePromise<any>;
 }