// 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>;
};

/**
 * 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>;
};

/**
 * 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[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[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;
};

/**
 * 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';

/**
 * 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?: {
        /**
         * Last-Event-Id
         */
        'Last-Event-ID'?: string | null;
    };
    path: {
        /**
         * Project Id
         */
        project_id: string;
    };
    query?: never;
    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 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];
