// This file is auto-generated by @hey-api/openapi-ts

export type ClientOptions = {
    baseURL: `${string}://${string}` | (string & {});
};

/**
 * ActivatePrivacyConfigVersionRequest
 */
export type ActivatePrivacyConfigVersionRequest = {
    /**
     * Version
     */
    version: number;
};

/**
 * AddMessageRequest
 *
 * Request model for adding a message.
 *
 * Supports two modes:
 * 1. Simple mode: provide `content` string (backward compatible)
 * 2. Parts mode: provide `parts` array for full Part support
 *
 * If both are provided, `parts` takes precedence.
 */
export type AddMessageRequest = {
    /**
     * Role
     */
    role: string;
    /**
     * Peer Id
     */
    peer_id?: string | null;
    /**
     * Content
     */
    content?: string | null;
    /**
     * Parts
     */
    parts?: Array<{
        [key: string]: unknown;
    }> | null;
    /**
     * Created At
     */
    created_at?: string | null;
    /**
     * Telemetry
     */
    telemetry?: boolean | {
        [key: string]: boolean;
    };
};

/**
 * AddResourceRequest
 *
 * Request model for add_resource.
 *
 * Attributes:
 * path: Remote resource source such as an HTTP(S) URL or repository URL.
 * Either path or temp_file_id must be provided.
 * temp_file_id: Temporary upload id returned by /api/v1/resources/temp_upload.
 * Either path or temp_file_id must be provided.
 * to: Target URI for the resource (e.g., "viking://resources/my_resource").
 * If not specified, an auto-generated URI will be used.
 * parent: Parent URI under which the resource will be stored.
 * Cannot be used together with 'to'.
 * create_parent: Whether to automatically create the parent directory if it doesn't exist.
 * Default is False.
 * reason: Reason for adding the resource. Used for documentation and monitoring.
 * instruction: Processing instruction for semantic extraction.
 * Provides hints for how the resource should be processed.
 * wait: Whether to wait for semantic extraction and vectorization to complete.
 * Default is False (async processing).
 * timeout: Timeout in seconds when wait=True. None means no timeout.
 * strict: Whether to use strict mode for processing. Default is True.
 * ignore_dirs: Comma-separated list of directory names to ignore during parsing.
 * include: Glob pattern for files to include during parsing.
 * exclude: Glob pattern for files to exclude during parsing.
 * directly_upload_media: Whether to directly upload media files. Default is True.
 * preserve_structure: Whether to preserve directory structure when adding directories.
 * watch_interval: Watch interval in minutes for automatic resource monitoring.
 * - watch_interval > 0: Creates or updates a watch task. The resource will be
 * automatically re-processed at the specified interval.
 * - watch_interval = 0: No watch task is created. If a watch task exists for
 * this resource, it will be cancelled (deactivated).
 * - watch_interval < 0: Same as watch_interval = 0, cancels any existing watch task.
 * Default is 0 (no monitoring).
 *
 * Note: If the target URI already has an active watch task, a ConflictError will be
 * raised. You must first cancel the existing watch (set watch_interval <= 0) before
 * creating a new one.
 */
export type AddResourceRequest = {
    /**
     * Path
     */
    path?: string | null;
    /**
     * Temp File Id
     */
    temp_file_id?: string | null;
    /**
     * To
     */
    to?: string | null;
    /**
     * Parent
     */
    parent?: string | null;
    /**
     * Create Parent
     */
    create_parent?: boolean;
    /**
     * Reason
     */
    reason?: string;
    /**
     * Instruction
     */
    instruction?: string;
    /**
     * Wait
     */
    wait?: boolean;
    /**
     * Timeout
     */
    timeout?: number | null;
    /**
     * Strict
     */
    strict?: boolean;
    /**
     * Source Name
     */
    source_name?: string | null;
    /**
     * Ignore Dirs
     */
    ignore_dirs?: string | null;
    /**
     * Include
     */
    include?: string | null;
    /**
     * Exclude
     */
    exclude?: string | null;
    /**
     * Directly Upload Media
     */
    directly_upload_media?: boolean;
    /**
     * Preserve Structure
     */
    preserve_structure?: boolean | null;
    /**
     * Telemetry
     */
    telemetry?: boolean | {
        [key: string]: boolean;
    };
    /**
     * Watch Interval
     */
    watch_interval?: number;
};

/**
 * AddSkillRequest
 *
 * Request model for add_skill.
 *
 * Attributes:
 * data: Inline skill content or structured skill data. HTTP requests do not treat
 * string values as host filesystem paths.
 * temp_file_id: Temporary upload id returned by /api/v1/resources/temp_upload.
 * wait: Whether to wait for skill processing to complete.
 * timeout: Timeout in seconds when wait=True.
 */
export type AddSkillRequest = {
    /**
     * Data
     */
    data?: unknown;
    /**
     * Temp File Id
     */
    temp_file_id?: string | null;
    /**
     * Wait
     */
    wait?: boolean;
    /**
     * Timeout
     */
    timeout?: number | null;
    /**
     * Telemetry
     */
    telemetry?: boolean | {
        [key: string]: boolean;
    };
};

/**
 * BackupRequest
 *
 * Request model for backup export.
 */
export type BackupRequest = {
    /**
     * Include Vectors
     */
    include_vectors?: boolean;
};

/**
 * Body_temp_upload_api_v1_resources_temp_upload_post
 */
export type BodyTempUploadApiV1ResourcesTempUploadPost = {
    /**
     * File
     */
    file: Blob | File;
    /**
     * Telemetry
     */
    telemetry?: boolean;
    /**
     * Upload Mode
     */
    upload_mode?: string;
};

/**
 * CommitRequest
 *
 * Commit request body.
 *
 * WM v2: ``keep_recent_count`` allows the plugin to retain a tail of recent
 * messages in the live session after commit so the next turn still has
 * immediate context. Default 0 preserves the pre-v2 "archive everything"
 * behavior.
 */
export type CommitRequest = {
    /**
     * Keep Recent Count
     *
     * Number of most-recent messages to keep live after commit. Plugin's afterTurn path typically passes its configured value (default 10); compact path passes 0 to archive everything.
     */
    keep_recent_count?: number;
    /**
     * Telemetry
     */
    telemetry?: boolean | {
        [key: string]: boolean;
    };
};

/**
 * ConsistencyRequest
 *
 * Request model for filesystem/vector-index consistency checks.
 */
export type ConsistencyRequest = {
    /**
     * Uri
     */
    uri: string;
};

/**
 * CreateAccountRequest
 */
export type CreateAccountRequest = {
    /**
     * Account Id
     */
    account_id: string;
    /**
     * Admin User Id
     */
    admin_user_id: string;
};

/**
 * CreateSessionRequest
 *
 * Request model for creating a session.
 */
export type CreateSessionRequest = {
    /**
     * Session Id
     */
    session_id?: string | null;
    /**
     * Telemetry
     */
    telemetry?: boolean | {
        [key: string]: boolean;
    };
};

/**
 * ExportRequest
 *
 * Request model for export.
 */
export type ExportRequest = {
    /**
     * Uri
     */
    uri: string;
    /**
     * Include Vectors
     */
    include_vectors?: boolean;
};

/**
 * FindRequest
 *
 * Request model for find.
 */
export type FindRequest = {
    /**
     * Query
     */
    query: string;
    /**
     * Target Uri
     */
    target_uri?: string | Array<string>;
    /**
     * Peer Id
     */
    peer_id?: string | null;
    /**
     * Limit
     */
    limit?: number;
    /**
     * Node Limit
     */
    node_limit?: number | null;
    /**
     * Score Threshold
     */
    score_threshold?: number | null;
    /**
     * Filter
     */
    filter?: {
        [key: string]: unknown;
    } | null;
    /**
     * Include Provenance
     */
    include_provenance?: boolean;
    /**
     * Since
     */
    since?: string | null;
    /**
     * Until
     */
    until?: string | null;
    /**
     * Time Field
     */
    time_field?: 'updated_at' | 'created_at' | null;
    /**
     * Level
     */
    level?: number | string | Array<number> | null;
    /**
     * Telemetry
     */
    telemetry?: boolean | {
        [key: string]: boolean;
    };
};

/**
 * GlobRequest
 *
 * Request model for glob.
 */
export type GlobRequest = {
    /**
     * Pattern
     */
    pattern: string;
    /**
     * Uri
     */
    uri?: string;
    /**
     * Node Limit
     */
    node_limit?: number | null;
};

/**
 * GrepRequest
 *
 * Request model for grep.
 */
export type GrepRequest = {
    /**
     * Uri
     */
    uri: string;
    /**
     * Exclude Uri
     */
    exclude_uri?: string | null;
    /**
     * Pattern
     */
    pattern: string;
    /**
     * Case Insensitive
     */
    case_insensitive?: boolean;
    /**
     * Node Limit
     */
    node_limit?: number | null;
    /**
     * Level Limit
     */
    level_limit?: number;
};

/**
 * HTTPValidationError
 */
export type HttpValidationError = {
    /**
     * Detail
     */
    detail?: Array<ValidationError>;
};

/**
 * ImportRequest
 *
 * Request model for import.
 *
 * Attributes:
 * temp_file_id: Temporary upload id returned by /api/v1/resources/temp_upload.
 * parent: Parent URI under which the imported pack will be placed.
 * on_conflict: Conflict policy: fail, overwrite, or skip.
 */
export type ImportRequest = {
    /**
     * Temp File Id
     */
    temp_file_id: string;
    /**
     * Parent
     */
    parent: string;
    /**
     * On Conflict
     */
    on_conflict?: 'fail' | 'overwrite' | 'skip' | null;
    /**
     * Vector Mode
     */
    vector_mode?: 'auto' | 'recompute' | 'require' | null;
};

/**
 * LinkRequest
 *
 * Request model for link.
 */
export type LinkRequest = {
    /**
     * From Uri
     */
    from_uri: string;
    /**
     * To Uris
     */
    to_uris: string | Array<string>;
    /**
     * Reason
     */
    reason?: string;
};

/**
 * MkdirRequest
 *
 * Request model for mkdir.
 */
export type MkdirRequest = {
    /**
     * Uri
     */
    uri: string;
    /**
     * Description
     */
    description?: string | null;
};

/**
 * MvRequest
 *
 * Request model for mv.
 */
export type MvRequest = {
    /**
     * From Uri
     */
    from_uri: string;
    /**
     * To Uri
     */
    to_uri: string;
};

/**
 * RegisterUserRequest
 */
export type RegisterUserRequest = {
    /**
     * User Id
     */
    user_id: string;
    /**
     * Role
     */
    role?: string;
};

/**
 * ReindexRequest
 */
export type ReindexRequest = {
    /**
     * Uri
     */
    uri: string;
    /**
     * Mode
     */
    mode?: string;
    /**
     * Wait
     */
    wait?: boolean;
};

/**
 * RestoreRequest
 *
 * Request model for backup restore.
 */
export type RestoreRequest = {
    /**
     * Temp File Id
     */
    temp_file_id: string;
    /**
     * On Conflict
     */
    on_conflict?: 'fail' | 'overwrite' | 'skip' | null;
    /**
     * Vector Mode
     */
    vector_mode?: 'auto' | 'recompute' | 'require' | null;
};

/**
 * SearchRequest
 *
 * Request model for search with session.
 */
export type SearchRequest = {
    /**
     * Query
     */
    query: string;
    /**
     * Target Uri
     */
    target_uri?: string | Array<string>;
    /**
     * Peer Id
     */
    peer_id?: string | null;
    /**
     * Session Id
     */
    session_id?: string | null;
    /**
     * Limit
     */
    limit?: number;
    /**
     * Node Limit
     */
    node_limit?: number | null;
    /**
     * Score Threshold
     */
    score_threshold?: number | null;
    /**
     * Filter
     */
    filter?: {
        [key: string]: unknown;
    } | null;
    /**
     * Include Provenance
     */
    include_provenance?: boolean;
    /**
     * Since
     */
    since?: string | null;
    /**
     * Until
     */
    until?: string | null;
    /**
     * Time Field
     */
    time_field?: 'updated_at' | 'created_at' | null;
    /**
     * Level
     */
    level?: number | string | Array<number> | null;
    /**
     * Telemetry
     */
    telemetry?: boolean | {
        [key: string]: boolean;
    };
};

/**
 * SetRoleRequest
 */
export type SetRoleRequest = {
    /**
     * Role
     */
    role: string;
};

/**
 * UnlinkRequest
 *
 * Request model for unlink.
 */
export type UnlinkRequest = {
    /**
     * From Uri
     */
    from_uri: string;
    /**
     * To Uri
     */
    to_uri: string;
};

/**
 * UpsertPrivacyConfigRequest
 */
export type UpsertPrivacyConfigRequest = {
    /**
     * Values
     */
    values: {
        [key: string]: unknown;
    };
    /**
     * Change Reason
     */
    change_reason?: string;
    /**
     * Labels
     */
    labels?: {
        [key: string]: unknown;
    } | null;
};

/**
 * UsedRequest
 *
 * Request model for recording usage.
 */
export type UsedRequest = {
    /**
     * Contexts
     */
    contexts?: Array<string> | null;
    /**
     * Skill
     */
    skill?: {
        [key: string]: unknown;
    } | null;
};

/**
 * ValidationError
 */
export type ValidationError = {
    /**
     * Location
     */
    loc: Array<string | number>;
    /**
     * Message
     */
    msg: string;
    /**
     * Error Type
     */
    type: string;
    /**
     * Input
     */
    input?: unknown;
    /**
     * Context
     */
    ctx?: {
        [key: string]: unknown;
    };
};

/**
 * WaitRequest
 *
 * Request model for wait.
 */
export type WaitRequest = {
    /**
     * Timeout
     */
    timeout?: number | null;
};

/**
 * WriteContentRequest
 *
 * Request to write, append, or create text content to a file.
 */
export type WriteContentRequest = {
    /**
     * Uri
     */
    uri: string;
    /**
     * Content
     */
    content: string;
    /**
     * Mode
     */
    mode?: string;
    /**
     * Wait
     */
    wait?: boolean;
    /**
     * Timeout
     */
    timeout?: number | null;
    /**
     * Telemetry
     */
    telemetry?: boolean | {
        [key: string]: boolean;
    };
};

export type GetHealthData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/health';
};

export type GetHealthResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetReadyData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/ready';
};

export type GetReadyResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetSystemStatusData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/system/status';
};

export type GetSystemStatusErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetSystemStatusError = GetSystemStatusErrors[keyof GetSystemStatusErrors];

export type GetSystemStatusResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostSystemWaitData = {
    body: WaitRequest;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/system/wait';
};

export type PostSystemWaitErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostSystemWaitError = PostSystemWaitErrors[keyof PostSystemWaitErrors];

export type PostSystemWaitResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostSystemConsistencyData = {
    body: ConsistencyRequest;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/system/consistency';
};

export type PostSystemConsistencyErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostSystemConsistencyError = PostSystemConsistencyErrors[keyof PostSystemConsistencyErrors];

export type PostSystemConsistencyResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetAdminAccountsData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/admin/accounts';
};

export type GetAdminAccountsErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetAdminAccountsError = GetAdminAccountsErrors[keyof GetAdminAccountsErrors];

export type GetAdminAccountsResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostAdminAccountsData = {
    body: CreateAccountRequest;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/admin/accounts';
};

export type PostAdminAccountsErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostAdminAccountsError = PostAdminAccountsErrors[keyof PostAdminAccountsErrors];

export type PostAdminAccountsResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type DeleteAdminAccountByAccountIdData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path: {
        /**
         * Account Id
         *
         * Account ID
         */
        account_id: string;
    };
    query?: never;
    url: '/api/v1/admin/accounts/{account_id}';
};

export type DeleteAdminAccountByAccountIdErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type DeleteAdminAccountByAccountIdError = DeleteAdminAccountByAccountIdErrors[keyof DeleteAdminAccountByAccountIdErrors];

export type DeleteAdminAccountByAccountIdResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetAdminAccountIdUsersData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path: {
        /**
         * Account Id
         *
         * Account ID
         */
        account_id: string;
    };
    query?: {
        /**
         * Limit
         */
        limit?: number;
        /**
         * Name
         */
        name?: string | null;
        /**
         * Role
         */
        role?: string | null;
    };
    url: '/api/v1/admin/accounts/{account_id}/users';
};

export type GetAdminAccountIdUsersErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetAdminAccountIdUsersError = GetAdminAccountIdUsersErrors[keyof GetAdminAccountIdUsersErrors];

export type GetAdminAccountIdUsersResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostAdminAccountIdUsersData = {
    body: RegisterUserRequest;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path: {
        /**
         * Account Id
         *
         * Account ID
         */
        account_id: string;
    };
    query?: never;
    url: '/api/v1/admin/accounts/{account_id}/users';
};

export type PostAdminAccountIdUsersErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostAdminAccountIdUsersError = PostAdminAccountIdUsersErrors[keyof PostAdminAccountIdUsersErrors];

export type PostAdminAccountIdUsersResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type DeleteAdminAccountIdUserByUserIdData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path: {
        /**
         * Account Id
         *
         * Account ID
         */
        account_id: string;
        /**
         * User Id
         *
         * User ID
         */
        user_id: string;
    };
    query?: never;
    url: '/api/v1/admin/accounts/{account_id}/users/{user_id}';
};

export type DeleteAdminAccountIdUserByUserIdErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type DeleteAdminAccountIdUserByUserIdError = DeleteAdminAccountIdUserByUserIdErrors[keyof DeleteAdminAccountIdUserByUserIdErrors];

export type DeleteAdminAccountIdUserByUserIdResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PutAdminAccountIdUserIdRoleData = {
    body: SetRoleRequest;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path: {
        /**
         * Account Id
         *
         * Account ID
         */
        account_id: string;
        /**
         * User Id
         *
         * User ID
         */
        user_id: string;
    };
    query?: never;
    url: '/api/v1/admin/accounts/{account_id}/users/{user_id}/role';
};

export type PutAdminAccountIdUserIdRoleErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PutAdminAccountIdUserIdRoleError = PutAdminAccountIdUserIdRoleErrors[keyof PutAdminAccountIdUserIdRoleErrors];

export type PutAdminAccountIdUserIdRoleResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostAdminAccountIdUserIdKeyData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path: {
        /**
         * Account Id
         *
         * Account ID
         */
        account_id: string;
        /**
         * User Id
         *
         * User ID
         */
        user_id: string;
    };
    query?: never;
    url: '/api/v1/admin/accounts/{account_id}/users/{user_id}/key';
};

export type PostAdminAccountIdUserIdKeyErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostAdminAccountIdUserIdKeyError = PostAdminAccountIdUserIdKeyErrors[keyof PostAdminAccountIdUserIdKeyErrors];

export type PostAdminAccountIdUserIdKeyResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostResourcesTempUploadData = {
    body: BodyTempUploadApiV1ResourcesTempUploadPost;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/resources/temp_upload';
};

export type PostResourcesTempUploadErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostResourcesTempUploadError = PostResourcesTempUploadErrors[keyof PostResourcesTempUploadErrors];

export type PostResourcesTempUploadResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostResourcesData = {
    body: AddResourceRequest;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/resources';
};

export type PostResourcesErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostResourcesError = PostResourcesErrors[keyof PostResourcesErrors];

export type PostResourcesResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostSkillsData = {
    body: AddSkillRequest;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/skills';
};

export type PostSkillsErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostSkillsError = PostSkillsErrors[keyof PostSkillsErrors];

export type PostSkillsResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetFsLsData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query: {
        /**
         * Uri
         *
         * Viking URI
         */
        uri: string;
        /**
         * Simple
         *
         * Return only relative path list
         */
        simple?: boolean;
        /**
         * Recursive
         *
         * List all subdirectories recursively
         */
        recursive?: boolean;
        /**
         * Output
         *
         * Output format: original or agent
         */
        output?: string;
        /**
         * Abs Limit
         *
         * Abstract limit (only for agent output)
         */
        abs_limit?: number;
        /**
         * Show All Hidden
         *
         * List all hidden files, like -a
         */
        show_all_hidden?: boolean;
        /**
         * Node Limit
         *
         * Maximum number of nodes to list
         */
        node_limit?: number;
        /**
         * Limit
         *
         * Alias for node_limit
         */
        limit?: number | null;
    };
    url: '/api/v1/fs/ls';
};

export type GetFsLsErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetFsLsError = GetFsLsErrors[keyof GetFsLsErrors];

export type GetFsLsResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetFsTreeData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query: {
        /**
         * Uri
         *
         * Viking URI
         */
        uri: string;
        /**
         * Output
         *
         * Output format: original or agent
         */
        output?: string;
        /**
         * Abs Limit
         *
         * Abstract limit (only for agent output)
         */
        abs_limit?: number;
        /**
         * Show All Hidden
         *
         * List all hidden files, like -a
         */
        show_all_hidden?: boolean;
        /**
         * Node Limit
         *
         * Maximum number of nodes to list
         */
        node_limit?: number;
        /**
         * Limit
         *
         * Alias for node_limit
         */
        limit?: number | null;
        /**
         * Level Limit
         *
         * Maximum depth level to traverse
         */
        level_limit?: number;
    };
    url: '/api/v1/fs/tree';
};

export type GetFsTreeErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetFsTreeError = GetFsTreeErrors[keyof GetFsTreeErrors];

export type GetFsTreeResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetFsStatData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query: {
        /**
         * Uri
         *
         * Viking URI
         */
        uri: string;
    };
    url: '/api/v1/fs/stat';
};

export type GetFsStatErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetFsStatError = GetFsStatErrors[keyof GetFsStatErrors];

export type GetFsStatResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostFsMkdirData = {
    body: MkdirRequest;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/fs/mkdir';
};

export type PostFsMkdirErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostFsMkdirError = PostFsMkdirErrors[keyof PostFsMkdirErrors];

export type PostFsMkdirResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type DeleteFsData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query: {
        /**
         * Uri
         *
         * Viking URI
         */
        uri: string;
        /**
         * Recursive
         *
         * Remove recursively
         */
        recursive?: boolean;
    };
    url: '/api/v1/fs';
};

export type DeleteFsErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type DeleteFsError = DeleteFsErrors[keyof DeleteFsErrors];

export type DeleteFsResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostFsMvData = {
    body: MvRequest;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/fs/mv';
};

export type PostFsMvErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostFsMvError = PostFsMvErrors[keyof PostFsMvErrors];

export type PostFsMvResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetContentReadData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query: {
        /**
         * Uri
         *
         * Viking URI
         */
        uri: string;
        /**
         * Offset
         *
         * Starting line number (0-indexed)
         */
        offset?: number;
        /**
         * Limit
         *
         * Number of lines to read, -1 means read to end
         */
        limit?: number;
    };
    url: '/api/v1/content/read';
};

export type GetContentReadErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetContentReadError = GetContentReadErrors[keyof GetContentReadErrors];

export type GetContentReadResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetContentAbstractData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query: {
        /**
         * Uri
         *
         * Viking URI
         */
        uri: string;
    };
    url: '/api/v1/content/abstract';
};

export type GetContentAbstractErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetContentAbstractError = GetContentAbstractErrors[keyof GetContentAbstractErrors];

export type GetContentAbstractResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetContentOverviewData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query: {
        /**
         * Uri
         *
         * Viking URI
         */
        uri: string;
    };
    url: '/api/v1/content/overview';
};

export type GetContentOverviewErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetContentOverviewError = GetContentOverviewErrors[keyof GetContentOverviewErrors];

export type GetContentOverviewResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetContentDownloadData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query: {
        /**
         * Uri
         *
         * Viking URI
         */
        uri: string;
    };
    url: '/api/v1/content/download';
};

export type GetContentDownloadErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetContentDownloadError = GetContentDownloadErrors[keyof GetContentDownloadErrors];

export type GetContentDownloadResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostContentWriteData = {
    body: WriteContentRequest;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/content/write';
};

export type PostContentWriteErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostContentWriteError = PostContentWriteErrors[keyof PostContentWriteErrors];

export type PostContentWriteResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostContentReindexData = {
    body: ReindexRequest;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/content/reindex';
};

export type PostContentReindexErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostContentReindexError = PostContentReindexErrors[keyof PostContentReindexErrors];

export type PostContentReindexResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetConsoleDashboardSummaryData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: {
        /**
         * Timezone
         *
         * IANA viewer timezone (e.g. Asia/Shanghai). Defaults to server tz.
         */
        timezone?: string | null;
    };
    url: '/api/v1/console/dashboard/summary';
};

export type GetConsoleDashboardSummaryErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetConsoleDashboardSummaryError = GetConsoleDashboardSummaryErrors[keyof GetConsoleDashboardSummaryErrors];

export type GetConsoleDashboardSummaryResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetConsoleTokensData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query: {
        /**
         * Start Date
         *
         * Start date (viewer-local) in YYYY-MM-DD
         */
        start_date: string;
        /**
         * End Date
         *
         * End date (viewer-local) in YYYY-MM-DD
         */
        end_date: string;
        /**
         * Bucket
         */
        bucket?: string;
        /**
         * Timezone
         *
         * IANA viewer timezone (e.g. Asia/Shanghai). Defaults to server tz.
         */
        timezone?: string | null;
    };
    url: '/api/v1/console/tokens';
};

export type GetConsoleTokensErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetConsoleTokensError = GetConsoleTokensErrors[keyof GetConsoleTokensErrors];

export type GetConsoleTokensResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetConsoleContextCommitsData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query: {
        /**
         * Start Date
         *
         * Start date (viewer-local) in YYYY-MM-DD
         */
        start_date: string;
        /**
         * End Date
         *
         * End date (viewer-local) in YYYY-MM-DD
         */
        end_date: string;
        /**
         * Bucket
         */
        bucket?: string;
        /**
         * Timezone
         *
         * IANA viewer timezone (e.g. Asia/Shanghai). Defaults to server tz.
         */
        timezone?: string | null;
    };
    url: '/api/v1/console/context-commits';
};

export type GetConsoleContextCommitsErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetConsoleContextCommitsError = GetConsoleContextCommitsErrors[keyof GetConsoleContextCommitsErrors];

export type GetConsoleContextCommitsResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetConsoleAuditData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: {
        /**
         * Page
         */
        page?: number;
        /**
         * Page Size
         */
        page_size?: number;
        /**
         * Request Id
         */
        request_id?: string | null;
        /**
         * Status
         */
        status?: Array<string> | null;
        /**
         * Api Type
         */
        api_type?: Array<string> | null;
    };
    url: '/api/v1/console/audit';
};

export type GetConsoleAuditErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetConsoleAuditError = GetConsoleAuditErrors[keyof GetConsoleAuditErrors];

export type GetConsoleAuditResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostSearchFindData = {
    body: FindRequest;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/search/find';
};

export type PostSearchFindErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostSearchFindError = PostSearchFindErrors[keyof PostSearchFindErrors];

export type PostSearchFindResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostSearchSearchData = {
    body: SearchRequest;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/search/search';
};

export type PostSearchSearchErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostSearchSearchError = PostSearchSearchErrors[keyof PostSearchSearchErrors];

export type PostSearchSearchResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostSearchGrepData = {
    body: GrepRequest;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/search/grep';
};

export type PostSearchGrepErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostSearchGrepError = PostSearchGrepErrors[keyof PostSearchGrepErrors];

export type PostSearchGrepResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostSearchGlobData = {
    body: GlobRequest;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/search/glob';
};

export type PostSearchGlobErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostSearchGlobError = PostSearchGlobErrors[keyof PostSearchGlobErrors];

export type PostSearchGlobResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetRelationsData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query: {
        /**
         * Uri
         *
         * Viking URI
         */
        uri: string;
    };
    url: '/api/v1/relations';
};

export type GetRelationsErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetRelationsError = GetRelationsErrors[keyof GetRelationsErrors];

export type GetRelationsResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type DeleteRelationsLinkData = {
    body: UnlinkRequest;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/relations/link';
};

export type DeleteRelationsLinkErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type DeleteRelationsLinkError = DeleteRelationsLinkErrors[keyof DeleteRelationsLinkErrors];

export type DeleteRelationsLinkResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostRelationsLinkData = {
    body: LinkRequest;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/relations/link';
};

export type PostRelationsLinkErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostRelationsLinkError = PostRelationsLinkErrors[keyof PostRelationsLinkErrors];

export type PostRelationsLinkResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetPrivacyConfigsData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/privacy-configs';
};

export type GetPrivacyConfigsErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetPrivacyConfigsError = GetPrivacyConfigsErrors[keyof GetPrivacyConfigsErrors];

export type GetPrivacyConfigsResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetPrivacyConfigsByCategoryData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path: {
        /**
         * Category
         *
         * Privacy config category
         */
        category: string;
    };
    query?: never;
    url: '/api/v1/privacy-configs/{category}';
};

export type GetPrivacyConfigsByCategoryErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetPrivacyConfigsByCategoryError = GetPrivacyConfigsByCategoryErrors[keyof GetPrivacyConfigsByCategoryErrors];

export type GetPrivacyConfigsByCategoryResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetPrivacyConfigsByCategoryAndTargetKeyData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path: {
        /**
         * Category
         *
         * Privacy config category
         */
        category: string;
        /**
         * Target Key
         *
         * Privacy config target key
         */
        target_key: string;
    };
    query?: never;
    url: '/api/v1/privacy-configs/{category}/{target_key}';
};

export type GetPrivacyConfigsByCategoryAndTargetKeyErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetPrivacyConfigsByCategoryAndTargetKeyError = GetPrivacyConfigsByCategoryAndTargetKeyErrors[keyof GetPrivacyConfigsByCategoryAndTargetKeyErrors];

export type GetPrivacyConfigsByCategoryAndTargetKeyResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostPrivacyConfigsByCategoryAndTargetKeyData = {
    body: UpsertPrivacyConfigRequest;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path: {
        /**
         * Category
         *
         * Privacy config category
         */
        category: string;
        /**
         * Target Key
         *
         * Privacy config target key
         */
        target_key: string;
    };
    query?: never;
    url: '/api/v1/privacy-configs/{category}/{target_key}';
};

export type PostPrivacyConfigsByCategoryAndTargetKeyErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostPrivacyConfigsByCategoryAndTargetKeyError = PostPrivacyConfigsByCategoryAndTargetKeyErrors[keyof PostPrivacyConfigsByCategoryAndTargetKeyErrors];

export type PostPrivacyConfigsByCategoryAndTargetKeyResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetPrivacyConfigsVersionsByCategoryAndTargetKeyData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path: {
        /**
         * Category
         *
         * Privacy config category
         */
        category: string;
        /**
         * Target Key
         *
         * Privacy config target key
         */
        target_key: string;
    };
    query?: never;
    url: '/api/v1/privacy-configs/{category}/{target_key}/versions';
};

export type GetPrivacyConfigsVersionsByCategoryAndTargetKeyErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetPrivacyConfigsVersionsByCategoryAndTargetKeyError = GetPrivacyConfigsVersionsByCategoryAndTargetKeyErrors[keyof GetPrivacyConfigsVersionsByCategoryAndTargetKeyErrors];

export type GetPrivacyConfigsVersionsByCategoryAndTargetKeyResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetPrivacyConfigsVersionByCategoryAndTargetKeyAndVersionData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path: {
        /**
         * Category
         *
         * Privacy config category
         */
        category: string;
        /**
         * Target Key
         *
         * Privacy config target key
         */
        target_key: string;
        /**
         * Version
         *
         * Privacy config version
         */
        version: number;
    };
    query?: never;
    url: '/api/v1/privacy-configs/{category}/{target_key}/versions/{version}';
};

export type GetPrivacyConfigsVersionByCategoryAndTargetKeyAndVersionErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetPrivacyConfigsVersionByCategoryAndTargetKeyAndVersionError = GetPrivacyConfigsVersionByCategoryAndTargetKeyAndVersionErrors[keyof GetPrivacyConfigsVersionByCategoryAndTargetKeyAndVersionErrors];

export type GetPrivacyConfigsVersionByCategoryAndTargetKeyAndVersionResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostPrivacyConfigsActivateByCategoryAndTargetKeyData = {
    body: ActivatePrivacyConfigVersionRequest;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path: {
        /**
         * Category
         *
         * Privacy config category
         */
        category: string;
        /**
         * Target Key
         *
         * Privacy config target key
         */
        target_key: string;
    };
    query?: never;
    url: '/api/v1/privacy-configs/{category}/{target_key}/activate';
};

export type PostPrivacyConfigsActivateByCategoryAndTargetKeyErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostPrivacyConfigsActivateByCategoryAndTargetKeyError = PostPrivacyConfigsActivateByCategoryAndTargetKeyErrors[keyof PostPrivacyConfigsActivateByCategoryAndTargetKeyErrors];

export type PostPrivacyConfigsActivateByCategoryAndTargetKeyResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetSessionsData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/sessions';
};

export type GetSessionsErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetSessionsError = GetSessionsErrors[keyof GetSessionsErrors];

export type GetSessionsResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostSessionsData = {
    body?: CreateSessionRequest;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/sessions';
};

export type PostSessionsErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostSessionsError = PostSessionsErrors[keyof PostSessionsErrors];

export type PostSessionsResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type DeleteSessionBySessionIdData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path: {
        /**
         * Session Id
         *
         * Session ID
         */
        session_id: string;
    };
    query?: never;
    url: '/api/v1/sessions/{session_id}';
};

export type DeleteSessionBySessionIdErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type DeleteSessionBySessionIdError = DeleteSessionBySessionIdErrors[keyof DeleteSessionBySessionIdErrors];

export type DeleteSessionBySessionIdResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetSessionBySessionIdData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path: {
        /**
         * Session Id
         *
         * Session ID
         */
        session_id: string;
    };
    query?: {
        /**
         * Auto Create
         *
         * Create the session if it does not exist
         */
        auto_create?: boolean;
    };
    url: '/api/v1/sessions/{session_id}';
};

export type GetSessionBySessionIdErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetSessionBySessionIdError = GetSessionBySessionIdErrors[keyof GetSessionBySessionIdErrors];

export type GetSessionBySessionIdResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetSessionIdContextData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path: {
        /**
         * Session Id
         *
         * Session ID
         */
        session_id: string;
    };
    query?: {
        /**
         * Token Budget
         *
         * Token budget for session context
         */
        token_budget?: number;
    };
    url: '/api/v1/sessions/{session_id}/context';
};

export type GetSessionIdContextErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetSessionIdContextError = GetSessionIdContextErrors[keyof GetSessionIdContextErrors];

export type GetSessionIdContextResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetSessionIdArchiveByArchiveIdData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path: {
        /**
         * Session Id
         *
         * Session ID
         */
        session_id: string;
        /**
         * Archive Id
         *
         * Archive ID
         */
        archive_id: string;
    };
    query?: never;
    url: '/api/v1/sessions/{session_id}/archives/{archive_id}';
};

export type GetSessionIdArchiveByArchiveIdErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetSessionIdArchiveByArchiveIdError = GetSessionIdArchiveByArchiveIdErrors[keyof GetSessionIdArchiveByArchiveIdErrors];

export type GetSessionIdArchiveByArchiveIdResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostSessionIdCommitData = {
    body?: CommitRequest;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path: {
        /**
         * Session Id
         *
         * Session ID
         */
        session_id: string;
    };
    query?: never;
    url: '/api/v1/sessions/{session_id}/commit';
};

export type PostSessionIdCommitErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostSessionIdCommitError = PostSessionIdCommitErrors[keyof PostSessionIdCommitErrors];

export type PostSessionIdCommitResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostSessionIdExtractData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path: {
        /**
         * Session Id
         *
         * Session ID
         */
        session_id: string;
    };
    query?: never;
    url: '/api/v1/sessions/{session_id}/extract';
};

export type PostSessionIdExtractErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostSessionIdExtractError = PostSessionIdExtractErrors[keyof PostSessionIdExtractErrors];

export type PostSessionIdExtractResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostSessionIdMessagesData = {
    body: AddMessageRequest;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path: {
        /**
         * Session Id
         *
         * Session ID
         */
        session_id: string;
    };
    query?: never;
    url: '/api/v1/sessions/{session_id}/messages';
};

export type PostSessionIdMessagesErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostSessionIdMessagesError = PostSessionIdMessagesErrors[keyof PostSessionIdMessagesErrors];

export type PostSessionIdMessagesResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostSessionIdUsedData = {
    body: UsedRequest;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path: {
        /**
         * Session Id
         *
         * Session ID
         */
        session_id: string;
    };
    query?: never;
    url: '/api/v1/sessions/{session_id}/used';
};

export type PostSessionIdUsedErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostSessionIdUsedError = PostSessionIdUsedErrors[keyof PostSessionIdUsedErrors];

export type PostSessionIdUsedResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetStatsMemoriesData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: {
        /**
         * Category
         *
         * Filter by memory category (e.g. cases, patterns, tools)
         */
        category?: string | null;
    };
    url: '/api/v1/stats/memories';
};

export type GetStatsMemoriesErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetStatsMemoriesError = GetStatsMemoriesErrors[keyof GetStatsMemoriesErrors];

export type GetStatsMemoriesResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetStatsSessionBySessionIdData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path: {
        /**
         * Session Id
         *
         * Session ID
         */
        session_id: string;
    };
    query?: never;
    url: '/api/v1/stats/sessions/{session_id}';
};

export type GetStatsSessionBySessionIdErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetStatsSessionBySessionIdError = GetStatsSessionBySessionIdErrors[keyof GetStatsSessionBySessionIdErrors];

export type GetStatsSessionBySessionIdResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostPackExportData = {
    body: ExportRequest;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/pack/export';
};

export type PostPackExportErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostPackExportError = PostPackExportErrors[keyof PostPackExportErrors];

export type PostPackExportResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostPackBackupData = {
    /**
     * Body
     */
    body?: BackupRequest | null;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/pack/backup';
};

export type PostPackBackupErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostPackBackupError = PostPackBackupErrors[keyof PostPackBackupErrors];

export type PostPackBackupResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostPackImportData = {
    body: ImportRequest;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/pack/import';
};

export type PostPackImportErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostPackImportError = PostPackImportErrors[keyof PostPackImportErrors];

export type PostPackImportResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostPackRestoreData = {
    body: RestoreRequest;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/pack/restore';
};

export type PostPackRestoreErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostPackRestoreError = PostPackRestoreErrors[keyof PostPackRestoreErrors];

export type PostPackRestoreResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetDebugHealthData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/debug/health';
};

export type GetDebugHealthErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetDebugHealthError = GetDebugHealthErrors[keyof GetDebugHealthErrors];

export type GetDebugHealthResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetDebugVectorScrollData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: {
        /**
         * Limit
         */
        limit?: number;
        /**
         * Cursor
         */
        cursor?: string | null;
        /**
         * Uri
         */
        uri?: string | null;
    };
    url: '/api/v1/debug/vector/scroll';
};

export type GetDebugVectorScrollErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetDebugVectorScrollError = GetDebugVectorScrollErrors[keyof GetDebugVectorScrollErrors];

export type GetDebugVectorScrollResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetDebugVectorCountData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: {
        /**
         * Filter
         */
        filter?: string | null;
        /**
         * Uri
         */
        uri?: string | null;
    };
    url: '/api/v1/debug/vector/count';
};

export type GetDebugVectorCountErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetDebugVectorCountError = GetDebugVectorCountErrors[keyof GetDebugVectorCountErrors];

export type GetDebugVectorCountResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetObserverQueueData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/observer/queue';
};

export type GetObserverQueueErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetObserverQueueError = GetObserverQueueErrors[keyof GetObserverQueueErrors];

export type GetObserverQueueResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetObserverVikingdbData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/observer/vikingdb';
};

export type GetObserverVikingdbErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetObserverVikingdbError = GetObserverVikingdbErrors[keyof GetObserverVikingdbErrors];

export type GetObserverVikingdbResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetObserverModelsData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/observer/models';
};

export type GetObserverModelsErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetObserverModelsError = GetObserverModelsErrors[keyof GetObserverModelsErrors];

export type GetObserverModelsResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetObserverLockData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/observer/lock';
};

export type GetObserverLockErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetObserverLockError = GetObserverLockErrors[keyof GetObserverLockErrors];

export type GetObserverLockResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetObserverRetrievalData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/observer/retrieval';
};

export type GetObserverRetrievalErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetObserverRetrievalError = GetObserverRetrievalErrors[keyof GetObserverRetrievalErrors];

export type GetObserverRetrievalResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetObserverFilesystemData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/observer/filesystem';
};

export type GetObserverFilesystemErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetObserverFilesystemError = GetObserverFilesystemErrors[keyof GetObserverFilesystemErrors];

export type GetObserverFilesystemResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetObserverSystemData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/api/v1/observer/system';
};

export type GetObserverSystemErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetObserverSystemError = GetObserverSystemErrors[keyof GetObserverSystemErrors];

export type GetObserverSystemResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetMetricsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/metrics';
};

export type GetMetricsResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetTaskByTaskIdData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path: {
        /**
         * Task Id
         */
        task_id: string;
    };
    query?: never;
    url: '/api/v1/tasks/{task_id}';
};

export type GetTaskByTaskIdErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetTaskByTaskIdError = GetTaskByTaskIdErrors[keyof GetTaskByTaskIdErrors];

export type GetTaskByTaskIdResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetTasksData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: {
        /**
         * Task Type
         *
         * Filter by task type (e.g. session_commit)
         */
        task_type?: string | null;
        /**
         * Status
         *
         * Filter by status (pending/running/completed/failed)
         */
        status?: string | null;
        /**
         * Resource Id
         *
         * Filter by resource ID (e.g. session_id)
         */
        resource_id?: string | null;
        /**
         * Limit
         *
         * Max results
         */
        limit?: number;
    };
    url: '/api/v1/tasks';
};

export type GetTasksErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetTasksError = GetTasksErrors[keyof GetTasksErrors];

export type GetTasksResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type DeleteWebdavResourceByResourcePathData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path: {
        /**
         * Resource Path
         */
        resource_path: string;
    };
    query?: never;
    url: '/webdav/resources/{resource_path}';
};

export type DeleteWebdavResourceByResourcePathErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type DeleteWebdavResourceByResourcePathError = DeleteWebdavResourceByResourcePathErrors[keyof DeleteWebdavResourceByResourcePathErrors];

export type DeleteWebdavResourceByResourcePathResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetWebdavResourceByResourcePathData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path: {
        /**
         * Resource Path
         */
        resource_path: string;
    };
    query?: never;
    url: '/webdav/resources/{resource_path}';
};

export type GetWebdavResourceByResourcePathErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetWebdavResourceByResourcePathError = GetWebdavResourceByResourcePathErrors[keyof GetWebdavResourceByResourcePathErrors];

export type GetWebdavResourceByResourcePathResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type HeadWebdavResourceByResourcePathData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path: {
        /**
         * Resource Path
         */
        resource_path: string;
    };
    query?: never;
    url: '/webdav/resources/{resource_path}';
};

export type HeadWebdavResourceByResourcePathErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type HeadWebdavResourceByResourcePathError = HeadWebdavResourceByResourcePathErrors[keyof HeadWebdavResourceByResourcePathErrors];

export type HeadWebdavResourceByResourcePathResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type OptionsWebdavResourceByResourcePathData = {
    body?: never;
    path: {
        /**
         * Resource Path
         */
        resource_path: string;
    };
    query?: never;
    url: '/webdav/resources/{resource_path}';
};

export type OptionsWebdavResourceByResourcePathErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type OptionsWebdavResourceByResourcePathError = OptionsWebdavResourceByResourcePathErrors[keyof OptionsWebdavResourceByResourcePathErrors];

export type OptionsWebdavResourceByResourcePathResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PutWebdavResourceByResourcePathData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path: {
        /**
         * Resource Path
         */
        resource_path: string;
    };
    query?: never;
    url: '/webdav/resources/{resource_path}';
};

export type PutWebdavResourceByResourcePathErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PutWebdavResourceByResourcePathError = PutWebdavResourceByResourcePathErrors[keyof PutWebdavResourceByResourcePathErrors];

export type PutWebdavResourceByResourcePathResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type DeleteWebdavResourcesData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: {
        /**
         * Resource Path
         */
        resource_path?: string;
    };
    url: '/webdav/resources';
};

export type DeleteWebdavResourcesErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type DeleteWebdavResourcesError = DeleteWebdavResourcesErrors[keyof DeleteWebdavResourcesErrors];

export type DeleteWebdavResourcesResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetWebdavResourcesData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: {
        /**
         * Resource Path
         */
        resource_path?: string;
    };
    url: '/webdav/resources';
};

export type GetWebdavResourcesErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type GetWebdavResourcesError = GetWebdavResourcesErrors[keyof GetWebdavResourcesErrors];

export type GetWebdavResourcesResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type HeadWebdavResourcesData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: {
        /**
         * Resource Path
         */
        resource_path?: string;
    };
    url: '/webdav/resources';
};

export type HeadWebdavResourcesErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type HeadWebdavResourcesError = HeadWebdavResourcesErrors[keyof HeadWebdavResourcesErrors];

export type HeadWebdavResourcesResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type OptionsWebdavResourcesData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Resource Path
         */
        resource_path?: string;
    };
    url: '/webdav/resources';
};

export type OptionsWebdavResourcesErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type OptionsWebdavResourcesError = OptionsWebdavResourcesErrors[keyof OptionsWebdavResourcesErrors];

export type OptionsWebdavResourcesResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PutWebdavResourcesData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: {
        /**
         * Resource Path
         */
        resource_path?: string;
    };
    url: '/webdav/resources';
};

export type PutWebdavResourcesErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PutWebdavResourcesError = PutWebdavResourcesErrors[keyof PutWebdavResourcesErrors];

export type PutWebdavResourcesResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type GetBotV1HealthData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/bot/v1/health';
};

export type GetBotV1HealthResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostBotV1ChatData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/bot/v1/chat';
};

export type PostBotV1ChatErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostBotV1ChatError = PostBotV1ChatErrors[keyof PostBotV1ChatErrors];

export type PostBotV1ChatResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostBotV1FeedbackData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/bot/v1/feedback';
};

export type PostBotV1FeedbackErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostBotV1FeedbackError = PostBotV1FeedbackErrors[keyof PostBotV1FeedbackErrors];

export type PostBotV1FeedbackResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};

export type PostBotV1ChatStreamData = {
    body?: never;
    headers?: {
        /**
         * X-Api-Key
         */
        'x-api-key'?: string | null;
        /**
         * Authorization
         */
        authorization?: string | null;
        /**
         * X-Openviking-Account
         */
        'X-OpenViking-Account'?: string | null;
        /**
         * X-Openviking-User
         */
        'X-OpenViking-User'?: string | null;
    };
    path?: never;
    query?: never;
    url: '/bot/v1/chat/stream';
};

export type PostBotV1ChatStreamErrors = {
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type PostBotV1ChatStreamError = PostBotV1ChatStreamErrors[keyof PostBotV1ChatStreamErrors];

export type PostBotV1ChatStreamResponses = {
    /**
     * Successful Response
     */
    200: unknown;
};
