@oriva/sdk 0.1.0

package/dist/generated/types.gen.d.ts

@@ -0,0 +1,1652 @@
+export type ClientOptions = {
+    baseUrl: 'https://api.oriva.io' | 'http://localhost:3002' | (string & {});
+};
+export type AuthSessionResponse = {
+    user: {
+        id: string;
+        email: string | null;
+        display_name: string | null;
+        username: string | null;
+        subscription_tier: string;
+        created_at: string;
+    };
+    access_token: string;
+    refresh_token: string;
+    expires_in: number;
+};
+export type AuthProfileResponse = {
+    ok: boolean;
+    success: boolean;
+    data: {
+        id: string;
+        email: string | null;
+        displayName: string;
+        avatar: string | null;
+        authType: string;
+        permissions: Array<string>;
+        lastLogin: string;
+        accountStatus: string;
+        twoFactorEnabled: boolean;
+        emailVerified: boolean;
+    };
+};
+export type RawProfileResponse = {
+    id: string;
+    display_name: string | null;
+    username: string | null;
+    bio: string | null;
+    avatar_url: string | null;
+    location: string | null;
+    website_url: string | null;
+};
+export type TokenRefreshResponse = {
+    access_token: string;
+    refresh_token: string;
+    expires_in: number;
+};
+export type ProfileSummary = {
+    profileId: string;
+    profileName: string;
+    isActive: boolean;
+    avatar: string | null;
+    isDefault: boolean;
+};
+export type UpdatedProfile = {
+    ok: boolean;
+    success: boolean;
+    data: {
+        profileId: string;
+        profileName: string;
+        isActive: boolean;
+        avatar: string | null;
+        bio: string | null;
+        location: string | null;
+        updatedAt: string;
+    };
+    message?: string;
+};
+export type GroupSummary = {
+    groupId: string;
+    groupName: string;
+    memberCount: number;
+    isActive: boolean;
+    role: string;
+    description: string | null;
+    image_url: string | null;
+    external_link: string | null;
+};
+export type GroupMember = {
+    memberId: string;
+    displayName: string;
+    role: string;
+    joinedAt: string;
+    avatar: string | null;
+};
+export type UserMe = {
+    ok: boolean;
+    success: boolean;
+    data: {
+        id: string;
+        username: string | null;
+        displayName: string;
+        email: string | null;
+        bio: string | null;
+        location: string | null;
+        website: string | null;
+        avatar: string | null;
+        createdAt: string;
+        updatedAt: string;
+        apiKeyInfo: {
+            keyId: string;
+            name: string;
+            userId: string;
+            permissions: Array<string>;
+            usageCount: number;
+        };
+    };
+};
+export type AnalyticsSummary = {
+    ok: boolean;
+    success: boolean;
+    data: {
+        overview: {
+            totalEntries: number;
+            totalResponses: number;
+            totalGroups: number;
+            installedApps: number;
+        };
+        metrics: {
+            entriesGrowth: string;
+            responseGrowth: string;
+            groupActivity: string;
+            appUsage: string;
+        };
+        recentActivity: Array<unknown>;
+        timeRange: {
+            start: string;
+            end: string;
+        };
+    };
+    message?: string;
+};
+export type TeamMember = {
+    profileId: string;
+    displayName: string | null;
+    username: string | null;
+    avatarUrl: string | null;
+    role: string;
+    joinedAt: string;
+    group: {
+        id: string;
+        name: string;
+    };
+};
+export type MarketplaceApp = {
+    id: string;
+    external_id?: string;
+    name: string;
+    slug: string;
+    tagline?: string | null;
+    description?: string | null;
+    category: string;
+    icon_url?: string | null;
+    screenshots?: Array<string> | null;
+    version: string;
+    pricing_model: string;
+    pricing_config?: {
+        [key: string]: unknown;
+    } | null;
+    install_count: number;
+    developer_id: string;
+    developer_name: string;
+    status: 'draft' | 'pending_review' | 'approved' | 'rejected';
+    is_active: boolean;
+    supported_audience?: Array<string> | null;
+    created_at: string;
+    updated_at: string;
+};
+export type InstalledApp = {
+    installationId: string;
+    installedAt: string;
+    isActive: boolean;
+    settings: {
+        [key: string]: unknown;
+    } | null;
+    app: MarketplaceApp;
+};
+export type MarketplaceItem = {
+    id: string;
+    title: string;
+    content?: string | null;
+    profile_id: string;
+    entry_type: string;
+    marketplace_metadata?: {
+        [key: string]: unknown;
+    } | null;
+    created_at: string;
+    updated_at: string;
+};
+export type Category = {
+    id: string;
+    name: string;
+    description?: string | null;
+    collection_type: string;
+    organization_rules?: {
+        [key: string]: unknown;
+    } | null;
+    created_at: string;
+    updated_at: string;
+};
+export type Entry = {
+    id: string;
+    title: string;
+    content: string;
+    profile_id: string;
+    audience_type: string;
+    created_at: string;
+    updated_at: string;
+};
+export type Event = {
+    id: string;
+    title: string;
+    description: string;
+    startDate: string;
+    endDate: string;
+    location: string | null;
+    isOnline: boolean;
+    category: string;
+    organizer: string;
+    maxAttendees: number | null;
+    currentAttendees: number | null;
+    price: number;
+    tags: Array<string>;
+    imageUrl: string | null;
+    createdAt: string;
+    updatedAt: string;
+};
+export type CreatedPersonalToken = {
+    ok: true;
+    success: true;
+    data: {
+        /**
+         * Full token value — displayed ONCE. Store it now; it cannot be retrieved again.
+         */
+        token: string;
+        id: string;
+        name: string;
+        /**
+         * First 20 characters of the token, safe to display later.
+         */
+        prefix: string;
+        created_at: string;
+        expires_at: string | null;
+    };
+};
+export type PersonalTokenSummary = {
+    id: string;
+    name: string;
+    prefix: string;
+    created_at: string;
+    last_used_at: string | null;
+    expires_at: string | null;
+    is_active: boolean;
+};
+export type PersonalTokenList = {
+    ok: true;
+    success: true;
+    data: Array<PersonalTokenSummary>;
+};
+export type RegisterData = {
+    body?: {
+        email: string;
+        password: string;
+        name?: string;
+        username?: string;
+        preferences?: unknown;
+    };
+    path?: never;
+    query?: never;
+    url: '/api/v1/auth/register';
+};
+export type RegisterErrors = {
+    /**
+     * Validation error — weak password or invalid email
+     */
+    400: unknown;
+    /**
+     * Email already registered
+     */
+    409: unknown;
+};
+export type RegisterResponses = {
+    /**
+     * User registered and session created
+     */
+    201: AuthSessionResponse;
+};
+export type RegisterResponse = RegisterResponses[keyof RegisterResponses];
+export type LoginData = {
+    body?: {
+        email: string;
+        password: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/api/v1/auth/login';
+};
+export type LoginErrors = {
+    /**
+     * Validation error — missing email or password
+     */
+    400: unknown;
+    /**
+     * Invalid credentials
+     */
+    401: unknown;
+};
+export type LoginResponses = {
+    /**
+     * Login successful
+     */
+    200: AuthSessionResponse;
+};
+export type LoginResponse = LoginResponses[keyof LoginResponses];
+export type LogoutData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/auth/logout';
+};
+export type LogoutErrors = {
+    /**
+     * Missing authorization header
+     */
+    401: unknown;
+};
+export type LogoutResponses = {
+    /**
+     * Logged out
+     */
+    204: void;
+};
+export type LogoutResponse = LogoutResponses[keyof LogoutResponses];
+export type RefreshTokenData = {
+    body?: {
+        refresh_token: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/api/v1/auth/token/refresh';
+};
+export type RefreshTokenErrors = {
+    /**
+     * Validation error — missing refresh_token
+     */
+    400: unknown;
+    /**
+     * Invalid or expired refresh token
+     */
+    401: unknown;
+};
+export type RefreshTokenResponses = {
+    /**
+     * New tokens issued
+     */
+    200: TokenRefreshResponse;
+};
+export type RefreshTokenResponse = RefreshTokenResponses[keyof RefreshTokenResponses];
+export type GetAuthProfileData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/auth/profile';
+};
+export type GetAuthProfileErrors = {
+    /**
+     * Unauthorized
+     */
+    401: unknown;
+};
+export type GetAuthProfileResponses = {
+    /**
+     * Auth profile
+     */
+    200: AuthProfileResponse;
+};
+export type GetAuthProfileResponse = GetAuthProfileResponses[keyof GetAuthProfileResponses];
+export type PatchAuthProfileData = {
+    body?: {
+        name?: string;
+        bio?: string;
+        avatar_url?: string;
+        location?: string;
+        website_url?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/api/v1/auth/profile';
+};
+export type PatchAuthProfileErrors = {
+    /**
+     * No fields provided
+     */
+    400: unknown;
+    /**
+     * Unauthorized
+     */
+    401: unknown;
+};
+export type PatchAuthProfileResponses = {
+    /**
+     * Updated profile row
+     */
+    200: RawProfileResponse;
+};
+export type PatchAuthProfileResponse = PatchAuthProfileResponses[keyof PatchAuthProfileResponses];
+export type PutAuthProfileData = {
+    body?: {
+        name?: string;
+        bio?: string;
+        avatar_url?: string;
+        location?: string;
+        website_url?: string;
+        preferences?: {
+            [key: string]: unknown;
+        };
+        data_retention_days?: number;
+    };
+    path?: never;
+    query?: never;
+    url: '/api/v1/auth/profile';
+};
+export type PutAuthProfileErrors = {
+    /**
+     * No fields provided, or data_retention_days < 30
+     */
+    400: unknown;
+    /**
+     * Unauthorized
+     */
+    401: unknown;
+};
+export type PutAuthProfileResponses = {
+    /**
+     * Updated profile row
+     */
+    200: RawProfileResponse;
+};
+export type PutAuthProfileResponse = PutAuthProfileResponses[keyof PutAuthProfileResponses];
+export type DeleteAccountData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/auth/account';
+};
+export type DeleteAccountErrors = {
+    /**
+     * Unauthorized
+     */
+    401: unknown;
+};
+export type DeleteAccountResponses = {
+    /**
+     * Account deleted
+     */
+    204: void;
+};
+export type DeleteAccountResponse = DeleteAccountResponses[keyof DeleteAccountResponses];
+export type ListProfilesData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/profiles/available';
+};
+export type ListProfilesErrors = {
+    /**
+     * Invalid or missing API key
+     */
+    401: unknown;
+};
+export type ListProfilesResponses = {
+    /**
+     * Available profiles
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: Array<ProfileSummary>;
+    };
+};
+export type ListProfilesResponse = ListProfilesResponses[keyof ListProfilesResponses];
+export type GetActiveProfileData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/profiles/active';
+};
+export type GetActiveProfileErrors = {
+    /**
+     * Invalid or missing API key
+     */
+    401: unknown;
+};
+export type GetActiveProfileResponses = {
+    /**
+     * Active profile
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: ProfileSummary;
+    };
+};
+export type GetActiveProfileResponse = GetActiveProfileResponses[keyof GetActiveProfileResponses];
+export type UpdateProfileData = {
+    body?: {
+        profileName?: string;
+        avatar?: string;
+        bio?: string | null;
+        location?: string | null;
+    };
+    path: {
+        profileId: string;
+    };
+    query?: never;
+    url: '/api/v1/profiles/{profileId}';
+};
+export type UpdateProfileErrors = {
+    /**
+     * Validation error — invalid profileId format or body
+     */
+    400: unknown;
+    /**
+     * Invalid or missing API key
+     */
+    401: unknown;
+};
+export type UpdateProfileResponses = {
+    /**
+     * Profile updated
+     */
+    200: UpdatedProfile;
+};
+export type UpdateProfileResponse = UpdateProfileResponses[keyof UpdateProfileResponses];
+export type ActivateProfileData = {
+    body?: never;
+    path: {
+        profileId: string;
+    };
+    query?: never;
+    url: '/api/v1/profiles/{profileId}/activate';
+};
+export type ActivateProfileErrors = {
+    /**
+     * Validation error — invalid profileId format
+     */
+    400: unknown;
+    /**
+     * Invalid or missing API key
+     */
+    401: unknown;
+};
+export type ActivateProfileResponses = {
+    /**
+     * Profile activated
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: {
+            activeProfile: string;
+            switchedAt: string;
+        };
+    };
+};
+export type ActivateProfileResponse = ActivateProfileResponses[keyof ActivateProfileResponses];
+export type ListGroupsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/groups';
+};
+export type ListGroupsErrors = {
+    /**
+     * Invalid or missing API key
+     */
+    401: unknown;
+};
+export type ListGroupsResponses = {
+    /**
+     * User groups
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: Array<GroupSummary>;
+    };
+};
+export type ListGroupsResponse = ListGroupsResponses[keyof ListGroupsResponses];
+export type ListGroupMembersData = {
+    body?: never;
+    path: {
+        groupId: string;
+    };
+    query?: never;
+    url: '/api/v1/groups/{groupId}/members';
+};
+export type ListGroupMembersErrors = {
+    /**
+     * Validation error — invalid groupId format
+     */
+    400: unknown;
+    /**
+     * Invalid or missing API key
+     */
+    401: unknown;
+    /**
+     * Not a member or creator of this group
+     */
+    403: unknown;
+    /**
+     * Group not found
+     */
+    404: unknown;
+};
+export type ListGroupMembersResponses = {
+    /**
+     * Group members
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: Array<GroupMember>;
+    };
+};
+export type ListGroupMembersResponse = ListGroupMembersResponses[keyof ListGroupMembersResponses];
+export type GetCurrentUserData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/user/me';
+};
+export type GetCurrentUserErrors = {
+    /**
+     * Invalid or missing API key
+     */
+    401: unknown;
+};
+export type GetCurrentUserResponses = {
+    /**
+     * Current user
+     */
+    200: UserMe;
+};
+export type GetCurrentUserResponse = GetCurrentUserResponses[keyof GetCurrentUserResponses];
+export type GetAnalyticsSummaryData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/analytics/summary';
+};
+export type GetAnalyticsSummaryErrors = {
+    /**
+     * Invalid or missing API key
+     */
+    401: unknown;
+};
+export type GetAnalyticsSummaryResponses = {
+    /**
+     * Analytics summary
+     */
+    200: AnalyticsSummary;
+};
+export type GetAnalyticsSummaryResponse = GetAnalyticsSummaryResponses[keyof GetAnalyticsSummaryResponses];
+export type ListSessionsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/sessions';
+};
+export type ListSessionsErrors = {
+    /**
+     * Invalid or missing API key
+     */
+    401: unknown;
+};
+export type ListSessionsResponses = {
+    /**
+     * Sessions list (currently always empty)
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: Array<unknown>;
+        meta: {
+            pagination: {
+                page: number;
+                limit: number;
+                total: number;
+                totalPages: number;
+            };
+        };
+        message?: string;
+    };
+};
+export type ListSessionsResponse = ListSessionsResponses[keyof ListSessionsResponses];
+export type ListUpcomingSessionsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/sessions/upcoming';
+};
+export type ListUpcomingSessionsErrors = {
+    /**
+     * Invalid or missing API key
+     */
+    401: unknown;
+};
+export type ListUpcomingSessionsResponses = {
+    /**
+     * Upcoming sessions (currently always empty)
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: Array<unknown>;
+        message?: string;
+    };
+};
+export type ListUpcomingSessionsResponse = ListUpcomingSessionsResponses[keyof ListUpcomingSessionsResponses];
+export type ListTeamMembersData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/team/members';
+};
+export type ListTeamMembersErrors = {
+    /**
+     * Invalid or missing API key
+     */
+    401: unknown;
+};
+export type ListTeamMembersResponses = {
+    /**
+     * Team members
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: Array<TeamMember>;
+        meta: {
+            total: number;
+            roles: Array<string>;
+        };
+    };
+};
+export type ListTeamMembersResponse = ListTeamMembersResponses[keyof ListTeamMembersResponses];
+export type ListMarketplaceAppsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        limit?: number;
+        offset?: number;
+        category?: string;
+        search?: string;
+    };
+    url: '/api/v1/marketplace/apps';
+};
+export type ListMarketplaceAppsErrors = {
+    /**
+     * Invalid or missing API key
+     */
+    401: unknown;
+};
+export type ListMarketplaceAppsResponses = {
+    /**
+     * Marketplace apps
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: Array<MarketplaceApp>;
+        meta: {
+            pagination: {
+                page: number;
+                limit: number;
+                total: number;
+                totalPages: number;
+            };
+        };
+    };
+};
+export type ListMarketplaceAppsResponse = ListMarketplaceAppsResponses[keyof ListMarketplaceAppsResponses];
+export type ListTrendingAppsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/marketplace/trending';
+};
+export type ListTrendingAppsErrors = {
+    /**
+     * Invalid or missing API key
+     */
+    401: unknown;
+};
+export type ListTrendingAppsResponses = {
+    /**
+     * Trending apps
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: Array<MarketplaceApp>;
+    };
+};
+export type ListTrendingAppsResponse = ListTrendingAppsResponses[keyof ListTrendingAppsResponses];
+export type ListFeaturedAppsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/marketplace/featured';
+};
+export type ListFeaturedAppsErrors = {
+    /**
+     * Invalid or missing API key
+     */
+    401: unknown;
+};
+export type ListFeaturedAppsResponses = {
+    /**
+     * Featured apps
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: Array<MarketplaceApp>;
+    };
+};
+export type ListFeaturedAppsResponse = ListFeaturedAppsResponses[keyof ListFeaturedAppsResponses];
+export type ListMarketplaceCategoriesData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/marketplace/categories';
+};
+export type ListMarketplaceCategoriesErrors = {
+    /**
+     * Invalid or missing API key
+     */
+    401: unknown;
+};
+export type ListMarketplaceCategoriesResponses = {
+    /**
+     * Category counts
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: Array<{
+            category: string;
+            count: number;
+        }>;
+    };
+};
+export type ListMarketplaceCategoriesResponse = ListMarketplaceCategoriesResponses[keyof ListMarketplaceCategoriesResponses];
+export type GetMarketplaceAppData = {
+    body?: never;
+    path: {
+        appId: string;
+    };
+    query?: never;
+    url: '/api/v1/marketplace/apps/{appId}';
+};
+export type GetMarketplaceAppErrors = {
+    /**
+     * Invalid or missing API key
+     */
+    401: unknown;
+    /**
+     * App not found
+     */
+    404: unknown;
+};
+export type GetMarketplaceAppResponses = {
+    /**
+     * App details
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: MarketplaceApp;
+    };
+};
+export type GetMarketplaceAppResponse = GetMarketplaceAppResponses[keyof GetMarketplaceAppResponses];
+export type ListInstalledAppsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        limit?: number;
+        offset?: number;
+    };
+    url: '/api/v1/marketplace/installed';
+};
+export type ListInstalledAppsErrors = {
+    /**
+     * Unauthorized
+     */
+    401: unknown;
+};
+export type ListInstalledAppsResponses = {
+    /**
+     * Installed apps
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: Array<InstalledApp>;
+        meta: {
+            pagination: {
+                page: number;
+                limit: number;
+                total: number;
+                totalPages: number;
+            };
+        };
+    };
+};
+export type ListInstalledAppsResponse = ListInstalledAppsResponses[keyof ListInstalledAppsResponses];
+export type InstallMarketplaceAppData = {
+    body?: {
+        settings?: {
+            [key: string]: unknown;
+        };
+    };
+    path: {
+        appId: string;
+    };
+    query?: never;
+    url: '/api/v1/marketplace/install/{appId}';
+};
+export type InstallMarketplaceAppErrors = {
+    /**
+     * Unauthorized
+     */
+    401: unknown;
+    /**
+     * App not found or not available for installation
+     */
+    404: unknown;
+    /**
+     * App already installed
+     */
+    409: unknown;
+};
+export type InstallMarketplaceAppResponses = {
+    /**
+     * App installed
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: InstalledApp;
+        message: string;
+    };
+};
+export type InstallMarketplaceAppResponse = InstallMarketplaceAppResponses[keyof InstallMarketplaceAppResponses];
+export type UninstallMarketplaceAppData = {
+    body?: never;
+    path: {
+        appId: string;
+    };
+    query?: never;
+    url: '/api/v1/marketplace/uninstall/{appId}';
+};
+export type UninstallMarketplaceAppErrors = {
+    /**
+     * Unauthorized
+     */
+    401: unknown;
+    /**
+     * App installation not found
+     */
+    404: unknown;
+};
+export type UninstallMarketplaceAppResponses = {
+    /**
+     * App uninstalled
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        message: string;
+    };
+};
+export type UninstallMarketplaceAppResponse = UninstallMarketplaceAppResponses[keyof UninstallMarketplaceAppResponses];
+export type ListMarketplaceItemsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        limit?: number;
+        offset?: number;
+        item_type?: string;
+        earner_type?: string;
+        category_id?: string;
+        min_price?: number;
+        max_price?: number;
+        seller_id?: string;
+        search?: string;
+    };
+    url: '/api/v1/marketplace/items';
+};
+export type ListMarketplaceItemsResponses = {
+    /**
+     * Marketplace items
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: Array<MarketplaceItem>;
+        meta: {
+            pagination: {
+                page: number;
+                limit: number;
+                total: number;
+                totalPages: number;
+            };
+        };
+    };
+};
+export type ListMarketplaceItemsResponse = ListMarketplaceItemsResponses[keyof ListMarketplaceItemsResponses];
+export type GetMarketplaceItemData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/marketplace/items/{id}';
+};
+export type GetMarketplaceItemErrors = {
+    /**
+     * Item not found
+     */
+    404: unknown;
+};
+export type GetMarketplaceItemResponses = {
+    /**
+     * Marketplace item
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: MarketplaceItem;
+    };
+};
+export type GetMarketplaceItemResponse = GetMarketplaceItemResponses[keyof GetMarketplaceItemResponses];
+export type SearchMarketplaceData = {
+    body?: {
+        query: string;
+        filters?: {
+            [key: string]: unknown;
+        };
+        limit?: number;
+        offset?: number;
+    };
+    path?: never;
+    query?: never;
+    url: '/api/v1/marketplace/search';
+};
+export type SearchMarketplaceResponses = {
+    /**
+     * Search results
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: Array<MarketplaceItem>;
+        meta: {
+            pagination: {
+                page: number;
+                limit: number;
+                total: number;
+                totalPages: number;
+            };
+        };
+    };
+};
+export type SearchMarketplaceResponse = SearchMarketplaceResponses[keyof SearchMarketplaceResponses];
+export type GetCategoryTreeData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/marketplace/categories/tree';
+};
+export type GetCategoryTreeResponses = {
+    /**
+     * Category tree
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: Array<Category & {
+            children?: Array<{
+                [key: string]: unknown;
+            }>;
+        }>;
+    };
+};
+export type GetCategoryTreeResponse = GetCategoryTreeResponses[keyof GetCategoryTreeResponses];
+export type GetMarketplaceCategoryData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/marketplace/categories/{id}';
+};
+export type GetMarketplaceCategoryErrors = {
+    /**
+     * Category not found
+     */
+    404: unknown;
+};
+export type GetMarketplaceCategoryResponses = {
+    /**
+     * Category
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: Category;
+    };
+};
+export type GetMarketplaceCategoryResponse = GetMarketplaceCategoryResponses[keyof GetMarketplaceCategoryResponses];
+export type ListDeveloperAppsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/developer/apps';
+};
+export type ListDeveloperAppsErrors = {
+    /**
+     * Invalid or missing API key
+     */
+    401: unknown;
+};
+export type ListDeveloperAppsResponses = {
+    /**
+     * Developer apps
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: Array<MarketplaceApp>;
+    };
+};
+export type ListDeveloperAppsResponse = ListDeveloperAppsResponses[keyof ListDeveloperAppsResponses];
+export type CreateDeveloperAppData = {
+    body?: {
+        name: string;
+        slug: string;
+        tagline?: string;
+        description?: string;
+        category: string;
+        icon_url?: string;
+        screenshots?: Array<string>;
+        version?: string;
+        pricing_model?: string;
+        pricing_config?: {
+            [key: string]: unknown;
+        };
+        supported_audience?: Array<string>;
+    };
+    path?: never;
+    query?: never;
+    url: '/api/v1/developer/apps';
+};
+export type CreateDeveloperAppErrors = {
+    /**
+     * Invalid or missing API key
+     */
+    401: unknown;
+};
+export type CreateDeveloperAppResponses = {
+    /**
+     * App created (status: draft)
+     */
+    201: {
+        ok: boolean;
+        success: boolean;
+        data: MarketplaceApp;
+    };
+};
+export type CreateDeveloperAppResponse = CreateDeveloperAppResponses[keyof CreateDeveloperAppResponses];
+export type DeleteDeveloperAppData = {
+    body?: never;
+    path: {
+        appId: string;
+    };
+    query?: never;
+    url: '/api/v1/developer/apps/{appId}';
+};
+export type DeleteDeveloperAppErrors = {
+    /**
+     * App is not in draft status — cannot delete
+     */
+    400: unknown;
+    /**
+     * Invalid or missing API key
+     */
+    401: unknown;
+    /**
+     * App not found or not owned by this developer
+     */
+    404: unknown;
+};
+export type DeleteDeveloperAppResponses = {
+    /**
+     * App deleted
+     */
+    204: void;
+};
+export type DeleteDeveloperAppResponse = DeleteDeveloperAppResponses[keyof DeleteDeveloperAppResponses];
+export type GetDeveloperAppData = {
+    body?: never;
+    path: {
+        appId: string;
+    };
+    query?: never;
+    url: '/api/v1/developer/apps/{appId}';
+};
+export type GetDeveloperAppErrors = {
+    /**
+     * Invalid or missing API key
+     */
+    401: unknown;
+    /**
+     * App not found or not owned by this developer
+     */
+    404: unknown;
+};
+export type GetDeveloperAppResponses = {
+    /**
+     * App details
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: MarketplaceApp;
+    };
+};
+export type GetDeveloperAppResponse = GetDeveloperAppResponses[keyof GetDeveloperAppResponses];
+export type UpdateDeveloperAppData = {
+    body?: {
+        name?: string;
+        slug?: string;
+        tagline?: string;
+        description?: string;
+        category?: string;
+        icon_url?: string;
+        screenshots?: Array<string>;
+        version?: string;
+        pricing_model?: string;
+        pricing_config?: {
+            [key: string]: unknown;
+        };
+        supported_audience?: Array<string>;
+    };
+    path: {
+        appId: string;
+    };
+    query?: never;
+    url: '/api/v1/developer/apps/{appId}';
+};
+export type UpdateDeveloperAppErrors = {
+    /**
+     * Invalid or missing API key
+     */
+    401: unknown;
+    /**
+     * App not found or not owned by this developer
+     */
+    404: unknown;
+};
+export type UpdateDeveloperAppResponses = {
+    /**
+     * App updated
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: MarketplaceApp;
+    };
+};
+export type UpdateDeveloperAppResponse = UpdateDeveloperAppResponses[keyof UpdateDeveloperAppResponses];
+export type SubmitDeveloperAppData = {
+    body?: never;
+    path: {
+        appId: string;
+    };
+    query?: never;
+    url: '/api/v1/developer/apps/{appId}/submit';
+};
+export type SubmitDeveloperAppErrors = {
+    /**
+     * App is not in draft status
+     */
+    400: unknown;
+    /**
+     * Invalid or missing API key
+     */
+    401: unknown;
+    /**
+     * App not found or not owned by this developer
+     */
+    404: unknown;
+};
+export type SubmitDeveloperAppResponses = {
+    /**
+     * App submitted for review
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: MarketplaceApp;
+        message: string;
+    };
+};
+export type SubmitDeveloperAppResponse = SubmitDeveloperAppResponses[keyof SubmitDeveloperAppResponses];
+export type ResubmitDeveloperAppData = {
+    body?: {
+        name?: string;
+        slug?: string;
+        tagline?: string;
+        description?: string;
+        category?: string;
+        icon_url?: string;
+        screenshots?: Array<string>;
+        version?: string;
+        pricing_model?: string;
+        pricing_config?: {
+            [key: string]: unknown;
+        };
+        supported_audience?: Array<string>;
+    };
+    path: {
+        appId: string;
+    };
+    query?: never;
+    url: '/api/v1/developer/apps/{appId}/resubmit';
+};
+export type ResubmitDeveloperAppErrors = {
+    /**
+     * App is not in rejected status
+     */
+    400: unknown;
+    /**
+     * Invalid or missing API key
+     */
+    401: unknown;
+    /**
+     * App not found or not owned by this developer
+     */
+    404: unknown;
+};
+export type ResubmitDeveloperAppResponses = {
+    /**
+     * App resubmitted
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: MarketplaceApp;
+        message: string;
+    };
+};
+export type ResubmitDeveloperAppResponse = ResubmitDeveloperAppResponses[keyof ResubmitDeveloperAppResponses];
+export type ListEntriesData = {
+    body?: never;
+    path?: never;
+    query?: {
+        limit?: number;
+        offset?: number;
+    };
+    url: '/api/v1/entries';
+};
+export type ListEntriesErrors = {
+    /**
+     * Invalid or missing API key
+     */
+    401: unknown;
+    /**
+     * User profile not found
+     */
+    404: unknown;
+};
+export type ListEntriesResponses = {
+    /**
+     * Entries list
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: Array<Entry>;
+        meta: {
+            pagination: {
+                page: number;
+                limit: number;
+                total: number;
+                totalPages: number;
+            };
+        };
+    };
+};
+export type ListEntriesResponse = ListEntriesResponses[keyof ListEntriesResponses];
+export type ListTemplatesData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/templates';
+};
+export type ListTemplatesErrors = {
+    /**
+     * Invalid or missing API key
+     */
+    401: unknown;
+};
+export type ListTemplatesResponses = {
+    /**
+     * Templates list (currently always empty)
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: Array<unknown>;
+        meta: {
+            pagination: {
+                page: number;
+                limit: number;
+                total: number;
+                totalPages: number;
+            };
+        };
+    };
+};
+export type ListTemplatesResponse = ListTemplatesResponses[keyof ListTemplatesResponses];
+export type GetStorageData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/storage';
+};
+export type GetStorageErrors = {
+    /**
+     * Invalid or missing API key
+     */
+    401: unknown;
+};
+export type GetStorageResponses = {
+    /**
+     * Storage info
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: {
+            [key: string]: unknown;
+        };
+    };
+};
+export type GetStorageResponse = GetStorageResponses[keyof GetStorageResponses];
+export type CreateUiNotificationData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/ui/notifications';
+};
+export type CreateUiNotificationErrors = {
+    /**
+     * Invalid or missing API key
+     */
+    401: unknown;
+};
+export type CreateUiNotificationResponses = {
+    /**
+     * Notification created
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: {
+            id: string;
+        };
+    };
+};
+export type CreateUiNotificationResponse = CreateUiNotificationResponses[keyof CreateUiNotificationResponses];
+export type ListEventsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        category?: string;
+        startDate?: string;
+        endDate?: string;
+        limit?: number;
+        offset?: number;
+    };
+    url: '/api/oriva/events';
+};
+export type ListEventsResponses = {
+    /**
+     * Events list
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: Array<Event>;
+        total: number;
+        limit: number;
+        offset: number;
+    };
+};
+export type ListEventsResponse = ListEventsResponses[keyof ListEventsResponses];
+export type CreateEventData = {
+    body?: {
+        title: string;
+        description: string;
+        startDate: string;
+        endDate: string;
+        isOnline: boolean;
+        category: string;
+        location?: string | null;
+        maxAttendees?: number | null;
+        price?: number;
+        tags?: Array<string>;
+        imageUrl?: string | null;
+    };
+    path?: never;
+    query?: never;
+    url: '/api/oriva/events';
+};
+export type CreateEventErrors = {
+    /**
+     * Validation error — missing required fields or invalid category
+     */
+    400: unknown;
+    /**
+     * Unauthorized
+     */
+    401: unknown;
+};
+export type CreateEventResponses = {
+    /**
+     * Event created
+     */
+    201: {
+        ok: boolean;
+        success: boolean;
+        data: Event;
+        message: string;
+    };
+};
+export type CreateEventResponse = CreateEventResponses[keyof CreateEventResponses];
+export type GetEventData = {
+    body?: never;
+    path: {
+        eventId: string;
+    };
+    query?: never;
+    url: '/api/oriva/events/{eventId}';
+};
+export type GetEventErrors = {
+    /**
+     * Event not found
+     */
+    404: unknown;
+};
+export type GetEventResponses = {
+    /**
+     * Event details
+     */
+    200: {
+        ok: boolean;
+        success: boolean;
+        data: Event;
+    };
+};
+export type GetEventResponse = GetEventResponses[keyof GetEventResponses];
+export type ListPersonalAccessTokensData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/v1/me/tokens';
+};
+export type ListPersonalAccessTokensErrors = {
+    /**
+     * Not authenticated
+     */
+    401: unknown;
+};
+export type ListPersonalAccessTokensResponses = {
+    /**
+     * List of PATs
+     */
+    200: PersonalTokenList;
+};
+export type ListPersonalAccessTokensResponse = ListPersonalAccessTokensResponses[keyof ListPersonalAccessTokensResponses];
+export type CreatePersonalAccessTokenData = {
+    body: {
+        /**
+         * Human-readable label for the token
+         */
+        name: string;
+        /**
+         * ISO 8601 expiry date. Omit for a non-expiring token.
+         */
+        expires_at?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/api/v1/me/tokens';
+};
+export type CreatePersonalAccessTokenErrors = {
+    /**
+     * Validation error
+     */
+    400: unknown;
+    /**
+     * Not authenticated
+     */
+    401: unknown;
+};
+export type CreatePersonalAccessTokenResponses = {
+    /**
+     * Token created — contains the full one-time token value
+     */
+    201: CreatedPersonalToken;
+};
+export type CreatePersonalAccessTokenResponse = CreatePersonalAccessTokenResponses[keyof CreatePersonalAccessTokenResponses];
+export type RevokePersonalAccessTokenData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: never;
+    url: '/api/v1/me/tokens/{id}';
+};
+export type RevokePersonalAccessTokenErrors = {
+    /**
+     * Not authenticated
+     */
+    401: unknown;
+    /**
+     * Token not found or does not belong to this account
+     */
+    404: unknown;
+};
+export type RevokePersonalAccessTokenResponses = {
+    /**
+     * Revoked successfully
+     */
+    204: void;
+};
+export type RevokePersonalAccessTokenResponse = RevokePersonalAccessTokenResponses[keyof RevokePersonalAccessTokenResponses];
+//# sourceMappingURL=types.gen.d.ts.map