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

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

/**
 * AddMemberRequest
 *
 * Request to add a member to an organization.
 */
export type AddMemberRequest = {
    /**
     * User Id
     *
     * User ID to add
     */
    user_id: string;
    /**
     * Role in organization
     */
    role?: OrganizationRole;
};

/**
 * AdminSessionResponse
 *
 * Schema for session responses in admin panel.
 *
 * Includes user information for admin to see who owns each session.
 */
export type AdminSessionResponse = {
    /**
     * Device Name
     *
     * Friendly device name
     */
    device_name?: string | null;
    /**
     * Device Id
     *
     * Persistent device identifier
     */
    device_id?: string | null;
    /**
     * Id
     */
    id: string;
    /**
     * User Id
     */
    user_id: string;
    /**
     * User Email
     *
     * Email of the user who owns this session
     */
    user_email: string;
    /**
     * User Full Name
     *
     * Full name of the user
     */
    user_full_name?: string | null;
    /**
     * Ip Address
     */
    ip_address?: string | null;
    /**
     * Location City
     */
    location_city?: string | null;
    /**
     * Location Country
     */
    location_country?: string | null;
    /**
     * Last Used At
     */
    last_used_at: string;
    /**
     * Created At
     */
    created_at: string;
    /**
     * Expires At
     */
    expires_at: string;
    /**
     * Is Active
     */
    is_active: boolean;
};

/**
 * AdminStatsResponse
 */
export type AdminStatsResponse = {
    /**
     * User Growth
     */
    user_growth: Array<UserGrowthData>;
    /**
     * Organization Distribution
     */
    organization_distribution: Array<OrgDistributionData>;
    /**
     * Registration Activity
     */
    registration_activity: Array<RegistrationActivityData>;
    /**
     * User Status
     */
    user_status: Array<UserStatusData>;
};

/**
 * AgentInstanceCreate
 *
 * Schema for creating a new agent instance.
 */
export type AgentInstanceCreate = {
    /**
     * Agent Type Id
     */
    agent_type_id: string;
    /**
     * Project Id
     */
    project_id: string;
    /**
     * Name
     */
    name: string;
    status?: AgentStatus;
    /**
     * Current Task
     */
    current_task?: string | null;
    /**
     * Short Term Memory
     */
    short_term_memory?: {
        [key: string]: unknown;
    };
    /**
     * Long Term Memory Ref
     */
    long_term_memory_ref?: string | null;
    /**
     * Session Id
     */
    session_id?: string | null;
};

/**
 * AgentInstanceMetrics
 *
 * Schema for agent instance metrics summary.
 */
export type AgentInstanceMetrics = {
    /**
     * Total Instances
     */
    total_instances: number;
    /**
     * Active Instances
     */
    active_instances: number;
    /**
     * Idle Instances
     */
    idle_instances: number;
    /**
     * Total Tasks Completed
     */
    total_tasks_completed: number;
    /**
     * Total Tokens Used
     */
    total_tokens_used: number;
    /**
     * Total Cost Incurred
     */
    total_cost_incurred: string;
};

/**
 * AgentInstanceResponse
 *
 * Schema for agent instance API responses.
 */
export type AgentInstanceResponse = {
    /**
     * Id
     */
    id: string;
    /**
     * Agent Type Id
     */
    agent_type_id: string;
    /**
     * Project Id
     */
    project_id: string;
    /**
     * Name
     */
    name: string;
    status: AgentStatus;
    /**
     * Current Task
     */
    current_task?: string | null;
    /**
     * Short Term Memory
     */
    short_term_memory?: {
        [key: string]: unknown;
    };
    /**
     * Long Term Memory Ref
     */
    long_term_memory_ref?: string | null;
    /**
     * Session Id
     */
    session_id?: string | null;
    /**
     * Last Activity At
     */
    last_activity_at?: string | null;
    /**
     * Terminated At
     */
    terminated_at?: string | null;
    /**
     * Tasks Completed
     */
    tasks_completed?: number;
    /**
     * Tokens Used
     */
    tokens_used?: number;
    /**
     * Cost Incurred
     */
    cost_incurred?: string;
    /**
     * Created At
     */
    created_at: string;
    /**
     * Updated At
     */
    updated_at: string;
    /**
     * Agent Type Name
     */
    agent_type_name?: string | null;
    /**
     * Agent Type Slug
     */
    agent_type_slug?: string | null;
    /**
     * Project Name
     */
    project_name?: string | null;
    /**
     * Project Slug
     */
    project_slug?: string | null;
    /**
     * Assigned Issues Count
     */
    assigned_issues_count?: number | null;
};

/**
 * AgentInstanceUpdate
 *
 * Schema for updating an agent instance.
 */
export type AgentInstanceUpdate = {
    status?: AgentStatus | null;
    /**
     * Current Task
     */
    current_task?: string | null;
    /**
     * Short Term Memory
     */
    short_term_memory?: {
        [key: string]: unknown;
    } | null;
    /**
     * Long Term Memory Ref
     */
    long_term_memory_ref?: string | null;
    /**
     * Session Id
     */
    session_id?: string | null;
    /**
     * Last Activity At
     */
    last_activity_at?: string | null;
    /**
     * Tasks Completed
     */
    tasks_completed?: number | null;
    /**
     * Tokens Used
     */
    tokens_used?: number | null;
    /**
     * Cost Incurred
     */
    cost_incurred?: number | string | null;
};

/**
 * AgentStatus
 *
 * Current operational status of an agent instance.
 *
 * IDLE: Agent is available but not currently working
 * WORKING: Agent is actively processing a task
 * WAITING: Agent is waiting for external input or approval
 * PAUSED: Agent has been manually paused
 * TERMINATED: Agent instance has been shut down
 */
export type AgentStatus = 'idle' | 'working' | 'waiting' | 'paused' | 'terminated';

/**
 * AgentTypeCreate
 *
 * Schema for creating a new agent type.
 */
export type AgentTypeCreate = {
    /**
     * Name
     */
    name: string;
    /**
     * Slug
     */
    slug: string;
    /**
     * Description
     */
    description?: string | null;
    /**
     * Expertise
     */
    expertise?: Array<string>;
    /**
     * Personality Prompt
     */
    personality_prompt: string;
    /**
     * Primary Model
     */
    primary_model: string;
    /**
     * Fallback Models
     */
    fallback_models?: Array<string>;
    /**
     * Model Params
     */
    model_params?: {
        [key: string]: unknown;
    };
    /**
     * Mcp Servers
     */
    mcp_servers?: Array<string>;
    /**
     * Tool Permissions
     */
    tool_permissions?: {
        [key: string]: unknown;
    };
    /**
     * Is Active
     */
    is_active?: boolean;
};

/**
 * AgentTypeResponse
 *
 * Schema for agent type API responses.
 */
export type AgentTypeResponse = {
    /**
     * Name
     */
    name: string;
    /**
     * Slug
     */
    slug?: string | null;
    /**
     * Description
     */
    description?: string | null;
    /**
     * Expertise
     */
    expertise?: Array<string>;
    /**
     * Personality Prompt
     */
    personality_prompt: string;
    /**
     * Primary Model
     */
    primary_model: string;
    /**
     * Fallback Models
     */
    fallback_models?: Array<string>;
    /**
     * Model Params
     */
    model_params?: {
        [key: string]: unknown;
    };
    /**
     * Mcp Servers
     */
    mcp_servers?: Array<string>;
    /**
     * Tool Permissions
     */
    tool_permissions?: {
        [key: string]: unknown;
    };
    /**
     * Is Active
     */
    is_active?: boolean;
    /**
     * Id
     */
    id: string;
    /**
     * Created At
     */
    created_at: string;
    /**
     * Updated At
     */
    updated_at: string;
    /**
     * Instance Count
     */
    instance_count?: number | null;
};

/**
 * AgentTypeUpdate
 *
 * Schema for updating an agent type.
 */
export type AgentTypeUpdate = {
    /**
     * Name
     */
    name?: string | null;
    /**
     * Slug
     */
    slug?: string | null;
    /**
     * Description
     */
    description?: string | null;
    /**
     * Expertise
     */
    expertise?: Array<string> | null;
    /**
     * Personality Prompt
     */
    personality_prompt?: string | null;
    /**
     * Primary Model
     */
    primary_model?: string | null;
    /**
     * Fallback Models
     */
    fallback_models?: Array<string> | null;
    /**
     * Model Params
     */
    model_params?: {
        [key: string]: unknown;
    } | null;
    /**
     * Mcp Servers
     */
    mcp_servers?: Array<string> | null;
    /**
     * Tool Permissions
     */
    tool_permissions?: {
        [key: string]: unknown;
    } | null;
    /**
     * Is Active
     */
    is_active?: boolean | null;
};

/**
 * AutonomyLevel
 *
 * Defines how much control the human has over agent actions.
 *
 * FULL_CONTROL: Human must approve every agent action
 * MILESTONE: Human approves at sprint boundaries and major decisions
 * AUTONOMOUS: Agents work independently, only escalating critical issues
 */
export type AutonomyLevel = 'full_control' | 'milestone' | 'autonomous';

/**
 * Body_login_oauth
 */
export type BodyLoginOauth = {
    /**
     * Grant Type
     */
    grant_type?: string | null;
    /**
     * Username
     */
    username: string;
    /**
     * Password
     */
    password: string;
    /**
     * Scope
     */
    scope?: string;
    /**
     * Client Id
     */
    client_id?: string | null;
    /**
     * Client Secret
     */
    client_secret?: string | null;
};

/**
 * Body_oauth_provider_consent
 */
export type BodyOauthProviderConsent = {
    /**
     * Approved
     *
     * Whether user approved
     */
    approved: boolean;
    /**
     * Client Id
     *
     * OAuth client ID
     */
    client_id: string;
    /**
     * Redirect Uri
     *
     * Redirect URI
     */
    redirect_uri: string;
    /**
     * Scope
     *
     * Granted scopes
     */
    scope?: string;
    /**
     * State
     *
     * CSRF state parameter
     */
    state?: string;
    /**
     * Code Challenge
     */
    code_challenge?: string | null;
    /**
     * Code Challenge Method
     */
    code_challenge_method?: string | null;
    /**
     * Nonce
     */
    nonce?: string | null;
};

/**
 * Body_oauth_provider_introspect
 */
export type BodyOauthProviderIntrospect = {
    /**
     * Token
     *
     * Token to introspect
     */
    token: string;
    /**
     * Token Type Hint
     *
     * Token type hint (access_token, refresh_token)
     */
    token_type_hint?: string | null;
    /**
     * Client Id
     *
     * Client ID
     */
    client_id?: string | null;
    /**
     * Client Secret
     *
     * Client secret
     */
    client_secret?: string | null;
};

/**
 * Body_oauth_provider_revoke
 */
export type BodyOauthProviderRevoke = {
    /**
     * Token
     *
     * Token to revoke
     */
    token: string;
    /**
     * Token Type Hint
     *
     * Token type hint (access_token, refresh_token)
     */
    token_type_hint?: string | null;
    /**
     * Client Id
     *
     * Client ID
     */
    client_id?: string | null;
    /**
     * Client Secret
     *
     * Client secret
     */
    client_secret?: string | null;
};

/**
 * Body_oauth_provider_token
 */
export type BodyOauthProviderToken = {
    /**
     * Grant Type
     *
     * Grant type
     */
    grant_type: string;
    /**
     * Code
     *
     * Authorization code
     */
    code?: string | null;
    /**
     * Redirect Uri
     *
     * Redirect URI
     */
    redirect_uri?: string | null;
    /**
     * Client Id
     *
     * Client ID
     */
    client_id?: string | null;
    /**
     * Client Secret
     *
     * Client secret
     */
    client_secret?: string | null;
    /**
     * Code Verifier
     *
     * PKCE code verifier
     */
    code_verifier?: string | null;
    /**
     * Refresh Token
     *
     * Refresh token
     */
    refresh_token?: string | null;
    /**
     * Scope
     *
     * Scope (for refresh)
     */
    scope?: string | null;
};

/**
 * Body_register_oauth_client
 */
export type BodyRegisterOauthClient = {
    /**
     * Client Name
     *
     * Client application name
     */
    client_name: string;
    /**
     * Redirect Uris
     *
     * Comma-separated redirect URIs
     */
    redirect_uris: string;
    /**
     * Client Type
     *
     * public or confidential
     */
    client_type?: string;
    /**
     * Scopes
     *
     * Allowed scopes (space-separated)
     */
    scopes?: string;
    /**
     * Mcp Server Url
     *
     * MCP server URL
     */
    mcp_server_url?: string | null;
};

/**
 * BulkAction
 *
 * Supported bulk actions.
 */
export type BulkAction = 'activate' | 'deactivate' | 'delete';

/**
 * BulkActionResult
 *
 * Result of a bulk action.
 */
export type BulkActionResult = {
    /**
     * Success
     */
    success: boolean;
    /**
     * Affected Count
     */
    affected_count: number;
    /**
     * Failed Count
     */
    failed_count: number;
    /**
     * Message
     */
    message: string;
    /**
     * Failed Ids
     */
    failed_ids?: Array<string> | null;
};

/**
 * BulkUserAction
 *
 * Schema for bulk user actions.
 */
export type BulkUserAction = {
    /**
     * Action to perform on selected users
     */
    action: BulkAction;
    /**
     * User Ids
     *
     * List of user IDs (max 100)
     */
    user_ids: Array<string>;
};

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

/**
 * IssueAssign
 *
 * Schema for assigning an issue.
 */
export type IssueAssign = {
    /**
     * Assigned Agent Id
     */
    assigned_agent_id?: string | null;
    /**
     * Human Assignee
     */
    human_assignee?: string | null;
};

/**
 * IssueCreate
 *
 * Schema for creating a new issue.
 */
export type IssueCreate = {
    /**
     * Title
     */
    title: string;
    /**
     * Body
     */
    body?: string;
    status?: IssueStatus;
    priority?: IssuePriority;
    /**
     * Labels
     */
    labels?: Array<string>;
    /**
     * Story Points
     */
    story_points?: number | null;
    /**
     * Project Id
     */
    project_id: string;
    /**
     * Assigned Agent Id
     */
    assigned_agent_id?: string | null;
    /**
     * Human Assignee
     */
    human_assignee?: string | null;
    /**
     * Sprint Id
     */
    sprint_id?: string | null;
    /**
     * External Tracker Type
     */
    external_tracker_type?: 'gitea' | 'github' | 'gitlab' | null;
    /**
     * External Issue Id
     */
    external_issue_id?: string | null;
    /**
     * Remote Url
     */
    remote_url?: string | null;
    /**
     * External Issue Number
     */
    external_issue_number?: number | null;
};

/**
 * IssuePriority
 *
 * Issue priority levels.
 *
 * LOW: Nice to have, can be deferred
 * MEDIUM: Standard priority, should be done
 * HIGH: Important, should be prioritized
 * CRITICAL: Must be done immediately, blocking other work
 */
export type IssuePriority = 'low' | 'medium' | 'high' | 'critical';

/**
 * IssueResponse
 *
 * Schema for issue API responses.
 */
export type IssueResponse = {
    /**
     * Id
     */
    id: string;
    /**
     * Project Id
     */
    project_id: string;
    /**
     * Title
     */
    title: string;
    /**
     * Body
     */
    body: string;
    status: IssueStatus;
    priority: IssuePriority;
    /**
     * Labels
     */
    labels?: Array<string>;
    /**
     * Assigned Agent Id
     */
    assigned_agent_id?: string | null;
    /**
     * Human Assignee
     */
    human_assignee?: string | null;
    /**
     * Sprint Id
     */
    sprint_id?: string | null;
    /**
     * Story Points
     */
    story_points?: number | null;
    /**
     * External Tracker Type
     */
    external_tracker_type?: string | null;
    /**
     * External Issue Id
     */
    external_issue_id?: string | null;
    /**
     * Remote Url
     */
    remote_url?: string | null;
    /**
     * External Issue Number
     */
    external_issue_number?: number | null;
    sync_status?: SyncStatus;
    /**
     * Last Synced At
     */
    last_synced_at?: string | null;
    /**
     * External Updated At
     */
    external_updated_at?: string | null;
    /**
     * Closed At
     */
    closed_at?: string | null;
    /**
     * Created At
     */
    created_at: string;
    /**
     * Updated At
     */
    updated_at: string;
    /**
     * Project Name
     */
    project_name?: string | null;
    /**
     * Project Slug
     */
    project_slug?: string | null;
    /**
     * Sprint Name
     */
    sprint_name?: string | null;
    /**
     * Assigned Agent Type Name
     */
    assigned_agent_type_name?: string | null;
};

/**
 * IssueStats
 *
 * Schema for issue statistics.
 */
export type IssueStats = {
    /**
     * Total
     */
    total: number;
    /**
     * Open
     */
    open: number;
    /**
     * In Progress
     */
    in_progress: number;
    /**
     * In Review
     */
    in_review: number;
    /**
     * Blocked
     */
    blocked: number;
    /**
     * Closed
     */
    closed: number;
    /**
     * By Priority
     */
    by_priority: {
        [key: string]: number;
    };
    /**
     * Total Story Points
     */
    total_story_points?: number | null;
    /**
     * Completed Story Points
     */
    completed_story_points?: number | null;
};

/**
 * IssueStatus
 *
 * Issue workflow status.
 *
 * OPEN: Issue is ready to be worked on
 * IN_PROGRESS: Agent or human is actively working on the issue
 * IN_REVIEW: Work is complete, awaiting review
 * BLOCKED: Issue cannot proceed due to dependencies or blockers
 * CLOSED: Issue has been completed or cancelled
 */
export type IssueStatus = 'open' | 'in_progress' | 'in_review' | 'blocked' | 'closed';

/**
 * IssueUpdate
 *
 * Schema for updating an issue.
 */
export type IssueUpdate = {
    /**
     * Title
     */
    title?: string | null;
    /**
     * Body
     */
    body?: string | null;
    status?: IssueStatus | null;
    priority?: IssuePriority | null;
    /**
     * Labels
     */
    labels?: Array<string> | null;
    /**
     * Assigned Agent Id
     */
    assigned_agent_id?: string | null;
    /**
     * Human Assignee
     */
    human_assignee?: string | null;
    /**
     * Sprint Id
     */
    sprint_id?: string | null;
    /**
     * Story Points
     */
    story_points?: number | null;
    sync_status?: SyncStatus | null;
};

/**
 * LoginRequest
 */
export type LoginRequest = {
    /**
     * Email
     */
    email: string;
    /**
     * Password
     */
    password: string;
};

/**
 * LogoutRequest
 *
 * Request schema for logout endpoint.
 */
export type LogoutRequest = {
    /**
     * Refresh Token
     *
     * Refresh token for the session to logout from
     */
    refresh_token: string;
};

/**
 * MessageResponse
 *
 * Simple message response.
 */
export type MessageResponse = {
    /**
     * Success
     *
     * Operation success status
     */
    success?: boolean;
    /**
     * Message
     *
     * Human-readable message
     */
    message: string;
};

/**
 * OAuthAccountResponse
 *
 * Schema for OAuth account response to clients.
 */
export type OAuthAccountResponse = {
    /**
     * Provider
     *
     * OAuth provider name
     */
    provider: string;
    /**
     * Provider Email
     *
     * Email from OAuth provider
     */
    provider_email?: string | null;
    /**
     * Id
     */
    id: string;
    /**
     * Created At
     */
    created_at: string;
};

/**
 * OAuthAccountsListResponse
 *
 * Response containing list of linked OAuth accounts.
 */
export type OAuthAccountsListResponse = {
    /**
     * Accounts
     */
    accounts: Array<OAuthAccountResponse>;
};

/**
 * OAuthCallbackRequest
 *
 * Request parameters for OAuth callback.
 */
export type OAuthCallbackRequest = {
    /**
     * Code
     *
     * Authorization code from provider
     */
    code: string;
    /**
     * State
     *
     * State parameter for CSRF protection
     */
    state: string;
};

/**
 * OAuthCallbackResponse
 *
 * Response after successful OAuth authentication.
 */
export type OAuthCallbackResponse = {
    /**
     * Access Token
     *
     * JWT access token
     */
    access_token: string;
    /**
     * Refresh Token
     *
     * JWT refresh token
     */
    refresh_token: string;
    /**
     * Token Type
     */
    token_type?: string;
    /**
     * Expires In
     *
     * Token expiration in seconds
     */
    expires_in: number;
    /**
     * Is New User
     *
     * Whether a new user was created
     */
    is_new_user?: boolean;
};

/**
 * OAuthClientResponse
 *
 * Schema for OAuth client response.
 */
export type OAuthClientResponse = {
    /**
     * Client Name
     *
     * Client application name
     */
    client_name: string;
    /**
     * Client Description
     *
     * Client description
     */
    client_description?: string | null;
    /**
     * Redirect Uris
     *
     * Allowed redirect URIs
     */
    redirect_uris?: Array<string>;
    /**
     * Allowed Scopes
     *
     * Allowed OAuth scopes
     */
    allowed_scopes?: Array<string>;
    /**
     * Id
     */
    id: string;
    /**
     * Client Id
     *
     * OAuth client ID
     */
    client_id: string;
    /**
     * Client Type
     */
    client_type: string;
    /**
     * Is Active
     */
    is_active: boolean;
    /**
     * Created At
     */
    created_at: string;
};

/**
 * OAuthProviderInfo
 *
 * Information about an available OAuth provider.
 */
export type OAuthProviderInfo = {
    /**
     * Provider
     *
     * Provider identifier (google, github)
     */
    provider: string;
    /**
     * Name
     *
     * Human-readable provider name
     */
    name: string;
    /**
     * Icon
     *
     * Icon identifier for frontend
     */
    icon?: string | null;
};

/**
 * OAuthProvidersResponse
 *
 * Response containing list of enabled OAuth providers.
 */
export type OAuthProvidersResponse = {
    /**
     * Enabled
     *
     * Whether OAuth is globally enabled
     */
    enabled: boolean;
    /**
     * Providers
     *
     * List of enabled providers
     */
    providers?: Array<OAuthProviderInfo>;
};

/**
 * OAuthServerMetadata
 *
 * OAuth 2.0 Authorization Server Metadata (RFC 8414).
 */
export type OAuthServerMetadata = {
    /**
     * Issuer
     *
     * Authorization server issuer URL
     */
    issuer: string;
    /**
     * Authorization Endpoint
     *
     * Authorization endpoint URL
     */
    authorization_endpoint: string;
    /**
     * Token Endpoint
     *
     * Token endpoint URL
     */
    token_endpoint: string;
    /**
     * Registration Endpoint
     *
     * Dynamic client registration endpoint
     */
    registration_endpoint?: string | null;
    /**
     * Revocation Endpoint
     *
     * Token revocation endpoint
     */
    revocation_endpoint?: string | null;
    /**
     * Introspection Endpoint
     *
     * Token introspection endpoint (RFC 7662)
     */
    introspection_endpoint?: string | null;
    /**
     * Scopes Supported
     *
     * Supported scopes
     */
    scopes_supported?: Array<string>;
    /**
     * Response Types Supported
     *
     * Supported response types
     */
    response_types_supported?: Array<string>;
    /**
     * Grant Types Supported
     *
     * Supported grant types
     */
    grant_types_supported?: Array<string>;
    /**
     * Code Challenge Methods Supported
     *
     * Supported PKCE methods
     */
    code_challenge_methods_supported?: Array<string>;
    /**
     * Token Endpoint Auth Methods Supported
     *
     * Supported client authentication methods
     */
    token_endpoint_auth_methods_supported?: Array<string>;
};

/**
 * OAuthTokenIntrospectionResponse
 *
 * OAuth 2.0 Token Introspection Response (RFC 7662).
 */
export type OAuthTokenIntrospectionResponse = {
    /**
     * Active
     *
     * Whether the token is currently active
     */
    active: boolean;
    /**
     * Scope
     *
     * Space-separated list of scopes
     */
    scope?: string | null;
    /**
     * Client Id
     *
     * Client identifier for the token
     */
    client_id?: string | null;
    /**
     * Username
     *
     * Human-readable identifier for the resource owner
     */
    username?: string | null;
    /**
     * Token Type
     *
     * Type of the token (e.g., 'Bearer')
     */
    token_type?: string | null;
    /**
     * Exp
     *
     * Token expiration time (Unix timestamp)
     */
    exp?: number | null;
    /**
     * Iat
     *
     * Token issue time (Unix timestamp)
     */
    iat?: number | null;
    /**
     * Nbf
     *
     * Token not-before time (Unix timestamp)
     */
    nbf?: number | null;
    /**
     * Sub
     *
     * Subject of the token (user ID)
     */
    sub?: string | null;
    /**
     * Aud
     *
     * Intended audience of the token
     */
    aud?: string | null;
    /**
     * Iss
     *
     * Issuer of the token
     */
    iss?: string | null;
};

/**
 * OAuthTokenResponse
 *
 * OAuth 2.0 Token Response (RFC 6749 Section 5.1).
 */
export type OAuthTokenResponse = {
    /**
     * Access Token
     *
     * The access token issued by the server
     */
    access_token: string;
    /**
     * Token Type
     *
     * The type of token (typically 'Bearer')
     */
    token_type?: string;
    /**
     * Expires In
     *
     * Token lifetime in seconds
     */
    expires_in?: number | null;
    /**
     * Refresh Token
     *
     * Refresh token for obtaining new access tokens
     */
    refresh_token?: string | null;
    /**
     * Scope
     *
     * Space-separated list of granted scopes
     */
    scope?: string | null;
};

/**
 * OAuthUnlinkResponse
 *
 * Response after unlinking an OAuth account.
 */
export type OAuthUnlinkResponse = {
    /**
     * Success
     *
     * Whether the unlink was successful
     */
    success: boolean;
    /**
     * Message
     *
     * Status message
     */
    message: string;
};

/**
 * OrgDistributionData
 */
export type OrgDistributionData = {
    /**
     * Name
     */
    name: string;
    /**
     * Value
     */
    value: number;
};

/**
 * OrganizationCreate
 *
 * Schema for creating a new organization.
 */
export type OrganizationCreate = {
    /**
     * Name
     */
    name: string;
    /**
     * Slug
     */
    slug: string;
    /**
     * Description
     */
    description?: string | null;
    /**
     * Is Active
     */
    is_active?: boolean;
    /**
     * Settings
     */
    settings?: {
        [key: string]: unknown;
    } | null;
};

/**
 * OrganizationMemberResponse
 *
 * Schema for organization member information.
 */
export type OrganizationMemberResponse = {
    /**
     * User Id
     */
    user_id: string;
    /**
     * Email
     */
    email: string;
    /**
     * First Name
     */
    first_name: string;
    /**
     * Last Name
     */
    last_name?: string | null;
    role: OrganizationRole;
    /**
     * Is Active
     */
    is_active: boolean;
    /**
     * Joined At
     */
    joined_at: string;
};

/**
 * OrganizationResponse
 *
 * Schema for organization API responses.
 */
export type OrganizationResponse = {
    /**
     * Name
     */
    name: string;
    /**
     * Slug
     */
    slug?: string | null;
    /**
     * Description
     */
    description?: string | null;
    /**
     * Is Active
     */
    is_active?: boolean;
    /**
     * Settings
     */
    settings?: {
        [key: string]: unknown;
    } | null;
    /**
     * Id
     */
    id: string;
    /**
     * Created At
     */
    created_at: string;
    /**
     * Updated At
     */
    updated_at?: string | null;
    /**
     * Member Count
     */
    member_count?: number | null;
};

/**
 * OrganizationRole
 *
 * Built-in organization roles.
 * These provide a baseline role system that can be optionally used.
 * Projects can extend this or implement their own permission system.
 */
export type OrganizationRole = 'owner' | 'admin' | 'member' | 'guest';

/**
 * OrganizationUpdate
 *
 * Schema for updating an organization.
 */
export type OrganizationUpdate = {
    /**
     * Name
     */
    name?: string | null;
    /**
     * Slug
     */
    slug?: string | null;
    /**
     * Description
     */
    description?: string | null;
    /**
     * Is Active
     */
    is_active?: boolean | null;
    /**
     * Settings
     */
    settings?: {
        [key: string]: unknown;
    } | null;
};

/**
 * PaginatedResponse[AdminSessionResponse]
 */
export type PaginatedResponseAdminSessionResponse = {
    /**
     * Data
     *
     * List of items
     */
    data: Array<AdminSessionResponse>;
    /**
     * Pagination metadata
     */
    pagination: PaginationMeta;
};

/**
 * PaginatedResponse[AgentInstanceResponse]
 */
export type PaginatedResponseAgentInstanceResponse = {
    /**
     * Data
     *
     * List of items
     */
    data: Array<AgentInstanceResponse>;
    /**
     * Pagination metadata
     */
    pagination: PaginationMeta;
};

/**
 * PaginatedResponse[AgentTypeResponse]
 */
export type PaginatedResponseAgentTypeResponse = {
    /**
     * Data
     *
     * List of items
     */
    data: Array<AgentTypeResponse>;
    /**
     * Pagination metadata
     */
    pagination: PaginationMeta;
};

/**
 * PaginatedResponse[IssueResponse]
 */
export type PaginatedResponseIssueResponse = {
    /**
     * Data
     *
     * List of items
     */
    data: Array<IssueResponse>;
    /**
     * Pagination metadata
     */
    pagination: PaginationMeta;
};

/**
 * PaginatedResponse[OrganizationMemberResponse]
 */
export type PaginatedResponseOrganizationMemberResponse = {
    /**
     * Data
     *
     * List of items
     */
    data: Array<OrganizationMemberResponse>;
    /**
     * Pagination metadata
     */
    pagination: PaginationMeta;
};

/**
 * PaginatedResponse[OrganizationResponse]
 */
export type PaginatedResponseOrganizationResponse = {
    /**
     * Data
     *
     * List of items
     */
    data: Array<OrganizationResponse>;
    /**
     * Pagination metadata
     */
    pagination: PaginationMeta;
};

/**
 * PaginatedResponse[ProjectResponse]
 */
export type PaginatedResponseProjectResponse = {
    /**
     * Data
     *
     * List of items
     */
    data: Array<ProjectResponse>;
    /**
     * Pagination metadata
     */
    pagination: PaginationMeta;
};

/**
 * PaginatedResponse[SprintResponse]
 */
export type PaginatedResponseSprintResponse = {
    /**
     * Data
     *
     * List of items
     */
    data: Array<SprintResponse>;
    /**
     * Pagination metadata
     */
    pagination: PaginationMeta;
};

/**
 * PaginatedResponse[UserResponse]
 */
export type PaginatedResponseUserResponse = {
    /**
     * Data
     *
     * List of items
     */
    data: Array<UserResponse>;
    /**
     * Pagination metadata
     */
    pagination: PaginationMeta;
};

/**
 * PaginationMeta
 *
 * Metadata for paginated responses.
 */
export type PaginationMeta = {
    /**
     * Total
     *
     * Total number of items
     */
    total: number;
    /**
     * Page
     *
     * Current page number
     */
    page: number;
    /**
     * Page Size
     *
     * Number of items in current page
     */
    page_size: number;
    /**
     * Total Pages
     *
     * Total number of pages
     */
    total_pages: number;
    /**
     * Has Next
     *
     * Whether there is a next page
     */
    has_next: boolean;
    /**
     * Has Prev
     *
     * Whether there is a previous page
     */
    has_prev: boolean;
};

/**
 * PasswordChange
 *
 * Schema for changing password (requires current password).
 */
export type PasswordChange = {
    /**
     * Current Password
     */
    current_password: string;
    /**
     * New Password
     */
    new_password: string;
};

/**
 * PasswordResetConfirm
 *
 * Schema for confirming a password reset with token.
 */
export type PasswordResetConfirm = {
    /**
     * Token
     *
     * Password reset token from email
     */
    token: string;
    /**
     * New Password
     *
     * New password
     */
    new_password: string;
};

/**
 * PasswordResetRequest
 *
 * Schema for requesting a password reset.
 */
export type PasswordResetRequest = {
    /**
     * Email
     *
     * Email address of the account
     */
    email: string;
};

/**
 * ProjectCreate
 *
 * Schema for creating a new project.
 */
export type ProjectCreate = {
    /**
     * Name
     */
    name: string;
    /**
     * Slug
     */
    slug: string;
    /**
     * Description
     */
    description?: string | null;
    autonomy_level?: AutonomyLevel;
    status?: ProjectStatus;
    /**
     * Settings
     */
    settings?: {
        [key: string]: unknown;
    };
    /**
     * Owner Id
     */
    owner_id?: string | null;
};

/**
 * ProjectResponse
 *
 * Schema for project API responses.
 */
export type ProjectResponse = {
    /**
     * Name
     */
    name: string;
    /**
     * Slug
     */
    slug?: string | null;
    /**
     * Description
     */
    description?: string | null;
    autonomy_level?: AutonomyLevel;
    status?: ProjectStatus;
    /**
     * Settings
     */
    settings?: {
        [key: string]: unknown;
    };
    /**
     * Id
     */
    id: string;
    /**
     * Owner Id
     */
    owner_id?: string | null;
    /**
     * Created At
     */
    created_at: string;
    /**
     * Updated At
     */
    updated_at: string;
    /**
     * Agent Count
     */
    agent_count?: number | null;
    /**
     * Issue Count
     */
    issue_count?: number | null;
    /**
     * Active Sprint Name
     */
    active_sprint_name?: string | null;
};

/**
 * ProjectStatus
 *
 * Project lifecycle status.
 *
 * ACTIVE: Project is actively being worked on
 * PAUSED: Project is temporarily on hold
 * COMPLETED: Project has been delivered successfully
 * ARCHIVED: Project is no longer accessible for work
 */
export type ProjectStatus = 'active' | 'paused' | 'completed' | 'archived';

/**
 * ProjectUpdate
 *
 * Schema for updating a project.
 *
 * Note: owner_id is intentionally excluded to prevent IDOR vulnerabilities.
 * Project ownership transfer should be done via a dedicated endpoint with
 * proper authorization checks.
 */
export type ProjectUpdate = {
    /**
     * Name
     */
    name?: string | null;
    /**
     * Slug
     */
    slug?: string | null;
    /**
     * Description
     */
    description?: string | null;
    autonomy_level?: AutonomyLevel | null;
    status?: ProjectStatus | null;
    /**
     * Settings
     */
    settings?: {
        [key: string]: unknown;
    } | null;
};

/**
 * RefreshTokenRequest
 */
export type RefreshTokenRequest = {
    /**
     * Refresh Token
     */
    refresh_token: string;
};

/**
 * RegistrationActivityData
 */
export type RegistrationActivityData = {
    /**
     * Date
     */
    date: string;
    /**
     * Registrations
     */
    registrations: number;
};

/**
 * SessionListResponse
 *
 * Response containing list of sessions.
 */
export type SessionListResponse = {
    /**
     * Sessions
     */
    sessions: Array<SessionResponse>;
    /**
     * Total
     *
     * Total number of active sessions
     */
    total: number;
};

/**
 * SessionResponse
 *
 * Schema for session responses to clients.
 *
 * This is what users see when they list their active sessions.
 */
export type SessionResponse = {
    /**
     * Device Name
     *
     * Friendly device name
     */
    device_name?: string | null;
    /**
     * Device Id
     *
     * Persistent device identifier
     */
    device_id?: string | null;
    /**
     * Id
     */
    id: string;
    /**
     * Ip Address
     */
    ip_address?: string | null;
    /**
     * Location City
     */
    location_city?: string | null;
    /**
     * Location Country
     */
    location_country?: string | null;
    /**
     * Last Used At
     */
    last_used_at: string;
    /**
     * Created At
     */
    created_at: string;
    /**
     * Expires At
     */
    expires_at: string;
    /**
     * Is Current
     *
     * Whether this is the current session
     */
    is_current?: boolean;
};

/**
 * SortOrder
 *
 * Sort order options.
 */
export type SortOrder = 'asc' | 'desc';

/**
 * SprintComplete
 *
 * Schema for completing a sprint.
 */
export type SprintComplete = {
    /**
     * Velocity
     */
    velocity?: number | null;
    /**
     * Notes
     */
    notes?: string | null;
};

/**
 * SprintCreate
 *
 * Schema for creating a new sprint.
 */
export type SprintCreate = {
    /**
     * Name
     */
    name: string;
    /**
     * Number
     */
    number: number;
    /**
     * Goal
     */
    goal?: string | null;
    /**
     * Start Date
     */
    start_date: string;
    /**
     * End Date
     */
    end_date: string;
    status?: SprintStatus;
    /**
     * Planned Points
     */
    planned_points?: number | null;
    /**
     * Velocity
     */
    velocity?: number | null;
    /**
     * Project Id
     */
    project_id: string;
};

/**
 * SprintResponse
 *
 * Schema for sprint API responses.
 */
export type SprintResponse = {
    /**
     * Name
     */
    name: string;
    /**
     * Number
     */
    number: number;
    /**
     * Goal
     */
    goal?: string | null;
    /**
     * Start Date
     */
    start_date: string;
    /**
     * End Date
     */
    end_date: string;
    status?: SprintStatus;
    /**
     * Planned Points
     */
    planned_points?: number | null;
    /**
     * Velocity
     */
    velocity?: number | null;
    /**
     * Id
     */
    id: string;
    /**
     * Project Id
     */
    project_id: string;
    /**
     * Created At
     */
    created_at: string;
    /**
     * Updated At
     */
    updated_at: string;
    /**
     * Project Name
     */
    project_name?: string | null;
    /**
     * Project Slug
     */
    project_slug?: string | null;
    /**
     * Issue Count
     */
    issue_count?: number | null;
    /**
     * Open Issues
     */
    open_issues?: number | null;
    /**
     * Completed Issues
     */
    completed_issues?: number | null;
};

/**
 * SprintStart
 *
 * Schema for starting a sprint.
 */
export type SprintStart = {
    /**
     * Start Date
     */
    start_date?: string | null;
};

/**
 * SprintStatus
 *
 * Sprint lifecycle status.
 *
 * PLANNED: Sprint has been created but not started
 * ACTIVE: Sprint is currently in progress
 * IN_REVIEW: Sprint work is done, demo/review pending
 * COMPLETED: Sprint has been finished successfully
 * CANCELLED: Sprint was cancelled before completion
 */
export type SprintStatus = 'planned' | 'active' | 'in_review' | 'completed' | 'cancelled';

/**
 * SprintUpdate
 *
 * Schema for updating a sprint.
 */
export type SprintUpdate = {
    /**
     * Name
     */
    name?: string | null;
    /**
     * Goal
     */
    goal?: string | null;
    /**
     * Start Date
     */
    start_date?: string | null;
    /**
     * End Date
     */
    end_date?: string | null;
    status?: SprintStatus | null;
    /**
     * Planned Points
     */
    planned_points?: number | null;
    /**
     * Velocity
     */
    velocity?: number | null;
};

/**
 * SprintVelocity
 *
 * Schema for sprint velocity metrics.
 */
export type SprintVelocity = {
    /**
     * Sprint Number
     */
    sprint_number: number;
    /**
     * Sprint Name
     */
    sprint_name: string;
    /**
     * Planned Points
     */
    planned_points: number | null;
    /**
     * Velocity
     */
    velocity: number | null;
    /**
     * Velocity Ratio
     */
    velocity_ratio: number | null;
};

/**
 * SyncStatus
 *
 * External issue tracker synchronization status.
 *
 * SYNCED: Local and remote are in sync
 * PENDING: Local changes waiting to be pushed
 * CONFLICT: Merge conflict between local and remote
 * ERROR: Synchronization failed due to an error
 */
export type SyncStatus = 'synced' | 'pending' | 'conflict' | 'error';

/**
 * Token
 */
export type Token = {
    /**
     * Access Token
     */
    access_token: string;
    /**
     * Refresh Token
     */
    refresh_token?: string | null;
    /**
     * Token Type
     */
    token_type?: string;
    user: UserResponse;
    /**
     * Expires In
     */
    expires_in?: number | null;
};

/**
 * UserCreate
 */
export type UserCreate = {
    /**
     * Email
     */
    email: string;
    /**
     * First Name
     */
    first_name: string;
    /**
     * Last Name
     */
    last_name?: string | null;
    /**
     * Phone Number
     */
    phone_number?: string | null;
    /**
     * Password
     */
    password: string;
    /**
     * Is Superuser
     */
    is_superuser?: boolean;
    /**
     * Is Active
     */
    is_active?: boolean;
};

/**
 * UserGrowthData
 */
export type UserGrowthData = {
    /**
     * Date
     */
    date: string;
    /**
     * Total Users
     */
    total_users: number;
    /**
     * Active Users
     */
    active_users: number;
};

/**
 * UserResponse
 */
export type UserResponse = {
    /**
     * Email
     */
    email: string;
    /**
     * First Name
     */
    first_name: string;
    /**
     * Last Name
     */
    last_name?: string | null;
    /**
     * Phone Number
     */
    phone_number?: string | null;
    /**
     * Id
     */
    id: string;
    /**
     * Is Active
     */
    is_active: boolean;
    /**
     * Is Superuser
     */
    is_superuser: boolean;
    /**
     * Created At
     */
    created_at: string;
    /**
     * Updated At
     */
    updated_at?: string | null;
    /**
     * Locale
     */
    locale?: string | null;
};

/**
 * UserStatusData
 */
export type UserStatusData = {
    /**
     * Name
     */
    name: string;
    /**
     * Value
     */
    value: number;
};

/**
 * UserUpdate
 */
export type UserUpdate = {
    /**
     * First Name
     */
    first_name?: string | null;
    /**
     * Last Name
     */
    last_name?: string | null;
    /**
     * Phone Number
     */
    phone_number?: string | null;
    /**
     * Password
     */
    password?: string | null;
    /**
     * Preferences
     */
    preferences?: {
        [key: string]: unknown;
    } | null;
    /**
     * Locale
     *
     * User's preferred locale (BCP 47 format: en, it, en-US, it-IT)
     */
    locale?: string | null;
    /**
     * Is Active
     */
    is_active?: boolean | null;
    /**
     * Is Superuser
     */
    is_superuser?: boolean | null;
};

/**
 * ValidationError
 */
export type ValidationError = {
    /**
     * Location
     */
    loc: Array<string | number>;
    /**
     * Message
     */
    msg: string;
    /**
     * Error Type
     */
    type: string;
};

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

export type RootGetResponses = {
    /**
     * Successful Response
     */
    200: string;
};

export type RootGetResponse = RootGetResponses[keyof RootGetResponses];

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

export type HealthCheckResponses = {
    /**
     * Health status information
     */
    200: unknown;
};

export type RegisterData = {
    body: UserCreate;
    path?: never;
    query?: never;
    url: '/api/v1/auth/register';
};

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

export type RegisterError = RegisterErrors[keyof RegisterErrors];

export type RegisterResponses = {
    /**
     * Successful Response
     */
    201: UserResponse;
};

export type RegisterResponse = RegisterResponses[keyof RegisterResponses];

export type LoginData = {
    body: LoginRequest;
    path?: never;
    query?: never;
    url: '/api/v1/auth/login';
};

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

export type LoginError = LoginErrors[keyof LoginErrors];

export type LoginResponses = {
    /**
     * Successful Response
     */
    200: Token;
};

export type LoginResponse = LoginResponses[keyof LoginResponses];

export type LoginOauthData = {
    body: BodyLoginOauth;
    path?: never;
    query?: never;
    url: '/api/v1/auth/login/oauth';
};

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

export type LoginOauthError = LoginOauthErrors[keyof LoginOauthErrors];

export type LoginOauthResponses = {
    /**
     * Successful Response
     */
    200: Token;
};

export type LoginOauthResponse = LoginOauthResponses[keyof LoginOauthResponses];

export type RefreshTokenData = {
    body: RefreshTokenRequest;
    path?: never;
    query?: never;
    url: '/api/v1/auth/refresh';
};

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

export type RefreshTokenError = RefreshTokenErrors[keyof RefreshTokenErrors];

export type RefreshTokenResponses = {
    /**
     * Successful Response
     */
    200: Token;
};

export type RefreshTokenResponse = RefreshTokenResponses[keyof RefreshTokenResponses];

export type RequestPasswordResetData = {
    body: PasswordResetRequest;
    path?: never;
    query?: never;
    url: '/api/v1/auth/password-reset/request';
};

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

export type RequestPasswordResetError = RequestPasswordResetErrors[keyof RequestPasswordResetErrors];

export type RequestPasswordResetResponses = {
    /**
     * Successful Response
     */
    200: MessageResponse;
};

export type RequestPasswordResetResponse = RequestPasswordResetResponses[keyof RequestPasswordResetResponses];

export type ConfirmPasswordResetData = {
    body: PasswordResetConfirm;
    path?: never;
    query?: never;
    url: '/api/v1/auth/password-reset/confirm';
};

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

export type ConfirmPasswordResetError = ConfirmPasswordResetErrors[keyof ConfirmPasswordResetErrors];

export type ConfirmPasswordResetResponses = {
    /**
     * Successful Response
     */
    200: MessageResponse;
};

export type ConfirmPasswordResetResponse = ConfirmPasswordResetResponses[keyof ConfirmPasswordResetResponses];

export type LogoutData = {
    body: LogoutRequest;
    path?: never;
    query?: never;
    url: '/api/v1/auth/logout';
};

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

export type LogoutError = LogoutErrors[keyof LogoutErrors];

export type LogoutResponses = {
    /**
     * Successful Response
     */
    200: MessageResponse;
};

export type LogoutResponse = LogoutResponses[keyof LogoutResponses];

export type LogoutAllData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/v1/auth/logout-all';
};

export type LogoutAllResponses = {
    /**
     * Successful Response
     */
    200: MessageResponse;
};

export type LogoutAllResponse = LogoutAllResponses[keyof LogoutAllResponses];

export type ListOauthProvidersData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/v1/oauth/providers';
};

export type ListOauthProvidersResponses = {
    /**
     * Successful Response
     */
    200: OAuthProvidersResponse;
};

export type ListOauthProvidersResponse = ListOauthProvidersResponses[keyof ListOauthProvidersResponses];

export type GetOauthAuthorizationUrlData = {
    body?: never;
    headers?: {
        /**
         * Authorization
         */
        authorization?: string;
    };
    path: {
        /**
         * Provider
         */
        provider: string;
    };
    query: {
        /**
         * Redirect Uri
         *
         * Frontend callback URL after OAuth completes
         */
        redirect_uri: string;
    };
    url: '/api/v1/oauth/authorize/{provider}';
};

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

export type GetOauthAuthorizationUrlError = GetOauthAuthorizationUrlErrors[keyof GetOauthAuthorizationUrlErrors];

export type GetOauthAuthorizationUrlResponses = {
    /**
     * Response Get Oauth Authorization Url
     *
     * Successful Response
     */
    200: {
        [key: string]: unknown;
    };
};

export type GetOauthAuthorizationUrlResponse = GetOauthAuthorizationUrlResponses[keyof GetOauthAuthorizationUrlResponses];

export type HandleOauthCallbackData = {
    body: OAuthCallbackRequest;
    path: {
        /**
         * Provider
         */
        provider: string;
    };
    query: {
        /**
         * Redirect Uri
         *
         * Must match the redirect_uri used in authorization
         */
        redirect_uri: string;
    };
    url: '/api/v1/oauth/callback/{provider}';
};

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

export type HandleOauthCallbackError = HandleOauthCallbackErrors[keyof HandleOauthCallbackErrors];

export type HandleOauthCallbackResponses = {
    /**
     * Successful Response
     */
    200: OAuthCallbackResponse;
};

export type HandleOauthCallbackResponse = HandleOauthCallbackResponses[keyof HandleOauthCallbackResponses];

export type ListOauthAccountsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/v1/oauth/accounts';
};

export type ListOauthAccountsResponses = {
    /**
     * Successful Response
     */
    200: OAuthAccountsListResponse;
};

export type ListOauthAccountsResponse = ListOauthAccountsResponses[keyof ListOauthAccountsResponses];

export type UnlinkOauthAccountData = {
    body?: never;
    path: {
        /**
         * Provider
         */
        provider: string;
    };
    query?: never;
    url: '/api/v1/oauth/accounts/{provider}';
};

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

export type UnlinkOauthAccountError = UnlinkOauthAccountErrors[keyof UnlinkOauthAccountErrors];

export type UnlinkOauthAccountResponses = {
    /**
     * Successful Response
     */
    200: OAuthUnlinkResponse;
};

export type UnlinkOauthAccountResponse = UnlinkOauthAccountResponses[keyof UnlinkOauthAccountResponses];

export type StartOauthLinkData = {
    body?: never;
    path: {
        /**
         * Provider
         */
        provider: string;
    };
    query: {
        /**
         * Redirect Uri
         *
         * Frontend callback URL after OAuth completes
         */
        redirect_uri: string;
    };
    url: '/api/v1/oauth/link/{provider}';
};

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

export type StartOauthLinkError = StartOauthLinkErrors[keyof StartOauthLinkErrors];

export type StartOauthLinkResponses = {
    /**
     * Response Start Oauth Link
     *
     * Successful Response
     */
    200: {
        [key: string]: unknown;
    };
};

export type StartOauthLinkResponse = StartOauthLinkResponses[keyof StartOauthLinkResponses];

export type OauthProviderAuthorizeData = {
    body?: never;
    headers?: {
        /**
         * Authorization
         */
        authorization?: string;
    };
    path?: never;
    query: {
        /**
         * Response Type
         *
         * Must be 'code'
         */
        response_type: string;
        /**
         * Client Id
         *
         * OAuth client ID
         */
        client_id: string;
        /**
         * Redirect Uri
         *
         * Redirect URI
         */
        redirect_uri: string;
        /**
         * Scope
         *
         * Requested scopes (space-separated)
         */
        scope?: string;
        /**
         * State
         *
         * CSRF state parameter
         */
        state?: string;
        /**
         * Code Challenge
         *
         * PKCE code challenge
         */
        code_challenge?: string | null;
        /**
         * Code Challenge Method
         *
         * PKCE method (S256)
         */
        code_challenge_method?: string | null;
        /**
         * Nonce
         *
         * OpenID Connect nonce
         */
        nonce?: string | null;
    };
    url: '/api/v1/oauth/provider/authorize';
};

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

export type OauthProviderAuthorizeError = OauthProviderAuthorizeErrors[keyof OauthProviderAuthorizeErrors];

export type OauthProviderAuthorizeResponses = {
    /**
     * Response Oauth Provider Authorize
     *
     * Successful Response
     */
    200: unknown;
};

export type OauthProviderConsentData = {
    body: BodyOauthProviderConsent;
    path?: never;
    query?: never;
    url: '/api/v1/oauth/provider/authorize/consent';
};

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

export type OauthProviderConsentError = OauthProviderConsentErrors[keyof OauthProviderConsentErrors];

export type OauthProviderConsentResponses = {
    /**
     * Response Oauth Provider Consent
     *
     * Successful Response
     */
    200: unknown;
};

export type OauthProviderTokenData = {
    body: BodyOauthProviderToken;
    path?: never;
    query?: never;
    url: '/api/v1/oauth/provider/token';
};

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

export type OauthProviderTokenError = OauthProviderTokenErrors[keyof OauthProviderTokenErrors];

export type OauthProviderTokenResponses = {
    /**
     * Successful Response
     */
    200: OAuthTokenResponse;
};

export type OauthProviderTokenResponse = OauthProviderTokenResponses[keyof OauthProviderTokenResponses];

export type OauthProviderRevokeData = {
    body: BodyOauthProviderRevoke;
    path?: never;
    query?: never;
    url: '/api/v1/oauth/provider/revoke';
};

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

export type OauthProviderRevokeError = OauthProviderRevokeErrors[keyof OauthProviderRevokeErrors];

export type OauthProviderRevokeResponses = {
    /**
     * Response Oauth Provider Revoke
     *
     * Successful Response
     */
    200: {
        [key: string]: string;
    };
};

export type OauthProviderRevokeResponse = OauthProviderRevokeResponses[keyof OauthProviderRevokeResponses];

export type OauthProviderIntrospectData = {
    body: BodyOauthProviderIntrospect;
    path?: never;
    query?: never;
    url: '/api/v1/oauth/provider/introspect';
};

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

export type OauthProviderIntrospectError = OauthProviderIntrospectErrors[keyof OauthProviderIntrospectErrors];

export type OauthProviderIntrospectResponses = {
    /**
     * Successful Response
     */
    200: OAuthTokenIntrospectionResponse;
};

export type OauthProviderIntrospectResponse = OauthProviderIntrospectResponses[keyof OauthProviderIntrospectResponses];

export type ListOauthClientsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/v1/oauth/provider/clients';
};

export type ListOauthClientsResponses = {
    /**
     * Response List Oauth Clients
     *
     * Successful Response
     */
    200: Array<OAuthClientResponse>;
};

export type ListOauthClientsResponse = ListOauthClientsResponses[keyof ListOauthClientsResponses];

export type RegisterOauthClientData = {
    body: BodyRegisterOauthClient;
    path?: never;
    query?: never;
    url: '/api/v1/oauth/provider/clients';
};

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

export type RegisterOauthClientError = RegisterOauthClientErrors[keyof RegisterOauthClientErrors];

export type RegisterOauthClientResponses = {
    /**
     * Response Register Oauth Client
     *
     * Successful Response
     */
    200: {
        [key: string]: unknown;
    };
};

export type RegisterOauthClientResponse = RegisterOauthClientResponses[keyof RegisterOauthClientResponses];

export type DeleteOauthClientData = {
    body?: never;
    path: {
        /**
         * Client Id
         */
        client_id: string;
    };
    query?: never;
    url: '/api/v1/oauth/provider/clients/{client_id}';
};

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

export type DeleteOauthClientError = DeleteOauthClientErrors[keyof DeleteOauthClientErrors];

export type DeleteOauthClientResponses = {
    /**
     * Successful Response
     */
    204: void;
};

export type DeleteOauthClientResponse = DeleteOauthClientResponses[keyof DeleteOauthClientResponses];

export type ListMyOauthConsentsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/v1/oauth/provider/consents';
};

export type ListMyOauthConsentsResponses = {
    /**
     * Response List My Oauth Consents
     *
     * Successful Response
     */
    200: Array<{
        [key: string]: unknown;
    }>;
};

export type ListMyOauthConsentsResponse = ListMyOauthConsentsResponses[keyof ListMyOauthConsentsResponses];

export type RevokeMyOauthConsentData = {
    body?: never;
    path: {
        /**
         * Client Id
         */
        client_id: string;
    };
    query?: never;
    url: '/api/v1/oauth/provider/consents/{client_id}';
};

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

export type RevokeMyOauthConsentError = RevokeMyOauthConsentErrors[keyof RevokeMyOauthConsentErrors];

export type RevokeMyOauthConsentResponses = {
    /**
     * Successful Response
     */
    204: void;
};

export type RevokeMyOauthConsentResponse = RevokeMyOauthConsentResponses[keyof RevokeMyOauthConsentResponses];

export type ListUsersData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Is Active
         *
         * Filter by active status
         */
        is_active?: boolean | null;
        /**
         * Is Superuser
         *
         * Filter by superuser status
         */
        is_superuser?: boolean | null;
        /**
         * Page
         */
        page?: number;
        /**
         * Limit
         */
        limit?: number;
        /**
         * Sort By
         */
        sort_by?: string | null;
        sort_order?: SortOrder;
    };
    url: '/api/v1/users';
};

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

export type ListUsersError = ListUsersErrors[keyof ListUsersErrors];

export type ListUsersResponses = {
    /**
     * Successful Response
     */
    200: PaginatedResponseUserResponse;
};

export type ListUsersResponse = ListUsersResponses[keyof ListUsersResponses];

export type GetCurrentUserProfileData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/v1/users/me';
};

export type GetCurrentUserProfileResponses = {
    /**
     * Successful Response
     */
    200: UserResponse;
};

export type GetCurrentUserProfileResponse = GetCurrentUserProfileResponses[keyof GetCurrentUserProfileResponses];

export type UpdateCurrentUserData = {
    body: UserUpdate;
    path?: never;
    query?: never;
    url: '/api/v1/users/me';
};

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

export type UpdateCurrentUserError = UpdateCurrentUserErrors[keyof UpdateCurrentUserErrors];

export type UpdateCurrentUserResponses = {
    /**
     * Successful Response
     */
    200: UserResponse;
};

export type UpdateCurrentUserResponse = UpdateCurrentUserResponses[keyof UpdateCurrentUserResponses];

export type DeleteUserData = {
    body?: never;
    path: {
        /**
         * User Id
         */
        user_id: string;
    };
    query?: never;
    url: '/api/v1/users/{user_id}';
};

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

export type DeleteUserError = DeleteUserErrors[keyof DeleteUserErrors];

export type DeleteUserResponses = {
    /**
     * Successful Response
     */
    200: MessageResponse;
};

export type DeleteUserResponse = DeleteUserResponses[keyof DeleteUserResponses];

export type GetUserByIdData = {
    body?: never;
    path: {
        /**
         * User Id
         */
        user_id: string;
    };
    query?: never;
    url: '/api/v1/users/{user_id}';
};

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

export type GetUserByIdError = GetUserByIdErrors[keyof GetUserByIdErrors];

export type GetUserByIdResponses = {
    /**
     * Successful Response
     */
    200: UserResponse;
};

export type GetUserByIdResponse = GetUserByIdResponses[keyof GetUserByIdResponses];

export type UpdateUserData = {
    body: UserUpdate;
    path: {
        /**
         * User Id
         */
        user_id: string;
    };
    query?: never;
    url: '/api/v1/users/{user_id}';
};

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

export type UpdateUserError = UpdateUserErrors[keyof UpdateUserErrors];

export type UpdateUserResponses = {
    /**
     * Successful Response
     */
    200: UserResponse;
};

export type UpdateUserResponse = UpdateUserResponses[keyof UpdateUserResponses];

export type ChangeCurrentUserPasswordData = {
    body: PasswordChange;
    path?: never;
    query?: never;
    url: '/api/v1/users/me/password';
};

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

export type ChangeCurrentUserPasswordError = ChangeCurrentUserPasswordErrors[keyof ChangeCurrentUserPasswordErrors];

export type ChangeCurrentUserPasswordResponses = {
    /**
     * Successful Response
     */
    200: MessageResponse;
};

export type ChangeCurrentUserPasswordResponse = ChangeCurrentUserPasswordResponses[keyof ChangeCurrentUserPasswordResponses];

export type ListMySessionsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/v1/sessions/me';
};

export type ListMySessionsResponses = {
    /**
     * Successful Response
     */
    200: SessionListResponse;
};

export type ListMySessionsResponse = ListMySessionsResponses[keyof ListMySessionsResponses];

export type RevokeSessionData = {
    body?: never;
    path: {
        /**
         * Session Id
         */
        session_id: string;
    };
    query?: never;
    url: '/api/v1/sessions/{session_id}';
};

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

export type RevokeSessionError = RevokeSessionErrors[keyof RevokeSessionErrors];

export type RevokeSessionResponses = {
    /**
     * Successful Response
     */
    200: MessageResponse;
};

export type RevokeSessionResponse = RevokeSessionResponses[keyof RevokeSessionResponses];

export type CleanupExpiredSessionsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/v1/sessions/me/expired';
};

export type CleanupExpiredSessionsResponses = {
    /**
     * Successful Response
     */
    200: MessageResponse;
};

export type CleanupExpiredSessionsResponse = CleanupExpiredSessionsResponses[keyof CleanupExpiredSessionsResponses];

export type AdminGetStatsData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/api/v1/admin/stats';
};

export type AdminGetStatsResponses = {
    /**
     * Successful Response
     */
    200: AdminStatsResponse;
};

export type AdminGetStatsResponse = AdminGetStatsResponses[keyof AdminGetStatsResponses];

export type AdminListUsersData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Is Active
         *
         * Filter by active status
         */
        is_active?: boolean | null;
        /**
         * Is Superuser
         *
         * Filter by superuser status
         */
        is_superuser?: boolean | null;
        /**
         * Search
         *
         * Search by email, name
         */
        search?: string | null;
        /**
         * Page
         */
        page?: number;
        /**
         * Limit
         */
        limit?: number;
        /**
         * Sort By
         */
        sort_by?: string | null;
        sort_order?: SortOrder;
    };
    url: '/api/v1/admin/users';
};

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

export type AdminListUsersError = AdminListUsersErrors[keyof AdminListUsersErrors];

export type AdminListUsersResponses = {
    /**
     * Successful Response
     */
    200: PaginatedResponseUserResponse;
};

export type AdminListUsersResponse = AdminListUsersResponses[keyof AdminListUsersResponses];

export type AdminCreateUserData = {
    body: UserCreate;
    path?: never;
    query?: never;
    url: '/api/v1/admin/users';
};

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

export type AdminCreateUserError = AdminCreateUserErrors[keyof AdminCreateUserErrors];

export type AdminCreateUserResponses = {
    /**
     * Successful Response
     */
    201: UserResponse;
};

export type AdminCreateUserResponse = AdminCreateUserResponses[keyof AdminCreateUserResponses];

export type AdminDeleteUserData = {
    body?: never;
    path: {
        /**
         * User Id
         */
        user_id: string;
    };
    query?: never;
    url: '/api/v1/admin/users/{user_id}';
};

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

export type AdminDeleteUserError = AdminDeleteUserErrors[keyof AdminDeleteUserErrors];

export type AdminDeleteUserResponses = {
    /**
     * Successful Response
     */
    200: MessageResponse;
};

export type AdminDeleteUserResponse = AdminDeleteUserResponses[keyof AdminDeleteUserResponses];

export type AdminGetUserData = {
    body?: never;
    path: {
        /**
         * User Id
         */
        user_id: string;
    };
    query?: never;
    url: '/api/v1/admin/users/{user_id}';
};

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

export type AdminGetUserError = AdminGetUserErrors[keyof AdminGetUserErrors];

export type AdminGetUserResponses = {
    /**
     * Successful Response
     */
    200: UserResponse;
};

export type AdminGetUserResponse = AdminGetUserResponses[keyof AdminGetUserResponses];

export type AdminUpdateUserData = {
    body: UserUpdate;
    path: {
        /**
         * User Id
         */
        user_id: string;
    };
    query?: never;
    url: '/api/v1/admin/users/{user_id}';
};

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

export type AdminUpdateUserError = AdminUpdateUserErrors[keyof AdminUpdateUserErrors];

export type AdminUpdateUserResponses = {
    /**
     * Successful Response
     */
    200: UserResponse;
};

export type AdminUpdateUserResponse = AdminUpdateUserResponses[keyof AdminUpdateUserResponses];

export type AdminActivateUserData = {
    body?: never;
    path: {
        /**
         * User Id
         */
        user_id: string;
    };
    query?: never;
    url: '/api/v1/admin/users/{user_id}/activate';
};

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

export type AdminActivateUserError = AdminActivateUserErrors[keyof AdminActivateUserErrors];

export type AdminActivateUserResponses = {
    /**
     * Successful Response
     */
    200: MessageResponse;
};

export type AdminActivateUserResponse = AdminActivateUserResponses[keyof AdminActivateUserResponses];

export type AdminDeactivateUserData = {
    body?: never;
    path: {
        /**
         * User Id
         */
        user_id: string;
    };
    query?: never;
    url: '/api/v1/admin/users/{user_id}/deactivate';
};

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

export type AdminDeactivateUserError = AdminDeactivateUserErrors[keyof AdminDeactivateUserErrors];

export type AdminDeactivateUserResponses = {
    /**
     * Successful Response
     */
    200: MessageResponse;
};

export type AdminDeactivateUserResponse = AdminDeactivateUserResponses[keyof AdminDeactivateUserResponses];

export type AdminBulkUserActionData = {
    body: BulkUserAction;
    path?: never;
    query?: never;
    url: '/api/v1/admin/users/bulk-action';
};

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

export type AdminBulkUserActionError = AdminBulkUserActionErrors[keyof AdminBulkUserActionErrors];

export type AdminBulkUserActionResponses = {
    /**
     * Successful Response
     */
    200: BulkActionResult;
};

export type AdminBulkUserActionResponse = AdminBulkUserActionResponses[keyof AdminBulkUserActionResponses];

export type AdminListOrganizationsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Is Active
         *
         * Filter by active status
         */
        is_active?: boolean | null;
        /**
         * Search
         *
         * Search by name, slug, description
         */
        search?: string | null;
        /**
         * Page
         */
        page?: number;
        /**
         * Limit
         */
        limit?: number;
    };
    url: '/api/v1/admin/organizations';
};

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

export type AdminListOrganizationsError = AdminListOrganizationsErrors[keyof AdminListOrganizationsErrors];

export type AdminListOrganizationsResponses = {
    /**
     * Successful Response
     */
    200: PaginatedResponseOrganizationResponse;
};

export type AdminListOrganizationsResponse = AdminListOrganizationsResponses[keyof AdminListOrganizationsResponses];

export type AdminCreateOrganizationData = {
    body: OrganizationCreate;
    path?: never;
    query?: never;
    url: '/api/v1/admin/organizations';
};

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

export type AdminCreateOrganizationError = AdminCreateOrganizationErrors[keyof AdminCreateOrganizationErrors];

export type AdminCreateOrganizationResponses = {
    /**
     * Successful Response
     */
    201: OrganizationResponse;
};

export type AdminCreateOrganizationResponse = AdminCreateOrganizationResponses[keyof AdminCreateOrganizationResponses];

export type AdminDeleteOrganizationData = {
    body?: never;
    path: {
        /**
         * Org Id
         */
        org_id: string;
    };
    query?: never;
    url: '/api/v1/admin/organizations/{org_id}';
};

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

export type AdminDeleteOrganizationError = AdminDeleteOrganizationErrors[keyof AdminDeleteOrganizationErrors];

export type AdminDeleteOrganizationResponses = {
    /**
     * Successful Response
     */
    200: MessageResponse;
};

export type AdminDeleteOrganizationResponse = AdminDeleteOrganizationResponses[keyof AdminDeleteOrganizationResponses];

export type AdminGetOrganizationData = {
    body?: never;
    path: {
        /**
         * Org Id
         */
        org_id: string;
    };
    query?: never;
    url: '/api/v1/admin/organizations/{org_id}';
};

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

export type AdminGetOrganizationError = AdminGetOrganizationErrors[keyof AdminGetOrganizationErrors];

export type AdminGetOrganizationResponses = {
    /**
     * Successful Response
     */
    200: OrganizationResponse;
};

export type AdminGetOrganizationResponse = AdminGetOrganizationResponses[keyof AdminGetOrganizationResponses];

export type AdminUpdateOrganizationData = {
    body: OrganizationUpdate;
    path: {
        /**
         * Org Id
         */
        org_id: string;
    };
    query?: never;
    url: '/api/v1/admin/organizations/{org_id}';
};

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

export type AdminUpdateOrganizationError = AdminUpdateOrganizationErrors[keyof AdminUpdateOrganizationErrors];

export type AdminUpdateOrganizationResponses = {
    /**
     * Successful Response
     */
    200: OrganizationResponse;
};

export type AdminUpdateOrganizationResponse = AdminUpdateOrganizationResponses[keyof AdminUpdateOrganizationResponses];

export type AdminListOrganizationMembersData = {
    body?: never;
    path: {
        /**
         * Org Id
         */
        org_id: string;
    };
    query?: {
        /**
         * Is Active
         *
         * Filter by active status
         */
        is_active?: boolean | null;
        /**
         * Page
         */
        page?: number;
        /**
         * Limit
         */
        limit?: number;
    };
    url: '/api/v1/admin/organizations/{org_id}/members';
};

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

export type AdminListOrganizationMembersError = AdminListOrganizationMembersErrors[keyof AdminListOrganizationMembersErrors];

export type AdminListOrganizationMembersResponses = {
    /**
     * Successful Response
     */
    200: PaginatedResponseOrganizationMemberResponse;
};

export type AdminListOrganizationMembersResponse = AdminListOrganizationMembersResponses[keyof AdminListOrganizationMembersResponses];

export type AdminAddOrganizationMemberData = {
    body: AddMemberRequest;
    path: {
        /**
         * Org Id
         */
        org_id: string;
    };
    query?: never;
    url: '/api/v1/admin/organizations/{org_id}/members';
};

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

export type AdminAddOrganizationMemberError = AdminAddOrganizationMemberErrors[keyof AdminAddOrganizationMemberErrors];

export type AdminAddOrganizationMemberResponses = {
    /**
     * Successful Response
     */
    200: MessageResponse;
};

export type AdminAddOrganizationMemberResponse = AdminAddOrganizationMemberResponses[keyof AdminAddOrganizationMemberResponses];

export type AdminRemoveOrganizationMemberData = {
    body?: never;
    path: {
        /**
         * Org Id
         */
        org_id: string;
        /**
         * User Id
         */
        user_id: string;
    };
    query?: never;
    url: '/api/v1/admin/organizations/{org_id}/members/{user_id}';
};

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

export type AdminRemoveOrganizationMemberError = AdminRemoveOrganizationMemberErrors[keyof AdminRemoveOrganizationMemberErrors];

export type AdminRemoveOrganizationMemberResponses = {
    /**
     * Successful Response
     */
    200: MessageResponse;
};

export type AdminRemoveOrganizationMemberResponse = AdminRemoveOrganizationMemberResponses[keyof AdminRemoveOrganizationMemberResponses];

export type AdminListSessionsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Is Active
         *
         * Filter by active status
         */
        is_active?: boolean | null;
        /**
         * Page
         */
        page?: number;
        /**
         * Limit
         */
        limit?: number;
    };
    url: '/api/v1/admin/sessions';
};

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

export type AdminListSessionsError = AdminListSessionsErrors[keyof AdminListSessionsErrors];

export type AdminListSessionsResponses = {
    /**
     * Successful Response
     */
    200: PaginatedResponseAdminSessionResponse;
};

export type AdminListSessionsResponse = AdminListSessionsResponses[keyof AdminListSessionsResponses];

export type GetMyOrganizationsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Is Active
         *
         * Filter by active membership
         */
        is_active?: boolean;
    };
    url: '/api/v1/organizations/me';
};

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

export type GetMyOrganizationsError = GetMyOrganizationsErrors[keyof GetMyOrganizationsErrors];

export type GetMyOrganizationsResponses = {
    /**
     * Response Get My Organizations
     *
     * Successful Response
     */
    200: Array<OrganizationResponse>;
};

export type GetMyOrganizationsResponse = GetMyOrganizationsResponses[keyof GetMyOrganizationsResponses];

export type GetOrganizationData = {
    body?: never;
    path: {
        /**
         * Organization Id
         */
        organization_id: string;
    };
    query?: never;
    url: '/api/v1/organizations/{organization_id}';
};

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

export type GetOrganizationError = GetOrganizationErrors[keyof GetOrganizationErrors];

export type GetOrganizationResponses = {
    /**
     * Successful Response
     */
    200: OrganizationResponse;
};

export type GetOrganizationResponse = GetOrganizationResponses[keyof GetOrganizationResponses];

export type UpdateOrganizationData = {
    body: OrganizationUpdate;
    path: {
        /**
         * Organization Id
         */
        organization_id: string;
    };
    query?: never;
    url: '/api/v1/organizations/{organization_id}';
};

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

export type UpdateOrganizationError = UpdateOrganizationErrors[keyof UpdateOrganizationErrors];

export type UpdateOrganizationResponses = {
    /**
     * Successful Response
     */
    200: OrganizationResponse;
};

export type UpdateOrganizationResponse = UpdateOrganizationResponses[keyof UpdateOrganizationResponses];

export type GetOrganizationMembersData = {
    body?: never;
    path: {
        /**
         * Organization Id
         */
        organization_id: string;
    };
    query?: {
        /**
         * Is Active
         *
         * Filter by active status
         */
        is_active?: boolean;
        /**
         * Page
         */
        page?: number;
        /**
         * Limit
         */
        limit?: number;
    };
    url: '/api/v1/organizations/{organization_id}/members';
};

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

export type GetOrganizationMembersError = GetOrganizationMembersErrors[keyof GetOrganizationMembersErrors];

export type GetOrganizationMembersResponses = {
    /**
     * Successful Response
     */
    200: PaginatedResponseOrganizationMemberResponse;
};

export type GetOrganizationMembersResponse = GetOrganizationMembersResponses[keyof GetOrganizationMembersResponses];

export type StreamProjectEventsData = {
    body?: never;
    headers?: {
        /**
         * Authorization
         */
        Authorization?: string | null;
        /**
         * Last-Event-Id
         */
        'Last-Event-ID'?: string | null;
    };
    path: {
        /**
         * Project Id
         */
        project_id: string;
    };
    query?: {
        /**
         * Token
         *
         * Auth token (for EventSource compatibility)
         */
        token?: string | null;
    };
    url: '/api/v1/projects/{project_id}/events/stream';
};

export type StreamProjectEventsErrors = {
    /**
     * Not authenticated
     */
    401: unknown;
    /**
     * Not authorized to access this project
     */
    403: unknown;
    /**
     * Project not found
     */
    404: unknown;
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type StreamProjectEventsError = StreamProjectEventsErrors[keyof StreamProjectEventsErrors];

export type StreamProjectEventsResponses = {
    /**
     * SSE stream established
     */
    200: unknown;
};

export type SendTestEventData = {
    body?: never;
    path: {
        /**
         * Project Id
         */
        project_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}/events/test';
};

export type SendTestEventErrors = {
    /**
     * Not authenticated
     */
    401: unknown;
    /**
     * Not authorized to access this project
     */
    403: unknown;
    /**
     * Validation Error
     */
    422: HttpValidationError;
};

export type SendTestEventError = SendTestEventErrors[keyof SendTestEventErrors];

export type SendTestEventResponses = {
    /**
     * Response Send Test Event
     *
     * Test event sent
     */
    200: {
        [key: string]: unknown;
    };
};

export type SendTestEventResponse = SendTestEventResponses[keyof SendTestEventResponses];

export type ListProjectsData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Status
         *
         * Filter by project status
         */
        status?: ProjectStatus | null;
        /**
         * Search
         *
         * Search by name, slug, or description
         */
        search?: string | null;
        /**
         * All Projects
         *
         * Show all projects (superuser only)
         */
        all_projects?: boolean;
        /**
         * Page
         */
        page?: number;
        /**
         * Limit
         */
        limit?: number;
    };
    url: '/api/v1/projects';
};

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

export type ListProjectsError = ListProjectsErrors[keyof ListProjectsErrors];

export type ListProjectsResponses = {
    /**
     * Successful Response
     */
    200: PaginatedResponseProjectResponse;
};

export type ListProjectsResponse = ListProjectsResponses[keyof ListProjectsResponses];

export type CreateProjectData = {
    body: ProjectCreate;
    path?: never;
    query?: never;
    url: '/api/v1/projects';
};

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

export type CreateProjectError = CreateProjectErrors[keyof CreateProjectErrors];

export type CreateProjectResponses = {
    /**
     * Successful Response
     */
    201: ProjectResponse;
};

export type CreateProjectResponse = CreateProjectResponses[keyof CreateProjectResponses];

export type ArchiveProjectData = {
    body?: never;
    path: {
        /**
         * Project Id
         */
        project_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}';
};

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

export type ArchiveProjectError = ArchiveProjectErrors[keyof ArchiveProjectErrors];

export type ArchiveProjectResponses = {
    /**
     * Successful Response
     */
    200: MessageResponse;
};

export type ArchiveProjectResponse = ArchiveProjectResponses[keyof ArchiveProjectResponses];

export type GetProjectData = {
    body?: never;
    path: {
        /**
         * Project Id
         */
        project_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}';
};

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

export type GetProjectError = GetProjectErrors[keyof GetProjectErrors];

export type GetProjectResponses = {
    /**
     * Successful Response
     */
    200: ProjectResponse;
};

export type GetProjectResponse = GetProjectResponses[keyof GetProjectResponses];

export type UpdateProjectData = {
    body: ProjectUpdate;
    path: {
        /**
         * Project Id
         */
        project_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}';
};

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

export type UpdateProjectError = UpdateProjectErrors[keyof UpdateProjectErrors];

export type UpdateProjectResponses = {
    /**
     * Successful Response
     */
    200: ProjectResponse;
};

export type UpdateProjectResponse = UpdateProjectResponses[keyof UpdateProjectResponses];

export type GetProjectBySlugData = {
    body?: never;
    path: {
        /**
         * Slug
         */
        slug: string;
    };
    query?: never;
    url: '/api/v1/projects/slug/{slug}';
};

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

export type GetProjectBySlugError = GetProjectBySlugErrors[keyof GetProjectBySlugErrors];

export type GetProjectBySlugResponses = {
    /**
     * Successful Response
     */
    200: ProjectResponse;
};

export type GetProjectBySlugResponse = GetProjectBySlugResponses[keyof GetProjectBySlugResponses];

export type PauseProjectData = {
    body?: never;
    path: {
        /**
         * Project Id
         */
        project_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}/pause';
};

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

export type PauseProjectError = PauseProjectErrors[keyof PauseProjectErrors];

export type PauseProjectResponses = {
    /**
     * Successful Response
     */
    200: ProjectResponse;
};

export type PauseProjectResponse = PauseProjectResponses[keyof PauseProjectResponses];

export type ResumeProjectData = {
    body?: never;
    path: {
        /**
         * Project Id
         */
        project_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}/resume';
};

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

export type ResumeProjectError = ResumeProjectErrors[keyof ResumeProjectErrors];

export type ResumeProjectResponses = {
    /**
     * Successful Response
     */
    200: ProjectResponse;
};

export type ResumeProjectResponse = ResumeProjectResponses[keyof ResumeProjectResponses];

export type ListAgentTypesData = {
    body?: never;
    path?: never;
    query?: {
        /**
         * Is Active
         *
         * Filter by active status
         */
        is_active?: boolean;
        /**
         * Search
         *
         * Search by name, slug, description
         */
        search?: string | null;
        /**
         * Page
         */
        page?: number;
        /**
         * Limit
         */
        limit?: number;
    };
    url: '/api/v1/agent-types';
};

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

export type ListAgentTypesError = ListAgentTypesErrors[keyof ListAgentTypesErrors];

export type ListAgentTypesResponses = {
    /**
     * Successful Response
     */
    200: PaginatedResponseAgentTypeResponse;
};

export type ListAgentTypesResponse = ListAgentTypesResponses[keyof ListAgentTypesResponses];

export type CreateAgentTypeData = {
    body: AgentTypeCreate;
    path?: never;
    query?: never;
    url: '/api/v1/agent-types';
};

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

export type CreateAgentTypeError = CreateAgentTypeErrors[keyof CreateAgentTypeErrors];

export type CreateAgentTypeResponses = {
    /**
     * Successful Response
     */
    201: AgentTypeResponse;
};

export type CreateAgentTypeResponse = CreateAgentTypeResponses[keyof CreateAgentTypeResponses];

export type DeactivateAgentTypeData = {
    body?: never;
    path: {
        /**
         * Agent Type Id
         */
        agent_type_id: string;
    };
    query?: never;
    url: '/api/v1/agent-types/{agent_type_id}';
};

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

export type DeactivateAgentTypeError = DeactivateAgentTypeErrors[keyof DeactivateAgentTypeErrors];

export type DeactivateAgentTypeResponses = {
    /**
     * Successful Response
     */
    200: MessageResponse;
};

export type DeactivateAgentTypeResponse = DeactivateAgentTypeResponses[keyof DeactivateAgentTypeResponses];

export type GetAgentTypeData = {
    body?: never;
    path: {
        /**
         * Agent Type Id
         */
        agent_type_id: string;
    };
    query?: never;
    url: '/api/v1/agent-types/{agent_type_id}';
};

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

export type GetAgentTypeError = GetAgentTypeErrors[keyof GetAgentTypeErrors];

export type GetAgentTypeResponses = {
    /**
     * Successful Response
     */
    200: AgentTypeResponse;
};

export type GetAgentTypeResponse = GetAgentTypeResponses[keyof GetAgentTypeResponses];

export type UpdateAgentTypeData = {
    body: AgentTypeUpdate;
    path: {
        /**
         * Agent Type Id
         */
        agent_type_id: string;
    };
    query?: never;
    url: '/api/v1/agent-types/{agent_type_id}';
};

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

export type UpdateAgentTypeError = UpdateAgentTypeErrors[keyof UpdateAgentTypeErrors];

export type UpdateAgentTypeResponses = {
    /**
     * Successful Response
     */
    200: AgentTypeResponse;
};

export type UpdateAgentTypeResponse = UpdateAgentTypeResponses[keyof UpdateAgentTypeResponses];

export type GetAgentTypeBySlugData = {
    body?: never;
    path: {
        /**
         * Slug
         */
        slug: string;
    };
    query?: never;
    url: '/api/v1/agent-types/slug/{slug}';
};

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

export type GetAgentTypeBySlugError = GetAgentTypeBySlugErrors[keyof GetAgentTypeBySlugErrors];

export type GetAgentTypeBySlugResponses = {
    /**
     * Successful Response
     */
    200: AgentTypeResponse;
};

export type GetAgentTypeBySlugResponse = GetAgentTypeBySlugResponses[keyof GetAgentTypeBySlugResponses];

export type ListIssuesData = {
    body?: never;
    path: {
        /**
         * Project Id
         */
        project_id: string;
    };
    query?: {
        /**
         * Status
         *
         * Filter by issue status
         */
        status?: IssueStatus | null;
        /**
         * Priority
         *
         * Filter by priority
         */
        priority?: IssuePriority | null;
        /**
         * Labels
         *
         * Filter by labels (comma-separated)
         */
        labels?: Array<string> | null;
        /**
         * Sprint Id
         *
         * Filter by sprint ID
         */
        sprint_id?: string | null;
        /**
         * Assigned Agent Id
         *
         * Filter by assigned agent ID
         */
        assigned_agent_id?: string | null;
        /**
         * Sync Status
         *
         * Filter by sync status
         */
        sync_status?: SyncStatus | null;
        /**
         * Search
         *
         * Search in title and body
         */
        search?: string | null;
        /**
         * Sort By
         *
         * Field to sort by (created_at, updated_at, priority, status, title)
         */
        sort_by?: string;
        /**
         * Sort order
         */
        sort_order?: SortOrder;
        /**
         * Page
         */
        page?: number;
        /**
         * Limit
         */
        limit?: number;
    };
    url: '/api/v1/projects/{project_id}/issues';
};

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

export type ListIssuesError = ListIssuesErrors[keyof ListIssuesErrors];

export type ListIssuesResponses = {
    /**
     * Successful Response
     */
    200: PaginatedResponseIssueResponse;
};

export type ListIssuesResponse = ListIssuesResponses[keyof ListIssuesResponses];

export type CreateIssueData = {
    body: IssueCreate;
    path: {
        /**
         * Project Id
         */
        project_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}/issues';
};

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

export type CreateIssueError = CreateIssueErrors[keyof CreateIssueErrors];

export type CreateIssueResponses = {
    /**
     * Successful Response
     */
    201: IssueResponse;
};

export type CreateIssueResponse = CreateIssueResponses[keyof CreateIssueResponses];

export type GetIssueStatsData = {
    body?: never;
    path: {
        /**
         * Project Id
         */
        project_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}/issues/stats';
};

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

export type GetIssueStatsError = GetIssueStatsErrors[keyof GetIssueStatsErrors];

export type GetIssueStatsResponses = {
    /**
     * Successful Response
     */
    200: IssueStats;
};

export type GetIssueStatsResponse = GetIssueStatsResponses[keyof GetIssueStatsResponses];

export type DeleteIssueData = {
    body?: never;
    path: {
        /**
         * Project Id
         */
        project_id: string;
        /**
         * Issue Id
         */
        issue_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}/issues/{issue_id}';
};

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

export type DeleteIssueError = DeleteIssueErrors[keyof DeleteIssueErrors];

export type DeleteIssueResponses = {
    /**
     * Successful Response
     */
    200: MessageResponse;
};

export type DeleteIssueResponse = DeleteIssueResponses[keyof DeleteIssueResponses];

export type GetIssueData = {
    body?: never;
    path: {
        /**
         * Project Id
         */
        project_id: string;
        /**
         * Issue Id
         */
        issue_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}/issues/{issue_id}';
};

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

export type GetIssueError = GetIssueErrors[keyof GetIssueErrors];

export type GetIssueResponses = {
    /**
     * Successful Response
     */
    200: IssueResponse;
};

export type GetIssueResponse = GetIssueResponses[keyof GetIssueResponses];

export type UpdateIssueData = {
    body: IssueUpdate;
    path: {
        /**
         * Project Id
         */
        project_id: string;
        /**
         * Issue Id
         */
        issue_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}/issues/{issue_id}';
};

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

export type UpdateIssueError = UpdateIssueErrors[keyof UpdateIssueErrors];

export type UpdateIssueResponses = {
    /**
     * Successful Response
     */
    200: IssueResponse;
};

export type UpdateIssueResponse = UpdateIssueResponses[keyof UpdateIssueResponses];

export type AssignIssueData = {
    body: IssueAssign;
    path: {
        /**
         * Project Id
         */
        project_id: string;
        /**
         * Issue Id
         */
        issue_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}/issues/{issue_id}/assign';
};

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

export type AssignIssueError = AssignIssueErrors[keyof AssignIssueErrors];

export type AssignIssueResponses = {
    /**
     * Successful Response
     */
    200: IssueResponse;
};

export type AssignIssueResponse = AssignIssueResponses[keyof AssignIssueResponses];

export type UnassignIssueData = {
    body?: never;
    path: {
        /**
         * Project Id
         */
        project_id: string;
        /**
         * Issue Id
         */
        issue_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}/issues/{issue_id}/assignment';
};

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

export type UnassignIssueError = UnassignIssueErrors[keyof UnassignIssueErrors];

export type UnassignIssueResponses = {
    /**
     * Successful Response
     */
    200: IssueResponse;
};

export type UnassignIssueResponse = UnassignIssueResponses[keyof UnassignIssueResponses];

export type SyncIssueData = {
    body?: never;
    path: {
        /**
         * Project Id
         */
        project_id: string;
        /**
         * Issue Id
         */
        issue_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}/issues/{issue_id}/sync';
};

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

export type SyncIssueError = SyncIssueErrors[keyof SyncIssueErrors];

export type SyncIssueResponses = {
    /**
     * Successful Response
     */
    200: MessageResponse;
};

export type SyncIssueResponse = SyncIssueResponses[keyof SyncIssueResponses];

export type ListProjectAgentsData = {
    body?: never;
    path: {
        /**
         * Project Id
         */
        project_id: string;
    };
    query?: {
        /**
         * Status
         *
         * Filter by agent status
         */
        status?: AgentStatus | null;
        /**
         * Page
         */
        page?: number;
        /**
         * Limit
         */
        limit?: number;
    };
    url: '/api/v1/projects/{project_id}/agents';
};

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

export type ListProjectAgentsError = ListProjectAgentsErrors[keyof ListProjectAgentsErrors];

export type ListProjectAgentsResponses = {
    /**
     * Successful Response
     */
    200: PaginatedResponseAgentInstanceResponse;
};

export type ListProjectAgentsResponse = ListProjectAgentsResponses[keyof ListProjectAgentsResponses];

export type SpawnAgentData = {
    body: AgentInstanceCreate;
    path: {
        /**
         * Project Id
         */
        project_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}/agents';
};

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

export type SpawnAgentError = SpawnAgentErrors[keyof SpawnAgentErrors];

export type SpawnAgentResponses = {
    /**
     * Successful Response
     */
    201: AgentInstanceResponse;
};

export type SpawnAgentResponse = SpawnAgentResponses[keyof SpawnAgentResponses];

export type GetProjectAgentMetricsData = {
    body?: never;
    path: {
        /**
         * Project Id
         */
        project_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}/agents/metrics';
};

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

export type GetProjectAgentMetricsError = GetProjectAgentMetricsErrors[keyof GetProjectAgentMetricsErrors];

export type GetProjectAgentMetricsResponses = {
    /**
     * Successful Response
     */
    200: AgentInstanceMetrics;
};

export type GetProjectAgentMetricsResponse = GetProjectAgentMetricsResponses[keyof GetProjectAgentMetricsResponses];

export type TerminateAgentData = {
    body?: never;
    path: {
        /**
         * Project Id
         */
        project_id: string;
        /**
         * Agent Id
         */
        agent_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}/agents/{agent_id}';
};

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

export type TerminateAgentError = TerminateAgentErrors[keyof TerminateAgentErrors];

export type TerminateAgentResponses = {
    /**
     * Successful Response
     */
    200: MessageResponse;
};

export type TerminateAgentResponse = TerminateAgentResponses[keyof TerminateAgentResponses];

export type GetAgentData = {
    body?: never;
    path: {
        /**
         * Project Id
         */
        project_id: string;
        /**
         * Agent Id
         */
        agent_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}/agents/{agent_id}';
};

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

export type GetAgentError = GetAgentErrors[keyof GetAgentErrors];

export type GetAgentResponses = {
    /**
     * Successful Response
     */
    200: AgentInstanceResponse;
};

export type GetAgentResponse = GetAgentResponses[keyof GetAgentResponses];

export type UpdateAgentData = {
    body: AgentInstanceUpdate;
    path: {
        /**
         * Project Id
         */
        project_id: string;
        /**
         * Agent Id
         */
        agent_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}/agents/{agent_id}';
};

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

export type UpdateAgentError = UpdateAgentErrors[keyof UpdateAgentErrors];

export type UpdateAgentResponses = {
    /**
     * Successful Response
     */
    200: AgentInstanceResponse;
};

export type UpdateAgentResponse = UpdateAgentResponses[keyof UpdateAgentResponses];

export type PauseAgentData = {
    body?: never;
    path: {
        /**
         * Project Id
         */
        project_id: string;
        /**
         * Agent Id
         */
        agent_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}/agents/{agent_id}/pause';
};

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

export type PauseAgentError = PauseAgentErrors[keyof PauseAgentErrors];

export type PauseAgentResponses = {
    /**
     * Successful Response
     */
    200: AgentInstanceResponse;
};

export type PauseAgentResponse = PauseAgentResponses[keyof PauseAgentResponses];

export type ResumeAgentData = {
    body?: never;
    path: {
        /**
         * Project Id
         */
        project_id: string;
        /**
         * Agent Id
         */
        agent_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}/agents/{agent_id}/resume';
};

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

export type ResumeAgentError = ResumeAgentErrors[keyof ResumeAgentErrors];

export type ResumeAgentResponses = {
    /**
     * Successful Response
     */
    200: AgentInstanceResponse;
};

export type ResumeAgentResponse = ResumeAgentResponses[keyof ResumeAgentResponses];

export type GetAgentMetricsData = {
    body?: never;
    path: {
        /**
         * Project Id
         */
        project_id: string;
        /**
         * Agent Id
         */
        agent_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}/agents/{agent_id}/metrics';
};

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

export type GetAgentMetricsError = GetAgentMetricsErrors[keyof GetAgentMetricsErrors];

export type GetAgentMetricsResponses = {
    /**
     * Successful Response
     */
    200: AgentInstanceMetrics;
};

export type GetAgentMetricsResponse = GetAgentMetricsResponses[keyof GetAgentMetricsResponses];

export type ListSprintsData = {
    body?: never;
    path: {
        /**
         * Project Id
         */
        project_id: string;
    };
    query?: {
        /**
         * Status
         *
         * Filter by sprint status
         */
        status?: SprintStatus | null;
        /**
         * Page
         */
        page?: number;
        /**
         * Limit
         */
        limit?: number;
    };
    url: '/api/v1/projects/{project_id}/sprints';
};

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

export type ListSprintsError = ListSprintsErrors[keyof ListSprintsErrors];

export type ListSprintsResponses = {
    /**
     * Successful Response
     */
    200: PaginatedResponseSprintResponse;
};

export type ListSprintsResponse = ListSprintsResponses[keyof ListSprintsResponses];

export type CreateSprintData = {
    body: SprintCreate;
    path: {
        /**
         * Project Id
         */
        project_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}/sprints';
};

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

export type CreateSprintError = CreateSprintErrors[keyof CreateSprintErrors];

export type CreateSprintResponses = {
    /**
     * Successful Response
     */
    201: SprintResponse;
};

export type CreateSprintResponse = CreateSprintResponses[keyof CreateSprintResponses];

export type GetActiveSprintData = {
    body?: never;
    path: {
        /**
         * Project Id
         */
        project_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}/sprints/active';
};

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

export type GetActiveSprintError = GetActiveSprintErrors[keyof GetActiveSprintErrors];

export type GetActiveSprintResponses = {
    /**
     * Response Get Active Sprint
     *
     * Successful Response
     */
    200: SprintResponse | null;
};

export type GetActiveSprintResponse = GetActiveSprintResponses[keyof GetActiveSprintResponses];

export type GetProjectVelocityData = {
    body?: never;
    path: {
        /**
         * Project Id
         */
        project_id: string;
    };
    query?: {
        /**
         * Limit
         *
         * Number of completed sprints to include
         */
        limit?: number;
    };
    url: '/api/v1/projects/{project_id}/sprints/velocity';
};

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

export type GetProjectVelocityError = GetProjectVelocityErrors[keyof GetProjectVelocityErrors];

export type GetProjectVelocityResponses = {
    /**
     * Response Get Project Velocity
     *
     * Successful Response
     */
    200: Array<SprintVelocity>;
};

export type GetProjectVelocityResponse = GetProjectVelocityResponses[keyof GetProjectVelocityResponses];

export type DeleteSprintData = {
    body?: never;
    path: {
        /**
         * Project Id
         */
        project_id: string;
        /**
         * Sprint Id
         */
        sprint_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}/sprints/{sprint_id}';
};

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

export type DeleteSprintError = DeleteSprintErrors[keyof DeleteSprintErrors];

export type DeleteSprintResponses = {
    /**
     * Successful Response
     */
    200: MessageResponse;
};

export type DeleteSprintResponse = DeleteSprintResponses[keyof DeleteSprintResponses];

export type GetSprintData = {
    body?: never;
    path: {
        /**
         * Project Id
         */
        project_id: string;
        /**
         * Sprint Id
         */
        sprint_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}/sprints/{sprint_id}';
};

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

export type GetSprintError = GetSprintErrors[keyof GetSprintErrors];

export type GetSprintResponses = {
    /**
     * Successful Response
     */
    200: SprintResponse;
};

export type GetSprintResponse = GetSprintResponses[keyof GetSprintResponses];

export type UpdateSprintData = {
    body: SprintUpdate;
    path: {
        /**
         * Project Id
         */
        project_id: string;
        /**
         * Sprint Id
         */
        sprint_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}/sprints/{sprint_id}';
};

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

export type UpdateSprintError = UpdateSprintErrors[keyof UpdateSprintErrors];

export type UpdateSprintResponses = {
    /**
     * Successful Response
     */
    200: SprintResponse;
};

export type UpdateSprintResponse = UpdateSprintResponses[keyof UpdateSprintResponses];

export type StartSprintData = {
    /**
     * Sprint Start
     */
    body?: SprintStart | null;
    path: {
        /**
         * Project Id
         */
        project_id: string;
        /**
         * Sprint Id
         */
        sprint_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}/sprints/{sprint_id}/start';
};

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

export type StartSprintError = StartSprintErrors[keyof StartSprintErrors];

export type StartSprintResponses = {
    /**
     * Successful Response
     */
    200: SprintResponse;
};

export type StartSprintResponse = StartSprintResponses[keyof StartSprintResponses];

export type CompleteSprintData = {
    /**
     * Sprint Complete
     */
    body?: SprintComplete | null;
    path: {
        /**
         * Project Id
         */
        project_id: string;
        /**
         * Sprint Id
         */
        sprint_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}/sprints/{sprint_id}/complete';
};

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

export type CompleteSprintError = CompleteSprintErrors[keyof CompleteSprintErrors];

export type CompleteSprintResponses = {
    /**
     * Successful Response
     */
    200: SprintResponse;
};

export type CompleteSprintResponse = CompleteSprintResponses[keyof CompleteSprintResponses];

export type CancelSprintData = {
    body?: never;
    path: {
        /**
         * Project Id
         */
        project_id: string;
        /**
         * Sprint Id
         */
        sprint_id: string;
    };
    query?: never;
    url: '/api/v1/projects/{project_id}/sprints/{sprint_id}/cancel';
};

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

export type CancelSprintError = CancelSprintErrors[keyof CancelSprintErrors];

export type CancelSprintResponses = {
    /**
     * Successful Response
     */
    200: SprintResponse;
};

export type CancelSprintResponse = CancelSprintResponses[keyof CancelSprintResponses];

export type RemoveIssueFromSprintData = {
    body?: never;
    path: {
        /**
         * Project Id
         */
        project_id: string;
        /**
         * Sprint Id
         */
        sprint_id: string;
    };
    query: {
        /**
         * Issue Id
         *
         * ID of the issue to remove from the sprint
         */
        issue_id: string;
    };
    url: '/api/v1/projects/{project_id}/sprints/{sprint_id}/issues';
};

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

export type RemoveIssueFromSprintError = RemoveIssueFromSprintErrors[keyof RemoveIssueFromSprintErrors];

export type RemoveIssueFromSprintResponses = {
    /**
     * Successful Response
     */
    200: MessageResponse;
};

export type RemoveIssueFromSprintResponse = RemoveIssueFromSprintResponses[keyof RemoveIssueFromSprintResponses];

export type GetSprintIssuesData = {
    body?: never;
    path: {
        /**
         * Project Id
         */
        project_id: string;
        /**
         * Sprint Id
         */
        sprint_id: string;
    };
    query?: {
        /**
         * Page
         */
        page?: number;
        /**
         * Limit
         */
        limit?: number;
    };
    url: '/api/v1/projects/{project_id}/sprints/{sprint_id}/issues';
};

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

export type GetSprintIssuesError = GetSprintIssuesErrors[keyof GetSprintIssuesErrors];

export type GetSprintIssuesResponses = {
    /**
     * Successful Response
     */
    200: PaginatedResponseIssueResponse;
};

export type GetSprintIssuesResponse = GetSprintIssuesResponses[keyof GetSprintIssuesResponses];

export type AddIssueToSprintData = {
    body?: never;
    path: {
        /**
         * Project Id
         */
        project_id: string;
        /**
         * Sprint Id
         */
        sprint_id: string;
    };
    query: {
        /**
         * Issue Id
         *
         * ID of the issue to add to the sprint
         */
        issue_id: string;
    };
    url: '/api/v1/projects/{project_id}/sprints/{sprint_id}/issues';
};

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

export type AddIssueToSprintError = AddIssueToSprintErrors[keyof AddIssueToSprintErrors];

export type AddIssueToSprintResponses = {
    /**
     * Successful Response
     */
    200: MessageResponse;
};

export type AddIssueToSprintResponse = AddIssueToSprintResponses[keyof AddIssueToSprintResponses];

export type GetOauthServerMetadataData = {
    body?: never;
    path?: never;
    query?: never;
    url: '/.well-known/oauth-authorization-server';
};

export type GetOauthServerMetadataResponses = {
    /**
     * Successful Response
     */
    200: OAuthServerMetadata;
};

export type GetOauthServerMetadataResponse = GetOauthServerMetadataResponses[keyof GetOauthServerMetadataResponses];
