@octonodes/sdk 0.0.3

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

@@ -0,0 +1,4597 @@
+export type ClientOptions = {
+    baseUrl: `${string}://${string}` | (string & {});
+};
+export type GetApiCapabilitiesData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/capabilities';
+};
+export type GetApiCapabilitiesResponses = {
+    /**
+     * Success
+     */
+    200: {
+        version: 1;
+        mode: 'trusted-local' | 'configured-local-cloud' | 'hosted';
+        items: Array<{
+            name: 'workspace_identity' | 'workspace_social' | 'task_management' | 'workspace_admin' | 'workflow_execution' | 'billing' | 'design_review' | 'design_preview' | 'architecture' | 'repository_registry' | 'repository_discovery' | 'repository_git_read' | 'repository_git_write' | 'design_architecture_embed' | 'workspace_registry_backup_restore' | 'github' | 'slack' | 'google' | 'meta' | 'qwen' | 'workflow_agents' | 'cloud_terminal' | 'mcp_catalog' | 'monitoring' | 'agent_monitoring' | 'backup_restore' | 'write_authority' | 'community_read' | 'community_authoring' | 'community_publishing' | 'workflow_templates';
+            available: true;
+            mode: 'trusted-local' | 'configured-local-cloud' | 'hosted';
+        } | {
+            name: 'workspace_identity' | 'workspace_social' | 'task_management' | 'workspace_admin' | 'workflow_execution' | 'billing' | 'design_review' | 'design_preview' | 'architecture' | 'repository_registry' | 'repository_discovery' | 'repository_git_read' | 'repository_git_write' | 'design_architecture_embed' | 'workspace_registry_backup_restore' | 'github' | 'slack' | 'google' | 'meta' | 'qwen' | 'workflow_agents' | 'cloud_terminal' | 'mcp_catalog' | 'monitoring' | 'agent_monitoring' | 'backup_restore' | 'write_authority' | 'community_read' | 'community_authoring' | 'community_publishing' | 'workflow_templates';
+            available: false;
+            mode: 'trusted-local' | 'configured-local-cloud' | 'hosted';
+            reason: 'not_implemented' | 'requires_cloud_configuration' | 'requires_hosted_runtime' | 'provider_not_configured' | 'disabled_by_policy' | 'missing_entitlement' | 'missing_permission';
+        }>;
+    };
+};
+export type GetApiCapabilitiesResponse = GetApiCapabilitiesResponses[keyof GetApiCapabilitiesResponses];
+export type GetApiIdentityData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/identity';
+};
+export type GetApiIdentityResponses = {
+    /**
+     * Success
+     */
+    200: {
+        userId: string;
+        displayName?: string;
+        groups: Array<string>;
+        orgId: string;
+    };
+};
+export type GetApiIdentityResponse = GetApiIdentityResponses[keyof GetApiIdentityResponses];
+export type GetApiRunsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        workflowId?: string;
+        cursor?: string;
+        offset?: number;
+        limit?: number;
+        fields?: string;
+    };
+    url: '/api/runs';
+};
+export type GetApiRunsResponses = {
+    /**
+     * Success
+     */
+    200: {
+        items: Array<{
+            runId: string;
+            workflowId: string;
+            status: 'ok' | 'error' | 'partial';
+            durationMs: number;
+            startedAt: number;
+            owner: string;
+            scope: 'user' | 'group' | 'org' | 'public';
+            nodeCount?: number;
+            record: {
+                workflowId: string;
+                runId: string;
+                env?: string;
+                status: 'ok' | 'error' | 'partial';
+                nodes: {
+                    [key: string]: {
+                        status: 'ok' | 'error' | 'skipped';
+                        attempts: number;
+                        durationMs: number;
+                        command?: string;
+                        inputs?: unknown;
+                        outputs?: unknown;
+                        error?: {
+                            code: string;
+                            message: string;
+                            retryable?: boolean;
+                        };
+                        note?: 'disabled' | 'pinned' | 'upstream-of-from-node';
+                    };
+                };
+                outputs: {
+                    [key: string]: unknown;
+                };
+                durationMs: number;
+            };
+        }>;
+        total: number;
+        offset: number;
+        limit: number;
+        nextCursor?: string;
+        usage?: {
+            count: number;
+            bytes: number;
+        };
+    };
+};
+export type GetApiRunsResponse = GetApiRunsResponses[keyof GetApiRunsResponses];
+export type GetApiRunsByRunIdData = {
+    body?: never;
+    path: {
+        runId: string;
+    };
+    query?: never;
+    url: '/api/runs/{runId}';
+};
+export type GetApiRunsByRunIdErrors = {
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+};
+export type GetApiRunsByRunIdError = GetApiRunsByRunIdErrors[keyof GetApiRunsByRunIdErrors];
+export type GetApiRunsByRunIdResponses = {
+    /**
+     * Success
+     */
+    200: {
+        runId: string;
+        workflowId: string;
+        status: 'ok' | 'error' | 'partial';
+        durationMs: number;
+        startedAt: number;
+        owner: string;
+        scope: 'user' | 'group' | 'org' | 'public';
+        nodeCount?: number;
+        record: {
+            workflowId: string;
+            runId: string;
+            env?: string;
+            status: 'ok' | 'error' | 'partial';
+            nodes: {
+                [key: string]: {
+                    status: 'ok' | 'error' | 'skipped';
+                    attempts: number;
+                    durationMs: number;
+                    command?: string;
+                    inputs?: unknown;
+                    outputs?: unknown;
+                    error?: {
+                        code: string;
+                        message: string;
+                        retryable?: boolean;
+                    };
+                    note?: 'disabled' | 'pinned' | 'upstream-of-from-node';
+                };
+            };
+            outputs: {
+                [key: string]: unknown;
+            };
+            durationMs: number;
+        };
+    };
+};
+export type GetApiRunsByRunIdResponse = GetApiRunsByRunIdResponses[keyof GetApiRunsByRunIdResponses];
+export type PostApiRunsByRunIdCancelData = {
+    body?: never;
+    path: {
+        runId: string;
+    };
+    query?: never;
+    url: '/api/runs/{runId}/cancel';
+};
+export type PostApiRunsByRunIdCancelErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+};
+export type PostApiRunsByRunIdCancelError = PostApiRunsByRunIdCancelErrors[keyof PostApiRunsByRunIdCancelErrors];
+export type PostApiRunsByRunIdCancelResponses = {
+    /**
+     * Success
+     */
+    200: {
+        ok: true;
+        cancelled: boolean;
+    };
+};
+export type PostApiRunsByRunIdCancelResponse = PostApiRunsByRunIdCancelResponses[keyof PostApiRunsByRunIdCancelResponses];
+export type GetApiProfileData = {
+    body?: never;
+    path?: never;
+    query: {
+        workspace: string;
+    };
+    url: '/api/profile';
+};
+export type GetApiProfileErrors = {
+    /**
+     * Error
+     */
+    401: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+};
+export type GetApiProfileError = GetApiProfileErrors[keyof GetApiProfileErrors];
+export type GetApiProfileResponses = {
+    /**
+     * Success
+     */
+    200: {
+        userId: string;
+        displayName: string | null;
+        title: string | null;
+        bio: string | null;
+        avatarUrl: string | null;
+        profileVersion: number;
+    };
+};
+export type GetApiProfileResponse = GetApiProfileResponses[keyof GetApiProfileResponses];
+export type GetApiProfilesByUserIdAvatarData = {
+    body?: never;
+    path: {
+        userId: string;
+    };
+    query: {
+        workspace: string;
+        v?: number;
+    };
+    url: '/api/profiles/{userId}/avatar';
+};
+export type GetApiProfilesByUserIdAvatarErrors = {
+    /**
+     * Not found
+     */
+    404: unknown;
+};
+export type GetApiProfilesByUserIdAvatarResponses = {
+    /**
+     * Avatar bytes
+     */
+    200: Blob | File;
+};
+export type GetApiProfilesByUserIdAvatarResponse = GetApiProfilesByUserIdAvatarResponses[keyof GetApiProfilesByUserIdAvatarResponses];
+export type GetApiProfilesWorkspaceMembersData = {
+    body?: never;
+    path?: never;
+    query: {
+        workspace: string;
+        q?: string;
+        cursor?: string;
+        limit?: number;
+    };
+    url: '/api/profiles/workspace-members';
+};
+export type GetApiProfilesWorkspaceMembersErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+};
+export type GetApiProfilesWorkspaceMembersError = GetApiProfilesWorkspaceMembersErrors[keyof GetApiProfilesWorkspaceMembersErrors];
+export type GetApiProfilesWorkspaceMembersResponses = {
+    /**
+     * Success
+     */
+    200: {
+        items: Array<{
+            userId: string;
+            displayName: string | null;
+            title: string | null;
+            bio: string | null;
+            avatarUrl: string | null;
+            profileVersion: number;
+        }>;
+        nextCursor: string | null;
+    };
+};
+export type GetApiProfilesWorkspaceMembersResponse = GetApiProfilesWorkspaceMembersResponses[keyof GetApiProfilesWorkspaceMembersResponses];
+export type PostApiKnowledgeSearchData = {
+    body: {
+        query: string;
+        topK?: number;
+    };
+    path?: never;
+    query: {
+        workspace: string;
+        project: string;
+    };
+    url: '/api/knowledge/search';
+};
+export type PostApiKnowledgeSearchErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    503: {
+        error: string;
+    };
+};
+export type PostApiKnowledgeSearchError = PostApiKnowledgeSearchErrors[keyof PostApiKnowledgeSearchErrors];
+export type PostApiKnowledgeSearchResponses = {
+    /**
+     * Success
+     */
+    200: {
+        corpusGeneration: string;
+        model: '@cf/baai/bge-base-en-v1.5';
+        matches: Array<{
+            id: string;
+            score: number;
+            source: string;
+            title: string;
+            heading: string;
+            content: string;
+            digest: string;
+            kind: 'documentation' | 'skill';
+        }>;
+    };
+};
+export type PostApiKnowledgeSearchResponse = PostApiKnowledgeSearchResponses[keyof PostApiKnowledgeSearchResponses];
+export type GetApiSocialConversationsData = {
+    body?: never;
+    path?: never;
+    query: {
+        workspace: string;
+        cursor?: string;
+        limit?: number;
+    };
+    url: '/api/social/conversations';
+};
+export type GetApiSocialConversationsErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    503: {
+        error: string;
+    };
+};
+export type GetApiSocialConversationsError = GetApiSocialConversationsErrors[keyof GetApiSocialConversationsErrors];
+export type GetApiSocialConversationsResponses = {
+    /**
+     * Success
+     */
+    200: {
+        items: Array<{
+            id: string;
+            kind: 'workspace' | 'group' | 'direct' | 'assistant';
+            name: string | null;
+            version: number;
+            createdAt: number;
+            updatedAt: number;
+            archivedAt: number | null;
+            lastMessageSeq: number | null;
+            lastMessageAt: number | null;
+            unreadCount: number;
+        }>;
+        nextCursor: string | null;
+    };
+};
+export type GetApiSocialConversationsResponse = GetApiSocialConversationsResponses[keyof GetApiSocialConversationsResponses];
+export type GetApiSocialConversationsByIdMembersData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query: {
+        workspace: string;
+    };
+    url: '/api/social/conversations/{id}/members';
+};
+export type GetApiSocialConversationsByIdMembersErrors = {
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+};
+export type GetApiSocialConversationsByIdMembersError = GetApiSocialConversationsByIdMembersErrors[keyof GetApiSocialConversationsByIdMembersErrors];
+export type GetApiSocialConversationsByIdMembersResponses = {
+    /**
+     * Success
+     */
+    200: {
+        items: Array<string>;
+    };
+};
+export type GetApiSocialConversationsByIdMembersResponse = GetApiSocialConversationsByIdMembersResponses[keyof GetApiSocialConversationsByIdMembersResponses];
+export type GetApiSocialConversationsByIdMessagesData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query: {
+        workspace: string;
+        cursor?: string;
+        limit?: number;
+    };
+    url: '/api/social/conversations/{id}/messages';
+};
+export type GetApiSocialConversationsByIdMessagesErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+};
+export type GetApiSocialConversationsByIdMessagesError = GetApiSocialConversationsByIdMessagesErrors[keyof GetApiSocialConversationsByIdMessagesErrors];
+export type GetApiSocialConversationsByIdMessagesResponses = {
+    /**
+     * Success
+     */
+    200: {
+        items: Array<{
+            seq: number;
+            id: string;
+            conversationId: string;
+            authorKind: 'user' | 'agent';
+            authorId: string;
+            authorLabel: string | null;
+            origin: 'octonode' | 'slack';
+            replyToId: string | null;
+            body: string;
+            version: number;
+            createdAt: number;
+            editedAt: number | null;
+            deletedAt: number | null;
+            reactions: {
+                [key: string]: number;
+            };
+            viewerReactions: Array<string>;
+        }>;
+        nextCursor: string | null;
+    };
+};
+export type GetApiSocialConversationsByIdMessagesResponse = GetApiSocialConversationsByIdMessagesResponses[keyof GetApiSocialConversationsByIdMessagesResponses];
+export type GetApiSocialNotificationsData = {
+    body?: never;
+    path?: never;
+    query: {
+        workspace: string;
+        cursor?: string;
+        limit?: number;
+    };
+    url: '/api/social/notifications';
+};
+export type GetApiSocialNotificationsErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+};
+export type GetApiSocialNotificationsError = GetApiSocialNotificationsErrors[keyof GetApiSocialNotificationsErrors];
+export type GetApiSocialNotificationsResponses = {
+    /**
+     * Success
+     */
+    200: {
+        items: Array<{
+            seq: number;
+            id: string;
+            kind: 'message' | 'review_reply' | 'suggestion' | 'github_sync';
+            actorKind: 'user' | 'agent' | 'github';
+            actorId: string;
+            entityType: string;
+            entityId: string;
+            payload: {
+                [key: string]: unknown;
+            };
+            createdAt: number;
+            readAt: number | null;
+        }>;
+        nextCursor: string | null;
+        unread: number;
+    };
+};
+export type GetApiSocialNotificationsResponse = GetApiSocialNotificationsResponses[keyof GetApiSocialNotificationsResponses];
+export type GetApiGithubRepositoriesData = {
+    body?: never;
+    path?: never;
+    query: {
+        workspace: string;
+    };
+    url: '/api/github/repositories';
+};
+export type GetApiGithubRepositoriesErrors = {
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    503: {
+        error: string;
+    };
+};
+export type GetApiGithubRepositoriesError = GetApiGithubRepositoriesErrors[keyof GetApiGithubRepositoriesErrors];
+export type GetApiGithubRepositoriesResponses = {
+    /**
+     * Success
+     */
+    200: {
+        items: Array<{
+            repositoryId: number;
+            installationId: number;
+            owner: string;
+            name: string;
+            fullName: string;
+            defaultBranch: string;
+            private: boolean;
+            archived: boolean;
+            permissions: {
+                [key: string]: boolean;
+            };
+            updatedAt: number;
+        }>;
+    };
+};
+export type GetApiGithubRepositoriesResponse = GetApiGithubRepositoriesResponses[keyof GetApiGithubRepositoriesResponses];
+export type GetApiArchitecturesByArchitectureIdGithubPullRequestsData = {
+    body?: never;
+    path: {
+        architectureId: string;
+    };
+    query: {
+        workspace: string;
+        state?: 'open' | 'closed' | 'all';
+    };
+    url: '/api/architectures/{architectureId}/github/pull-requests';
+};
+export type GetApiArchitecturesByArchitectureIdGithubPullRequestsErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    503: {
+        error: string;
+    };
+};
+export type GetApiArchitecturesByArchitectureIdGithubPullRequestsError = GetApiArchitecturesByArchitectureIdGithubPullRequestsErrors[keyof GetApiArchitecturesByArchitectureIdGithubPullRequestsErrors];
+export type GetApiArchitecturesByArchitectureIdGithubPullRequestsResponses = {
+    /**
+     * Success
+     */
+    200: {
+        repository: {
+            repositoryId: number;
+            installationId: number;
+            fullName: string;
+            defaultBranch: string;
+        };
+        items: Array<{
+            repositoryId: number;
+            number: number;
+            title: string;
+            body: string | null;
+            state: 'open' | 'closed' | 'merged';
+            draft: boolean;
+            author: {
+                id: number | null;
+                login: string;
+            };
+            base: {
+                ref: string;
+                sha: string;
+            };
+            head: {
+                repositoryId: number | null;
+                ref: string;
+                sha: string;
+            };
+            maintainerCanModify: boolean;
+            htmlUrl: string;
+            createdAt: number;
+            updatedAt: number;
+            closedAt: number | null;
+            mergedAt: number | null;
+        }>;
+    };
+};
+export type GetApiArchitecturesByArchitectureIdGithubPullRequestsResponse = GetApiArchitecturesByArchitectureIdGithubPullRequestsResponses[keyof GetApiArchitecturesByArchitectureIdGithubPullRequestsResponses];
+export type GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberData = {
+    body?: never;
+    path: {
+        architectureId: string;
+        number: number;
+    };
+    query: {
+        workspace: string;
+    };
+    url: '/api/architectures/{architectureId}/github/pull-requests/{number}';
+};
+export type GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberErrors = {
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    503: {
+        error: string;
+    };
+};
+export type GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberError = GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberErrors[keyof GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberErrors];
+export type GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberResponses = {
+    /**
+     * Success
+     */
+    200: {
+        repository: {
+            repositoryId: number;
+            installationId: number;
+            fullName: string;
+            defaultBranch: string;
+        };
+        pullRequest: {
+            repositoryId: number;
+            number: number;
+            title: string;
+            body: string | null;
+            state: 'open' | 'closed' | 'merged';
+            draft: boolean;
+            author: {
+                id: number | null;
+                login: string;
+            };
+            base: {
+                ref: string;
+                sha: string;
+            };
+            head: {
+                repositoryId: number | null;
+                ref: string;
+                sha: string;
+            };
+            maintainerCanModify: boolean;
+            htmlUrl: string;
+            createdAt: number;
+            updatedAt: number;
+            closedAt: number | null;
+            mergedAt: number | null;
+        };
+        affectedProjectIds: Array<string>;
+    };
+};
+export type GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberResponse = GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberResponses[keyof GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberResponses];
+export type GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberReviewFileData = {
+    body?: never;
+    path: {
+        architectureId: string;
+        number: number;
+    };
+    query: {
+        workspace: string;
+        path: string;
+    };
+    url: '/api/architectures/{architectureId}/github/pull-requests/{number}/review-file';
+};
+export type GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberReviewFileErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    413: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    503: {
+        error: string;
+    };
+};
+export type GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberReviewFileError = GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberReviewFileErrors[keyof GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberReviewFileErrors];
+export type GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberReviewFileResponses = {
+    /**
+     * Success
+     */
+    200: {
+        path: string;
+        previousPath: string | null;
+        status: string;
+        base: {
+            sha: string;
+            content: string;
+            bytes: number;
+        } | null;
+        head: {
+            sha: string;
+            content: string;
+            bytes: number;
+        } | null;
+        headSha: string;
+        changedLines: {
+            LEFT: Array<number>;
+            RIGHT: Array<number>;
+        };
+    };
+};
+export type GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberReviewFileResponse = GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberReviewFileResponses[keyof GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberReviewFileResponses];
+export type GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberWorkflowDiffData = {
+    body?: never;
+    path: {
+        architectureId: string;
+        number: number;
+    };
+    query: {
+        workspace: string;
+        projectId: string;
+    };
+    url: '/api/architectures/{architectureId}/github/pull-requests/{number}/workflow-diff';
+};
+export type GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberWorkflowDiffErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    413: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    503: {
+        error: string;
+    };
+};
+export type GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberWorkflowDiffError = GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberWorkflowDiffErrors[keyof GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberWorkflowDiffErrors];
+export type GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberWorkflowDiffResponses = {
+    /**
+     * Success
+     */
+    200: {
+        repository: {
+            repositoryId: number;
+            installationId: number;
+            fullName: string;
+            defaultBranch: string;
+        };
+        pullRequest: {
+            repositoryId: number;
+            number: number;
+            title: string;
+            body: string | null;
+            state: 'open' | 'closed' | 'merged';
+            draft: boolean;
+            author: {
+                id: number | null;
+                login: string;
+            };
+            base: {
+                ref: string;
+                sha: string;
+            };
+            head: {
+                repositoryId: number | null;
+                ref: string;
+                sha: string;
+            };
+            maintainerCanModify: boolean;
+            htmlUrl: string;
+            createdAt: number;
+            updatedAt: number;
+            closedAt: number | null;
+            mergedAt: number | null;
+        };
+        affectedProjectIds: Array<string>;
+        truncated: boolean;
+        workflows: Array<{
+            id: string;
+            change: 'added' | 'removed' | 'changed';
+            baseRevision: string | null;
+            headRevision: string | null;
+            baseGraph: {
+                entry: string | null;
+                nodes: Array<{
+                    id: string;
+                    type: string | null;
+                    language: string | null;
+                }>;
+                edges: Array<{
+                    from: {
+                        node: string;
+                        output?: string;
+                    };
+                    to: {
+                        node: string;
+                        input?: string;
+                    };
+                    kind?: 'data' | 'dependency' | 'control';
+                }>;
+            } | null;
+            headGraph: {
+                entry: string | null;
+                nodes: Array<{
+                    id: string;
+                    type: string | null;
+                    language: string | null;
+                }>;
+                edges: Array<{
+                    from: {
+                        node: string;
+                        output?: string;
+                    };
+                    to: {
+                        node: string;
+                        input?: string;
+                    };
+                    kind?: 'data' | 'dependency' | 'control';
+                }>;
+            } | null;
+            anchor: {
+                publication: 'inline' | 'fragments' | 'file' | 'summary' | 'unavailable';
+                state: 'current' | 'outdated' | 'unmapped';
+                filePath: string | null;
+                commitSha: string;
+                blobSha: string | null;
+                startLine: number | null;
+                startSide: 'LEFT' | 'RIGHT' | null;
+                endLine: number | null;
+                endSide: 'LEFT' | 'RIGHT' | null;
+                fragments?: Array<{
+                    filePath: string;
+                    startLine: number | null;
+                    startSide: 'LEFT' | 'RIGHT' | null;
+                    endLine: number;
+                    endSide: 'LEFT' | 'RIGHT';
+                }>;
+            };
+            nodes: Array<{
+                id: string;
+                change: 'added' | 'removed' | 'changed' | 'unchanged';
+                anchor: {
+                    publication: 'inline' | 'fragments' | 'file' | 'summary' | 'unavailable';
+                    state: 'current' | 'outdated' | 'unmapped';
+                    filePath: string | null;
+                    commitSha: string;
+                    blobSha: string | null;
+                    startLine: number | null;
+                    startSide: 'LEFT' | 'RIGHT' | null;
+                    endLine: number | null;
+                    endSide: 'LEFT' | 'RIGHT' | null;
+                    fragments?: Array<{
+                        filePath: string;
+                        startLine: number | null;
+                        startSide: 'LEFT' | 'RIGHT' | null;
+                        endLine: number;
+                        endSide: 'LEFT' | 'RIGHT';
+                    }>;
+                };
+            }>;
+            edges: Array<{
+                key: string;
+                change: 'added' | 'removed' | 'changed';
+                from: {
+                    node: string;
+                    output?: string;
+                };
+                to: {
+                    node: string;
+                    input?: string;
+                };
+                kind?: 'data' | 'dependency' | 'control';
+            }>;
+        }>;
+        files: Array<{
+            path: string;
+            status: string;
+            patchAvailable: boolean;
+        }>;
+    };
+};
+export type GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberWorkflowDiffResponse = GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberWorkflowDiffResponses[keyof GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberWorkflowDiffResponses];
+export type GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberReviewThreadsData = {
+    body?: never;
+    path: {
+        architectureId: string;
+        number: number;
+    };
+    query: {
+        workspace: string;
+        projectId: string;
+        workflowId?: string;
+        cursor?: string;
+        limit?: number;
+    };
+    url: '/api/architectures/{architectureId}/github/pull-requests/{number}/review-threads';
+};
+export type GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberReviewThreadsErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+};
+export type GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberReviewThreadsError = GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberReviewThreadsErrors[keyof GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberReviewThreadsErrors];
+export type GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberReviewThreadsResponses = {
+    /**
+     * Success
+     */
+    200: {
+        items: Array<{
+            id: string;
+            contextId: string;
+            projectId: string;
+            repositoryId: number;
+            pullNumber: number;
+            baseSha: string;
+            headSha: string;
+            workflowId: string | null;
+            scope: 'pull_request' | 'workflow' | 'nodes' | 'code';
+            nodeIds: Array<string>;
+            anchor: {
+                publication: 'inline' | 'fragments' | 'file' | 'summary' | 'unavailable';
+                state: 'current' | 'outdated' | 'unmapped';
+                filePath: string | null;
+                commitSha: string;
+                blobSha: string | null;
+                startLine: number | null;
+                startSide: 'LEFT' | 'RIGHT' | null;
+                endLine: number | null;
+                endSide: 'LEFT' | 'RIGHT' | null;
+                fragments?: Array<{
+                    filePath: string;
+                    startLine: number | null;
+                    startSide: 'LEFT' | 'RIGHT' | null;
+                    endLine: number;
+                    endSide: 'LEFT' | 'RIGHT';
+                }>;
+            };
+            status: 'open' | 'resolved';
+            version: number;
+            createdAt: number;
+            updatedAt: number;
+            comments: Array<{
+                seq: number;
+                id: string;
+                threadId: string;
+                authorKind: 'user' | 'agent' | 'github';
+                authorId: string;
+                authorLabel: string | null;
+                authorAvatarUrl: string | null;
+                origin: 'octonode' | 'github';
+                body: string;
+                version: number;
+                createdAt: number;
+                editedAt: number | null;
+                deletedAt: number | null;
+                githubState: 'unpublished' | 'queued' | 'published' | 'failed' | 'deleted';
+                suggestion: {
+                    id: string;
+                    commentId: string;
+                    kind: 'workflow_draft' | 'source_patch';
+                    baseHeadSha: string;
+                    baseRevision: string;
+                    payload: {
+                        [key: string]: unknown;
+                    };
+                    prepared: {
+                        [key: string]: unknown;
+                    } | null;
+                    validation: {
+                        [key: string]: unknown;
+                    } | null;
+                    status: 'open' | 'applying' | 'applied' | 'rejected' | 'outdated' | 'failed';
+                    version: number;
+                    createdAt: number;
+                    appliedCommitSha: string | null;
+                } | null;
+            }>;
+        }>;
+        nextCursor: string | null;
+    };
+};
+export type GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberReviewThreadsResponse = GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberReviewThreadsResponses[keyof GetApiArchitecturesByArchitectureIdGithubPullRequestsByNumberReviewThreadsResponses];
+export type GetApiGithubJobsByIdData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query: {
+        workspace: string;
+    };
+    url: '/api/github/jobs/{id}';
+};
+export type GetApiGithubJobsByIdErrors = {
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+};
+export type GetApiGithubJobsByIdError = GetApiGithubJobsByIdErrors[keyof GetApiGithubJobsByIdErrors];
+export type GetApiGithubJobsByIdResponses = {
+    /**
+     * Success
+     */
+    200: {
+        id: string;
+        kind: 'github_publish' | 'github_update' | 'github_delete' | 'github_resolve' | 'github_unresolve' | 'github_submit_review' | 'github_apply_suggestion';
+        status: 'queued' | 'processing' | 'done' | 'failed';
+        attempts: number;
+        availableAt: number;
+        lastError: string | null;
+        result: {
+            [key: string]: unknown;
+        } | null;
+    };
+};
+export type GetApiGithubJobsByIdResponse = GetApiGithubJobsByIdResponses[keyof GetApiGithubJobsByIdResponses];
+export type GetApiProjectsTrashData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/projects/trash';
+};
+export type GetApiProjectsTrashErrors = {
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+};
+export type GetApiProjectsTrashError = GetApiProjectsTrashErrors[keyof GetApiProjectsTrashErrors];
+export type GetApiProjectsTrashResponses = {
+    /**
+     * Success
+     */
+    200: Array<{
+        id: string;
+        name: string;
+        state: 'archived' | 'deleted';
+        changedAt: number;
+        expiresAt?: number;
+        purgedAt?: number;
+    }>;
+};
+export type GetApiProjectsTrashResponse = GetApiProjectsTrashResponses[keyof GetApiProjectsTrashResponses];
+export type GetApiProjectsSearchData = {
+    body?: never;
+    path?: never;
+    query?: {
+        q?: string;
+        offset?: number;
+        limit?: number;
+        cloud?: 'true';
+    };
+    url: '/api/projects/search';
+};
+export type GetApiProjectsSearchErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+};
+export type GetApiProjectsSearchError = GetApiProjectsSearchErrors[keyof GetApiProjectsSearchErrors];
+export type GetApiProjectsSearchResponses = {
+    /**
+     * Success
+     */
+    200: {
+        items: Array<{
+            id: string;
+            name: string;
+            path?: string;
+            workflowCount: number;
+            environments?: Array<string>;
+            readOnly?: true;
+            legacyLanguage?: string;
+            local?: false;
+            cloudAction?: 'install' | 'sync';
+            hosted?: true;
+            unavailable?: true;
+            sourceKind?: 'repository' | 'managed' | 'standalone';
+            sourceRepositoryId?: string | null;
+            configLocator?: string;
+        }>;
+        total: number;
+        offset: number;
+        limit: number;
+    };
+};
+export type GetApiProjectsSearchResponse = GetApiProjectsSearchResponses[keyof GetApiProjectsSearchResponses];
+export type GetApiProjectsCloudData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/projects/cloud';
+};
+export type GetApiProjectsCloudErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+};
+export type GetApiProjectsCloudError = GetApiProjectsCloudErrors[keyof GetApiProjectsCloudErrors];
+export type GetApiProjectsCloudResponses = {
+    /**
+     * Success
+     */
+    200: Array<{
+        id: string;
+        name: string;
+        path?: string;
+        workflowCount: number;
+        environments?: Array<string>;
+        readOnly?: true;
+        legacyLanguage?: string;
+        local?: false;
+        cloudAction?: 'install' | 'sync';
+        hosted?: true;
+        unavailable?: true;
+        sourceKind?: 'repository' | 'managed' | 'standalone';
+        sourceRepositoryId?: string | null;
+        configLocator?: string;
+    }>;
+};
+export type GetApiProjectsCloudResponse = GetApiProjectsCloudResponses[keyof GetApiProjectsCloudResponses];
+export type GetApiProjectsByProjectIdFilesData = {
+    body?: never;
+    path: {
+        projectId: string;
+    };
+    query?: never;
+    url: '/api/projects/{projectId}/files';
+};
+export type GetApiProjectsByProjectIdFilesErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+};
+export type GetApiProjectsByProjectIdFilesError = GetApiProjectsByProjectIdFilesErrors[keyof GetApiProjectsByProjectIdFilesErrors];
+export type GetApiProjectsByProjectIdFilesResponses = {
+    /**
+     * Success
+     */
+    200: Array<{
+        path: string;
+        size: number;
+        mtime: number;
+    }>;
+};
+export type GetApiProjectsByProjectIdFilesResponse = GetApiProjectsByProjectIdFilesResponses[keyof GetApiProjectsByProjectIdFilesResponses];
+export type GetApiProjectsByProjectIdFilesContentData = {
+    body?: never;
+    path: {
+        projectId: string;
+    };
+    query: {
+        path: string;
+    };
+    url: '/api/projects/{projectId}/files/content';
+};
+export type GetApiProjectsByProjectIdFilesContentErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+};
+export type GetApiProjectsByProjectIdFilesContentError = GetApiProjectsByProjectIdFilesContentErrors[keyof GetApiProjectsByProjectIdFilesContentErrors];
+export type GetApiProjectsByProjectIdFilesContentResponses = {
+    /**
+     * Success
+     */
+    200: {
+        path: string;
+        content: string;
+        mtime: number;
+        revision: string;
+        conflict?: boolean;
+    };
+};
+export type GetApiProjectsByProjectIdFilesContentResponse = GetApiProjectsByProjectIdFilesContentResponses[keyof GetApiProjectsByProjectIdFilesContentResponses];
+export type PostApiProjectsByProjectIdFilesContentData = {
+    body: {
+        path: string;
+        content: string;
+    };
+    path: {
+        projectId: string;
+    };
+    query?: never;
+    url: '/api/projects/{projectId}/files/content';
+};
+export type PostApiProjectsByProjectIdFilesContentErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    409: {
+        error: string;
+    };
+};
+export type PostApiProjectsByProjectIdFilesContentError = PostApiProjectsByProjectIdFilesContentErrors[keyof PostApiProjectsByProjectIdFilesContentErrors];
+export type PostApiProjectsByProjectIdFilesContentResponses = {
+    /**
+     * Success
+     */
+    201: {
+        path: string;
+        content: string;
+        mtime: number;
+        revision: string;
+        conflict?: boolean;
+    };
+};
+export type PostApiProjectsByProjectIdFilesContentResponse = PostApiProjectsByProjectIdFilesContentResponses[keyof PostApiProjectsByProjectIdFilesContentResponses];
+export type PutApiProjectsByProjectIdFilesContentData = {
+    body: {
+        path: string;
+        content: string;
+        baseRevision: string;
+    };
+    path: {
+        projectId: string;
+    };
+    query?: never;
+    url: '/api/projects/{projectId}/files/content';
+};
+export type PutApiProjectsByProjectIdFilesContentErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    409: {
+        error: string;
+    };
+};
+export type PutApiProjectsByProjectIdFilesContentError = PutApiProjectsByProjectIdFilesContentErrors[keyof PutApiProjectsByProjectIdFilesContentErrors];
+export type PutApiProjectsByProjectIdFilesContentResponses = {
+    /**
+     * Success
+     */
+    200: {
+        path: string;
+        content: string;
+        mtime: number;
+        revision: string;
+        conflict?: boolean;
+    };
+};
+export type PutApiProjectsByProjectIdFilesContentResponse = PutApiProjectsByProjectIdFilesContentResponses[keyof PutApiProjectsByProjectIdFilesContentResponses];
+export type PostApiProjectsByProjectIdCompileData = {
+    body?: never;
+    path: {
+        projectId: string;
+    };
+    query?: never;
+    url: '/api/projects/{projectId}/compile';
+};
+export type PostApiProjectsByProjectIdCompileErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+};
+export type PostApiProjectsByProjectIdCompileError = PostApiProjectsByProjectIdCompileErrors[keyof PostApiProjectsByProjectIdCompileErrors];
+export type PostApiProjectsByProjectIdCompileResponses = {
+    /**
+     * Success
+     */
+    200: {
+        success: boolean;
+        diagnostics: Array<{
+            severity: 'error' | 'warning';
+            code: string;
+            message: string;
+            path?: string;
+        }>;
+        synced: {
+            added: Array<string>;
+            updated: Array<string>;
+            unchanged: Array<string>;
+            orphaned: Array<string>;
+        };
+    };
+};
+export type PostApiProjectsByProjectIdCompileResponse = PostApiProjectsByProjectIdCompileResponses[keyof PostApiProjectsByProjectIdCompileResponses];
+export type GetApiProjectsByProjectIdPackageExportsData = {
+    body?: never;
+    path: {
+        projectId: string;
+    };
+    query?: {
+        module?: string;
+    };
+    url: '/api/projects/{projectId}/package-exports';
+};
+export type GetApiProjectsByProjectIdPackageExportsErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+};
+export type GetApiProjectsByProjectIdPackageExportsError = GetApiProjectsByProjectIdPackageExportsErrors[keyof GetApiProjectsByProjectIdPackageExportsErrors];
+export type GetApiProjectsByProjectIdPackageExportsResponses = {
+    /**
+     * Success
+     */
+    200: {
+        packages: Array<string>;
+        exports: Array<{
+            name: string;
+            kind: 'function' | 'constant' | 'type' | 'class' | 'value';
+            typeOnly: boolean;
+            declaration: string;
+        }>;
+    };
+};
+export type GetApiProjectsByProjectIdPackageExportsResponse = GetApiProjectsByProjectIdPackageExportsResponses[keyof GetApiProjectsByProjectIdPackageExportsResponses];
+export type GetApiProjectsByProjectIdSourceIndexData = {
+    body?: never;
+    path: {
+        projectId: string;
+    };
+    query?: never;
+    url: '/api/projects/{projectId}/source-index';
+};
+export type GetApiProjectsByProjectIdSourceIndexErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+};
+export type GetApiProjectsByProjectIdSourceIndexError = GetApiProjectsByProjectIdSourceIndexErrors[keyof GetApiProjectsByProjectIdSourceIndexErrors];
+export type GetApiProjectsByProjectIdSourceIndexResponses = {
+    /**
+     * Success
+     */
+    200: {
+        revision: string;
+        files: Array<{
+            path: string;
+            language: 'typescript' | 'javascript';
+            bundleId: string;
+            runtime?: 'frontend';
+            entryWorkflowId?: string;
+            imports?: Array<{
+                source: string;
+                module: string;
+                typeOnly: boolean;
+                default?: string;
+                namespace?: string;
+                named: Array<{
+                    name: string;
+                    alias?: string;
+                    typeOnly: boolean;
+                }>;
+            }>;
+            symbols: Array<{
+                id: string;
+                name: string;
+                kind: 'function' | 'workflow' | 'module-workflow' | 'type-alias' | 'interface' | 'enum' | 'constant' | 'variable' | 'class' | 'service';
+                exported: boolean;
+                location: {
+                    path: string;
+                    start: number;
+                    end: number;
+                    line: number;
+                    column: number;
+                };
+                declaration?: string;
+                owner?: string;
+                signature?: {
+                    params?: Array<{
+                        name: string;
+                        type?: string;
+                        optional?: boolean;
+                        rest?: boolean;
+                        visibility?: 'public' | 'protected' | 'private' | '#private';
+                        readonly?: boolean;
+                        decorators?: Array<{
+                            name: string;
+                            text: string;
+                            arguments: Array<string>;
+                        }>;
+                        initializer?: string;
+                    }>;
+                    returns?: string;
+                    typeText?: string;
+                    decorators?: Array<{
+                        name: string;
+                        text: string;
+                        arguments: Array<string>;
+                    }>;
+                    typeParameters?: Array<string>;
+                    extends?: string;
+                    implements?: Array<string>;
+                    abstract?: boolean;
+                    instances?: Array<string>;
+                    members?: Array<{
+                        name: string;
+                        kind: 'constructor' | 'method' | 'property' | 'getter' | 'setter' | 'accessor' | 'index-signature' | 'static-block';
+                        type?: string;
+                        returns?: string;
+                        parameters?: Array<{
+                            name: string;
+                            type?: string;
+                            optional?: boolean;
+                            rest?: boolean;
+                            visibility?: 'public' | 'protected' | 'private' | '#private';
+                            readonly?: boolean;
+                            decorators?: Array<{
+                                name: string;
+                                text: string;
+                                arguments: Array<string>;
+                            }>;
+                            initializer?: string;
+                        }>;
+                        typeParameters?: Array<string>;
+                        visibility?: 'public' | 'protected' | 'private' | '#private';
+                        static?: boolean;
+                        readonly?: boolean;
+                        declare?: boolean;
+                        definite?: boolean;
+                        abstract?: boolean;
+                        optional?: boolean;
+                        override?: boolean;
+                        async?: boolean;
+                        generator?: boolean;
+                        decorators?: Array<{
+                            name: string;
+                            text: string;
+                            arguments: Array<string>;
+                        }>;
+                        initializer?: string;
+                        workflowId?: string;
+                    }>;
+                };
+                constant?: {
+                    serializable: boolean;
+                    value?: unknown;
+                    declarationKind?: 'const';
+                    expression?: string;
+                };
+                variable?: {
+                    declarationKind: 'let' | 'var';
+                    initializer?: string;
+                };
+                service?: {
+                    classSymbol?: string;
+                    methods: Array<string>;
+                    lifecycle: 'invocation' | 'workflow-run' | 'worker';
+                };
+                controlFlow?: Array<{
+                    id: string;
+                    kind: 'if' | 'switch' | 'for' | 'while' | 'do-while' | 'for-in' | 'for-of' | 'break' | 'continue' | 'label' | 'try' | 'catch' | 'finally';
+                    path: Array<number>;
+                    parentId?: string;
+                    location: {
+                        path: string;
+                        start: number;
+                        end: number;
+                        line: number;
+                        column: number;
+                    };
+                    source: string;
+                }>;
+            }>;
+            exports?: Array<{
+                name: string;
+                local?: string;
+                module?: string;
+                typeOnly: boolean;
+            }>;
+            diagnostics: Array<{
+                severity: 'error' | 'warning';
+                code: string;
+                message: string;
+                location?: {
+                    path: string;
+                    start: number;
+                    end: number;
+                    line: number;
+                    column: number;
+                };
+            }>;
+        }>;
+        references: Array<{
+            from: string;
+            to: string;
+            kind: 'call' | 'type' | 'value' | 'construct' | 'method';
+            location: {
+                path: string;
+                start: number;
+                end: number;
+                line: number;
+                column: number;
+            };
+        }>;
+    };
+};
+export type GetApiProjectsByProjectIdSourceIndexResponse = GetApiProjectsByProjectIdSourceIndexResponses[keyof GetApiProjectsByProjectIdSourceIndexResponses];
+export type GetApiProjectsByProjectIdSourceSupportData = {
+    body?: never;
+    path: {
+        projectId: string;
+    };
+    query?: never;
+    url: '/api/projects/{projectId}/source-support';
+};
+export type GetApiProjectsByProjectIdSourceSupportErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+};
+export type GetApiProjectsByProjectIdSourceSupportError = GetApiProjectsByProjectIdSourceSupportErrors[keyof GetApiProjectsByProjectIdSourceSupportErrors];
+export type GetApiProjectsByProjectIdSourceSupportResponses = {
+    /**
+     * Success
+     */
+    200: {
+        revision: string;
+        items: Array<{
+            id: string;
+            name: string;
+            path: string;
+            kind: 'type-alias' | 'interface' | 'enum' | 'constant';
+            scope?: 'workflow' | 'file' | 'project';
+            owner?: string;
+            exported?: boolean;
+            declaration?: string;
+            value?: unknown;
+            schema?: {
+                [key: string]: unknown;
+            };
+        }>;
+    };
+};
+export type GetApiProjectsByProjectIdSourceSupportResponse = GetApiProjectsByProjectIdSourceSupportResponses[keyof GetApiProjectsByProjectIdSourceSupportResponses];
+export type GetApiStoreProjectsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/store/projects';
+};
+export type GetApiStoreProjectsErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+};
+export type GetApiStoreProjectsError = GetApiStoreProjectsErrors[keyof GetApiStoreProjectsErrors];
+export type GetApiStoreProjectsResponses = {
+    /**
+     * Success
+     */
+    200: Array<{
+        id: string;
+        orgId: string;
+        ownerUserId: string;
+        name: string;
+        slug: string;
+        description?: string;
+        visibility: {
+            scope: 'user' | 'group' | 'org' | 'public';
+            owner: string;
+            editors?: Array<string>;
+            groupId?: string;
+            orgId?: string;
+        };
+        repo?: {
+            provider?: 'github' | 'gitlab' | 'bitbucket' | 'other';
+            url: string;
+            owner?: string;
+            name?: string;
+            defaultBranch?: string;
+        };
+        cloudflare?: {
+            workerName?: string;
+            dataDoName: string;
+        };
+        createdAt: number;
+        updatedAt: number;
+    }>;
+};
+export type GetApiStoreProjectsResponse = GetApiStoreProjectsResponses[keyof GetApiStoreProjectsResponses];
+export type GetApiProjectsByProjectIdData = {
+    body?: never;
+    path: {
+        projectId: string;
+    };
+    query?: never;
+    url: '/api/projects/{projectId}';
+};
+export type GetApiProjectsByProjectIdErrors = {
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+};
+export type GetApiProjectsByProjectIdError = GetApiProjectsByProjectIdErrors[keyof GetApiProjectsByProjectIdErrors];
+export type GetApiProjectsByProjectIdResponses = {
+    /**
+     * Success
+     */
+    200: {
+        id: string;
+        orgId: string;
+        ownerUserId: string;
+        name: string;
+        slug: string;
+        description?: string;
+        visibility: {
+            scope: 'user' | 'group' | 'org' | 'public';
+            owner: string;
+            editors?: Array<string>;
+            groupId?: string;
+            orgId?: string;
+        };
+        repo?: {
+            provider?: 'github' | 'gitlab' | 'bitbucket' | 'other';
+            url: string;
+            owner?: string;
+            name?: string;
+            defaultBranch?: string;
+        };
+        cloudflare?: {
+            workerName?: string;
+            dataDoName: string;
+        };
+        createdAt: number;
+        updatedAt: number;
+    };
+};
+export type GetApiProjectsByProjectIdResponse = GetApiProjectsByProjectIdResponses[keyof GetApiProjectsByProjectIdResponses];
+export type GetApiProjectsByProjectIdDataTableSchemaData = {
+    body?: never;
+    path: {
+        projectId: string;
+    };
+    query?: {
+        workspace?: string;
+    };
+    url: '/api/projects/{projectId}/data-table-schema';
+};
+export type GetApiProjectsByProjectIdDataTableSchemaErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+};
+export type GetApiProjectsByProjectIdDataTableSchemaError = GetApiProjectsByProjectIdDataTableSchemaErrors[keyof GetApiProjectsByProjectIdDataTableSchemaErrors];
+export type GetApiProjectsByProjectIdDataTableSchemaResponses = {
+    /**
+     * Success
+     */
+    200: {
+        available: boolean;
+        canManage: boolean;
+        tables: Array<{
+            id: string;
+            projectId: string;
+            name: string;
+            slug: string;
+            description?: string;
+            storageMode: 'sqlite' | 'kv_blob';
+            columns: Array<{
+                id: string;
+                key: string;
+                name: string;
+                type: 'text' | 'number' | 'boolean' | 'date' | 'datetime' | 'json';
+                required: boolean;
+                defaultValue?: unknown;
+                position: number;
+            }>;
+            rowCount: number;
+            schemaVersion: number;
+            createdAt: number;
+            updatedAt: number;
+        }>;
+        relationships: Array<{
+            sourceTableId: string;
+            sourceColumn: string;
+            targetTableId: string;
+            onDelete?: 'restrict' | 'set_null';
+            id: string;
+            projectId: string;
+        }>;
+        views: Array<{
+            name: string;
+            tableId: string;
+            relationshipIds?: Array<string>;
+            filters?: Array<{
+                column: string;
+                operator: 'eq' | 'ne' | 'contains' | 'gt' | 'gte' | 'lt' | 'lte' | 'is_null' | 'not_null';
+                value?: string | number | boolean | null;
+            }>;
+            sort?: {
+                column: string;
+                direction: 'asc' | 'desc';
+            };
+            id: string;
+            projectId: string;
+            revision: number;
+        }>;
+    };
+};
+export type GetApiProjectsByProjectIdDataTableSchemaResponse = GetApiProjectsByProjectIdDataTableSchemaResponses[keyof GetApiProjectsByProjectIdDataTableSchemaResponses];
+export type PostApiProjectsByProjectIdDataTableSchemaViewsByViewIdQueryData = {
+    body: {
+        offset?: number;
+        limit?: number;
+    };
+    path: {
+        projectId: string;
+        viewId: string;
+    };
+    query?: {
+        workspace?: string;
+    };
+    url: '/api/projects/{projectId}/data-table-schema/views/{viewId}/query';
+};
+export type PostApiProjectsByProjectIdDataTableSchemaViewsByViewIdQueryErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+};
+export type PostApiProjectsByProjectIdDataTableSchemaViewsByViewIdQueryError = PostApiProjectsByProjectIdDataTableSchemaViewsByViewIdQueryErrors[keyof PostApiProjectsByProjectIdDataTableSchemaViewsByViewIdQueryErrors];
+export type PostApiProjectsByProjectIdDataTableSchemaViewsByViewIdQueryResponses = {
+    /**
+     * Success
+     */
+    200: {
+        columns: Array<string>;
+        rows: Array<{
+            [key: string]: unknown;
+        }>;
+        total: number;
+        nextOffset: number | null;
+    };
+};
+export type PostApiProjectsByProjectIdDataTableSchemaViewsByViewIdQueryResponse = PostApiProjectsByProjectIdDataTableSchemaViewsByViewIdQueryResponses[keyof PostApiProjectsByProjectIdDataTableSchemaViewsByViewIdQueryResponses];
+export type GetApiProjectsByProjectIdDataTablesData = {
+    body?: never;
+    path: {
+        projectId: string;
+    };
+    query?: {
+        search?: string;
+        global?: 'true';
+        fields?: string;
+    };
+    url: '/api/projects/{projectId}/data-tables';
+};
+export type GetApiProjectsByProjectIdDataTablesErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+};
+export type GetApiProjectsByProjectIdDataTablesError = GetApiProjectsByProjectIdDataTablesErrors[keyof GetApiProjectsByProjectIdDataTablesErrors];
+export type GetApiProjectsByProjectIdDataTablesResponses = {
+    /**
+     * Success
+     */
+    200: Array<{
+        id: string;
+        projectId: string;
+        name: string;
+        slug: string;
+        description?: string;
+        storageMode: 'sqlite' | 'kv_blob';
+        columns: Array<{
+            id: string;
+            key: string;
+            name: string;
+            type: 'text' | 'number' | 'boolean' | 'date' | 'datetime' | 'json';
+            required: boolean;
+            defaultValue?: unknown;
+            position: number;
+        }>;
+        rowCount: number;
+        schemaVersion: number;
+        createdAt: number;
+        updatedAt: number;
+    }>;
+};
+export type GetApiProjectsByProjectIdDataTablesResponse = GetApiProjectsByProjectIdDataTablesResponses[keyof GetApiProjectsByProjectIdDataTablesResponses];
+export type PostApiProjectsByProjectIdDataTablesData = {
+    body: {
+        name: string;
+        slug?: string;
+        description?: string;
+        storageMode?: 'sqlite' | 'kv_blob';
+        columns?: Array<{
+            id?: string;
+            key: string;
+            name: string;
+            type: 'text' | 'number' | 'boolean' | 'date' | 'datetime' | 'json';
+            required?: boolean;
+            defaultValue?: unknown;
+            position: number;
+        }>;
+    };
+    path: {
+        projectId: string;
+    };
+    query?: never;
+    url: '/api/projects/{projectId}/data-tables';
+};
+export type PostApiProjectsByProjectIdDataTablesErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    409: {
+        error: string;
+    };
+};
+export type PostApiProjectsByProjectIdDataTablesError = PostApiProjectsByProjectIdDataTablesErrors[keyof PostApiProjectsByProjectIdDataTablesErrors];
+export type PostApiProjectsByProjectIdDataTablesResponses = {
+    /**
+     * Success
+     */
+    201: {
+        id: string;
+        projectId: string;
+        name: string;
+        slug: string;
+        description?: string;
+        storageMode: 'sqlite' | 'kv_blob';
+        columns: Array<{
+            id: string;
+            key: string;
+            name: string;
+            type: 'text' | 'number' | 'boolean' | 'date' | 'datetime' | 'json';
+            required: boolean;
+            defaultValue?: unknown;
+            position: number;
+        }>;
+        rowCount: number;
+        schemaVersion: number;
+        createdAt: number;
+        updatedAt: number;
+    };
+};
+export type PostApiProjectsByProjectIdDataTablesResponse = PostApiProjectsByProjectIdDataTablesResponses[keyof PostApiProjectsByProjectIdDataTablesResponses];
+export type DeleteApiProjectsByProjectIdDataTablesByTableIdData = {
+    body?: never;
+    path: {
+        projectId: string;
+        tableId: string;
+    };
+    query?: never;
+    url: '/api/projects/{projectId}/data-tables/{tableId}';
+};
+export type DeleteApiProjectsByProjectIdDataTablesByTableIdErrors = {
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+};
+export type DeleteApiProjectsByProjectIdDataTablesByTableIdError = DeleteApiProjectsByProjectIdDataTablesByTableIdErrors[keyof DeleteApiProjectsByProjectIdDataTablesByTableIdErrors];
+export type DeleteApiProjectsByProjectIdDataTablesByTableIdResponses = {
+    /**
+     * Success
+     */
+    200: {
+        ok: true;
+    };
+};
+export type DeleteApiProjectsByProjectIdDataTablesByTableIdResponse = DeleteApiProjectsByProjectIdDataTablesByTableIdResponses[keyof DeleteApiProjectsByProjectIdDataTablesByTableIdResponses];
+export type GetApiProjectsByProjectIdDataTablesByTableIdData = {
+    body?: never;
+    path: {
+        projectId: string;
+        tableId: string;
+    };
+    query?: never;
+    url: '/api/projects/{projectId}/data-tables/{tableId}';
+};
+export type GetApiProjectsByProjectIdDataTablesByTableIdErrors = {
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+};
+export type GetApiProjectsByProjectIdDataTablesByTableIdError = GetApiProjectsByProjectIdDataTablesByTableIdErrors[keyof GetApiProjectsByProjectIdDataTablesByTableIdErrors];
+export type GetApiProjectsByProjectIdDataTablesByTableIdResponses = {
+    /**
+     * Success
+     */
+    200: {
+        id: string;
+        projectId: string;
+        name: string;
+        slug: string;
+        description?: string;
+        storageMode: 'sqlite' | 'kv_blob';
+        columns: Array<{
+            id: string;
+            key: string;
+            name: string;
+            type: 'text' | 'number' | 'boolean' | 'date' | 'datetime' | 'json';
+            required: boolean;
+            defaultValue?: unknown;
+            position: number;
+        }>;
+        rowCount: number;
+        schemaVersion: number;
+        createdAt: number;
+        updatedAt: number;
+    };
+};
+export type GetApiProjectsByProjectIdDataTablesByTableIdResponse = GetApiProjectsByProjectIdDataTablesByTableIdResponses[keyof GetApiProjectsByProjectIdDataTablesByTableIdResponses];
+export type PatchApiProjectsByProjectIdDataTablesByTableIdData = {
+    body: {
+        name?: string;
+        slug?: string;
+        description?: string | null;
+        columns?: Array<{
+            id?: string;
+            key: string;
+            name: string;
+            type: 'text' | 'number' | 'boolean' | 'date' | 'datetime' | 'json';
+            required?: boolean;
+            defaultValue?: unknown;
+            position: number;
+        }>;
+    };
+    path: {
+        projectId: string;
+        tableId: string;
+    };
+    query?: never;
+    url: '/api/projects/{projectId}/data-tables/{tableId}';
+};
+export type PatchApiProjectsByProjectIdDataTablesByTableIdErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    409: {
+        error: string;
+    };
+};
+export type PatchApiProjectsByProjectIdDataTablesByTableIdError = PatchApiProjectsByProjectIdDataTablesByTableIdErrors[keyof PatchApiProjectsByProjectIdDataTablesByTableIdErrors];
+export type PatchApiProjectsByProjectIdDataTablesByTableIdResponses = {
+    /**
+     * Success
+     */
+    200: {
+        id: string;
+        projectId: string;
+        name: string;
+        slug: string;
+        description?: string;
+        storageMode: 'sqlite' | 'kv_blob';
+        columns: Array<{
+            id: string;
+            key: string;
+            name: string;
+            type: 'text' | 'number' | 'boolean' | 'date' | 'datetime' | 'json';
+            required: boolean;
+            defaultValue?: unknown;
+            position: number;
+        }>;
+        rowCount: number;
+        schemaVersion: number;
+        createdAt: number;
+        updatedAt: number;
+    };
+};
+export type PatchApiProjectsByProjectIdDataTablesByTableIdResponse = PatchApiProjectsByProjectIdDataTablesByTableIdResponses[keyof PatchApiProjectsByProjectIdDataTablesByTableIdResponses];
+export type GetApiProjectsByProjectIdDataTablesByTableIdRowsData = {
+    body?: never;
+    path: {
+        projectId: string;
+        tableId: string;
+    };
+    query?: {
+        cursor?: string;
+        limit?: number;
+    };
+    url: '/api/projects/{projectId}/data-tables/{tableId}/rows';
+};
+export type GetApiProjectsByProjectIdDataTablesByTableIdRowsErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+};
+export type GetApiProjectsByProjectIdDataTablesByTableIdRowsError = GetApiProjectsByProjectIdDataTablesByTableIdRowsErrors[keyof GetApiProjectsByProjectIdDataTablesByTableIdRowsErrors];
+export type GetApiProjectsByProjectIdDataTablesByTableIdRowsResponses = {
+    /**
+     * Success
+     */
+    200: {
+        rows: Array<{
+            id: string;
+            tableId: string;
+            data: {
+                [key: string]: unknown;
+            };
+            version: number;
+            createdAt: number;
+            updatedAt: number;
+        }>;
+        nextCursor?: string;
+    };
+};
+export type GetApiProjectsByProjectIdDataTablesByTableIdRowsResponse = GetApiProjectsByProjectIdDataTablesByTableIdRowsResponses[keyof GetApiProjectsByProjectIdDataTablesByTableIdRowsResponses];
+export type PostApiProjectsByProjectIdDataTablesByTableIdRowsData = {
+    body: {
+        data: {
+            [key: string]: unknown;
+        };
+    };
+    path: {
+        projectId: string;
+        tableId: string;
+    };
+    query?: never;
+    url: '/api/projects/{projectId}/data-tables/{tableId}/rows';
+};
+export type PostApiProjectsByProjectIdDataTablesByTableIdRowsErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    409: {
+        error: string;
+    };
+};
+export type PostApiProjectsByProjectIdDataTablesByTableIdRowsError = PostApiProjectsByProjectIdDataTablesByTableIdRowsErrors[keyof PostApiProjectsByProjectIdDataTablesByTableIdRowsErrors];
+export type PostApiProjectsByProjectIdDataTablesByTableIdRowsResponses = {
+    /**
+     * Success
+     */
+    201: {
+        id: string;
+        tableId: string;
+        data: {
+            [key: string]: unknown;
+        };
+        version: number;
+        createdAt: number;
+        updatedAt: number;
+    };
+};
+export type PostApiProjectsByProjectIdDataTablesByTableIdRowsResponse = PostApiProjectsByProjectIdDataTablesByTableIdRowsResponses[keyof PostApiProjectsByProjectIdDataTablesByTableIdRowsResponses];
+export type DeleteApiProjectsByProjectIdDataTablesByTableIdRowsByRowIdData = {
+    body?: never;
+    path: {
+        projectId: string;
+        tableId: string;
+        rowId: string;
+    };
+    query?: never;
+    url: '/api/projects/{projectId}/data-tables/{tableId}/rows/{rowId}';
+};
+export type DeleteApiProjectsByProjectIdDataTablesByTableIdRowsByRowIdErrors = {
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+};
+export type DeleteApiProjectsByProjectIdDataTablesByTableIdRowsByRowIdError = DeleteApiProjectsByProjectIdDataTablesByTableIdRowsByRowIdErrors[keyof DeleteApiProjectsByProjectIdDataTablesByTableIdRowsByRowIdErrors];
+export type DeleteApiProjectsByProjectIdDataTablesByTableIdRowsByRowIdResponses = {
+    /**
+     * Success
+     */
+    200: {
+        ok: true;
+    };
+};
+export type DeleteApiProjectsByProjectIdDataTablesByTableIdRowsByRowIdResponse = DeleteApiProjectsByProjectIdDataTablesByTableIdRowsByRowIdResponses[keyof DeleteApiProjectsByProjectIdDataTablesByTableIdRowsByRowIdResponses];
+export type PatchApiProjectsByProjectIdDataTablesByTableIdRowsByRowIdData = {
+    body: {
+        data: {
+            [key: string]: unknown;
+        };
+        expectedVersion?: number;
+    };
+    path: {
+        projectId: string;
+        tableId: string;
+        rowId: string;
+    };
+    query?: never;
+    url: '/api/projects/{projectId}/data-tables/{tableId}/rows/{rowId}';
+};
+export type PatchApiProjectsByProjectIdDataTablesByTableIdRowsByRowIdErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    409: {
+        error: string;
+    };
+};
+export type PatchApiProjectsByProjectIdDataTablesByTableIdRowsByRowIdError = PatchApiProjectsByProjectIdDataTablesByTableIdRowsByRowIdErrors[keyof PatchApiProjectsByProjectIdDataTablesByTableIdRowsByRowIdErrors];
+export type PatchApiProjectsByProjectIdDataTablesByTableIdRowsByRowIdResponses = {
+    /**
+     * Success
+     */
+    200: {
+        id: string;
+        tableId: string;
+        data: {
+            [key: string]: unknown;
+        };
+        version: number;
+        createdAt: number;
+        updatedAt: number;
+    };
+};
+export type PatchApiProjectsByProjectIdDataTablesByTableIdRowsByRowIdResponse = PatchApiProjectsByProjectIdDataTablesByTableIdRowsByRowIdResponses[keyof PatchApiProjectsByProjectIdDataTablesByTableIdRowsByRowIdResponses];
+export type PostApiProjectsByProjectIdDataTablesByTableIdRowsBulkData = {
+    body: {
+        mutations: Array<{
+            data: {
+                [key: string]: unknown;
+            };
+            operation: 'insert';
+        } | {
+            data: {
+                [key: string]: unknown;
+            };
+            expectedVersion?: number;
+            operation: 'update';
+            rowId: string;
+        } | {
+            operation: 'delete';
+            rowId: string;
+        }>;
+    };
+    path: {
+        projectId: string;
+        tableId: string;
+    };
+    query?: never;
+    url: '/api/projects/{projectId}/data-tables/{tableId}/rows/bulk';
+};
+export type PostApiProjectsByProjectIdDataTablesByTableIdRowsBulkErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    409: {
+        error: string;
+    };
+};
+export type PostApiProjectsByProjectIdDataTablesByTableIdRowsBulkError = PostApiProjectsByProjectIdDataTablesByTableIdRowsBulkErrors[keyof PostApiProjectsByProjectIdDataTablesByTableIdRowsBulkErrors];
+export type PostApiProjectsByProjectIdDataTablesByTableIdRowsBulkResponses = {
+    /**
+     * Success
+     */
+    200: {
+        rows: Array<{
+            id: string;
+            tableId: string;
+            data: {
+                [key: string]: unknown;
+            };
+            version: number;
+            createdAt: number;
+            updatedAt: number;
+        }>;
+        deletedRowIds: Array<string>;
+    };
+};
+export type PostApiProjectsByProjectIdDataTablesByTableIdRowsBulkResponse = PostApiProjectsByProjectIdDataTablesByTableIdRowsBulkResponses[keyof PostApiProjectsByProjectIdDataTablesByTableIdRowsBulkResponses];
+export type GetApiNodesData = {
+    body?: never;
+    path?: never;
+    query?: {
+        scope?: string;
+        q?: string;
+        offset?: number;
+        limit?: number;
+        global?: 'true';
+    };
+    url: '/api/nodes';
+};
+export type GetApiNodesErrors = {
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+};
+export type GetApiNodesError = GetApiNodesErrors[keyof GetApiNodesErrors];
+export type GetApiNodesResponses = {
+    /**
+     * Success
+     */
+    200: {
+        items: Array<{
+            id: string;
+            language?: string;
+            icon?: string;
+            label?: string;
+            inputs?: {
+                [key: string]: unknown;
+            };
+            outputs?: {
+                [key: string]: unknown;
+            };
+            command?: string;
+            scope?: 'user' | 'group' | 'org' | 'public';
+            owner?: string;
+        }>;
+        total: number;
+        offset: number;
+        limit: number;
+    };
+};
+export type GetApiNodesResponse = GetApiNodesResponses[keyof GetApiNodesResponses];
+export type GetApiNodesByNodeIdSourceData = {
+    body?: never;
+    path: {
+        nodeId: string;
+    };
+    query?: never;
+    url: '/api/nodes/{nodeId}/source';
+};
+export type GetApiNodesByNodeIdSourceErrors = {
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+};
+export type GetApiNodesByNodeIdSourceError = GetApiNodesByNodeIdSourceErrors[keyof GetApiNodesByNodeIdSourceErrors];
+export type GetApiNodesByNodeIdSourceResponses = {
+    /**
+     * Success
+     */
+    200: {
+        path: string;
+        content: string;
+        language?: string;
+        mtime: number;
+        revision: string;
+        readOnly?: boolean;
+        location?: {
+            path: string;
+            start: number;
+            end: number;
+            line: number;
+            column: number;
+        };
+    };
+};
+export type GetApiNodesByNodeIdSourceResponse = GetApiNodesByNodeIdSourceResponses[keyof GetApiNodesByNodeIdSourceResponses];
+export type PutApiNodesByNodeIdSourceData = {
+    body: {
+        content: string;
+        baseRevision: string;
+    };
+    path: {
+        nodeId: string;
+    };
+    query?: never;
+    url: '/api/nodes/{nodeId}/source';
+};
+export type PutApiNodesByNodeIdSourceErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    409: {
+        error: string;
+    };
+};
+export type PutApiNodesByNodeIdSourceError = PutApiNodesByNodeIdSourceErrors[keyof PutApiNodesByNodeIdSourceErrors];
+export type PutApiNodesByNodeIdSourceResponses = {
+    /**
+     * Success
+     */
+    200: {
+        ok: true;
+        mtime: number;
+        revision: string;
+        describeError?: string;
+        resynced?: boolean;
+    } | {
+        ok: false;
+        conflict: true;
+        content: string;
+        mtime: number;
+        revision: string;
+        reason?: string;
+    };
+};
+export type PutApiNodesByNodeIdSourceResponse = PutApiNodesByNodeIdSourceResponses[keyof PutApiNodesByNodeIdSourceResponses];
+export type PutApiNodesByNodeIdSourceSignatureData = {
+    body: {
+        inputs: {
+            [key: string]: unknown;
+        };
+        outputs: {
+            [key: string]: unknown;
+        };
+        baseRevision: string;
+    };
+    path: {
+        nodeId: string;
+    };
+    query?: never;
+    url: '/api/nodes/{nodeId}/source/signature';
+};
+export type PutApiNodesByNodeIdSourceSignatureErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    409: {
+        error: string;
+    };
+};
+export type PutApiNodesByNodeIdSourceSignatureError = PutApiNodesByNodeIdSourceSignatureErrors[keyof PutApiNodesByNodeIdSourceSignatureErrors];
+export type PutApiNodesByNodeIdSourceSignatureResponses = {
+    /**
+     * Success
+     */
+    200: {
+        ok: true;
+        mtime: number;
+        revision: string;
+        describeError?: string;
+        resynced?: boolean;
+    } | {
+        ok: false;
+        conflict: true;
+        content: string;
+        mtime: number;
+        revision: string;
+        reason?: string;
+    };
+};
+export type PutApiNodesByNodeIdSourceSignatureResponse = PutApiNodesByNodeIdSourceSignatureResponses[keyof PutApiNodesByNodeIdSourceSignatureResponses];
+export type PostApiWorkflowsByWorkflowIdTriggersByTriggerIdEventsData = {
+    body: {
+        [key: string]: unknown;
+    };
+    headers?: {
+        'idempotency-key'?: string;
+    };
+    path: {
+        workflowId: string;
+        triggerId: string;
+    };
+    query?: {
+        project?: string;
+        workspace?: string;
+    };
+    url: '/api/workflows/{workflowId}/triggers/{triggerId}/events';
+};
+export type PostApiWorkflowsByWorkflowIdTriggersByTriggerIdEventsErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    409: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    429: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    503: {
+        error: string;
+    };
+};
+export type PostApiWorkflowsByWorkflowIdTriggersByTriggerIdEventsError = PostApiWorkflowsByWorkflowIdTriggersByTriggerIdEventsErrors[keyof PostApiWorkflowsByWorkflowIdTriggersByTriggerIdEventsErrors];
+export type PostApiWorkflowsByWorkflowIdTriggersByTriggerIdEventsResponses = {
+    /**
+     * Success
+     */
+    202: {
+        requestHash: string;
+        dispatchPending: boolean;
+        runId: string;
+        workflowId: string;
+        status: 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled' | 'interrupted';
+        submittedAt: number;
+        startedAt?: number;
+        finishedAt?: number;
+        result?: {
+            workflowId: string;
+            runId: string;
+            env?: string;
+            status: 'ok' | 'error' | 'partial';
+            nodes: {
+                [key: string]: {
+                    status: 'ok' | 'error' | 'skipped';
+                    attempts: number;
+                    durationMs: number;
+                    command?: string;
+                    inputs?: unknown;
+                    outputs?: unknown;
+                    error?: {
+                        code: string;
+                        message: string;
+                        retryable?: boolean;
+                    };
+                    note?: 'disabled' | 'pinned' | 'upstream-of-from-node';
+                };
+            };
+            outputs: {
+                [key: string]: unknown;
+            };
+            durationMs: number;
+        };
+        error?: string;
+    };
+};
+export type PostApiWorkflowsByWorkflowIdTriggersByTriggerIdEventsResponse = PostApiWorkflowsByWorkflowIdTriggersByTriggerIdEventsResponses[keyof PostApiWorkflowsByWorkflowIdTriggersByTriggerIdEventsResponses];
+export type PostApiWorkflowsByWorkflowIdExecutionsData = {
+    body: {
+        idempotencyKey: string;
+        baseRevision?: string;
+        env?: string;
+        input?: {
+            [key: string]: unknown;
+        };
+        fromNode?: string;
+        pins?: {
+            [key: string]: unknown;
+        };
+    };
+    path: {
+        workflowId: string;
+    };
+    query?: never;
+    url: '/api/workflows/{workflowId}/executions';
+};
+export type PostApiWorkflowsByWorkflowIdExecutionsErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    409: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    413: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    429: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    503: {
+        error: string;
+    };
+};
+export type PostApiWorkflowsByWorkflowIdExecutionsError = PostApiWorkflowsByWorkflowIdExecutionsErrors[keyof PostApiWorkflowsByWorkflowIdExecutionsErrors];
+export type PostApiWorkflowsByWorkflowIdExecutionsResponses = {
+    /**
+     * Success
+     */
+    202: {
+        requestHash: string;
+        dispatchPending: boolean;
+        runId: string;
+        workflowId: string;
+        status: 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled' | 'interrupted';
+        submittedAt: number;
+        startedAt?: number;
+        finishedAt?: number;
+        result?: {
+            workflowId: string;
+            runId: string;
+            env?: string;
+            status: 'ok' | 'error' | 'partial';
+            nodes: {
+                [key: string]: {
+                    status: 'ok' | 'error' | 'skipped';
+                    attempts: number;
+                    durationMs: number;
+                    command?: string;
+                    inputs?: unknown;
+                    outputs?: unknown;
+                    error?: {
+                        code: string;
+                        message: string;
+                        retryable?: boolean;
+                    };
+                    note?: 'disabled' | 'pinned' | 'upstream-of-from-node';
+                };
+            };
+            outputs: {
+                [key: string]: unknown;
+            };
+            durationMs: number;
+        };
+        error?: string;
+    };
+};
+export type PostApiWorkflowsByWorkflowIdExecutionsResponse = PostApiWorkflowsByWorkflowIdExecutionsResponses[keyof PostApiWorkflowsByWorkflowIdExecutionsResponses];
+export type GetApiExecutionsByRunIdData = {
+    body?: never;
+    path: {
+        runId: string;
+    };
+    query?: never;
+    url: '/api/executions/{runId}';
+};
+export type GetApiExecutionsByRunIdErrors = {
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+};
+export type GetApiExecutionsByRunIdError = GetApiExecutionsByRunIdErrors[keyof GetApiExecutionsByRunIdErrors];
+export type GetApiExecutionsByRunIdResponses = {
+    /**
+     * Success
+     */
+    200: {
+        requestHash: string;
+        dispatchPending: boolean;
+        runId: string;
+        workflowId: string;
+        status: 'queued' | 'running' | 'succeeded' | 'failed' | 'cancelled' | 'interrupted';
+        submittedAt: number;
+        startedAt?: number;
+        finishedAt?: number;
+        result?: {
+            workflowId: string;
+            runId: string;
+            env?: string;
+            status: 'ok' | 'error' | 'partial';
+            nodes: {
+                [key: string]: {
+                    status: 'ok' | 'error' | 'skipped';
+                    attempts: number;
+                    durationMs: number;
+                    command?: string;
+                    inputs?: unknown;
+                    outputs?: unknown;
+                    error?: {
+                        code: string;
+                        message: string;
+                        retryable?: boolean;
+                    };
+                    note?: 'disabled' | 'pinned' | 'upstream-of-from-node';
+                };
+            };
+            outputs: {
+                [key: string]: unknown;
+            };
+            durationMs: number;
+        };
+        error?: string;
+    };
+};
+export type GetApiExecutionsByRunIdResponse = GetApiExecutionsByRunIdResponses[keyof GetApiExecutionsByRunIdResponses];
+export type GetApiExecutionsByRunIdEventsData = {
+    body?: never;
+    path: {
+        runId: string;
+    };
+    query?: {
+        after?: number;
+    };
+    url: '/api/executions/{runId}/events';
+};
+export type GetApiExecutionsByRunIdEventsResponses = {
+    /**
+     * SSE stream
+     */
+    200: unknown;
+};
+export type PostApiExecutionsByRunIdCancelData = {
+    body?: never;
+    path: {
+        runId: string;
+    };
+    query?: never;
+    url: '/api/executions/{runId}/cancel';
+};
+export type PostApiExecutionsByRunIdCancelErrors = {
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+};
+export type PostApiExecutionsByRunIdCancelError = PostApiExecutionsByRunIdCancelErrors[keyof PostApiExecutionsByRunIdCancelErrors];
+export type PostApiExecutionsByRunIdCancelResponses = {
+    /**
+     * Success
+     */
+    200: {
+        ok: true;
+        cancelled: boolean;
+    };
+};
+export type PostApiExecutionsByRunIdCancelResponse = PostApiExecutionsByRunIdCancelResponses[keyof PostApiExecutionsByRunIdCancelResponses];
+export type GetApiWorkflowsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        archived?: 'true' | 'false';
+        scope?: string;
+        q?: string;
+        tag?: string;
+        active?: 'true' | 'false';
+        sort?: 'updated' | 'created' | 'name';
+        order?: 'asc' | 'desc';
+        offset?: number;
+        limit?: number;
+    };
+    url: '/api/workflows';
+};
+export type GetApiWorkflowsResponses = {
+    /**
+     * Success
+     */
+    200: {
+        items: Array<{
+            source?: {
+                path: string;
+                symbol: string;
+                kind: 'module' | 'function';
+                checksum: string;
+            };
+            label?: string;
+            archived?: boolean;
+            id: string;
+            description?: string;
+            nodeCount: number;
+            edgeCount: number;
+            scope?: 'user' | 'group' | 'org' | 'public';
+            owner?: string;
+            active?: boolean;
+            tags?: Array<string>;
+            folder?: string;
+            createdAt?: number;
+            updatedAt?: number;
+        }>;
+        total: number;
+        offset: number;
+        limit: number;
+        folders: Array<string>;
+        facets: {
+            tags: Array<string>;
+        };
+    };
+};
+export type GetApiWorkflowsResponse = GetApiWorkflowsResponses[keyof GetApiWorkflowsResponses];
+export type PostApiWorkflowsData = {
+    body: {
+        id: string;
+        description?: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/api/workflows';
+};
+export type PostApiWorkflowsErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    409: {
+        error: string;
+    };
+};
+export type PostApiWorkflowsError = PostApiWorkflowsErrors[keyof PostApiWorkflowsErrors];
+export type PostApiWorkflowsResponses = {
+    /**
+     * Success
+     */
+    201: {
+        ok: true;
+        id: string;
+    };
+};
+export type PostApiWorkflowsResponse = PostApiWorkflowsResponses[keyof PostApiWorkflowsResponses];
+export type GetApiWorkflowsByWorkflowIdNodeCatalogData = {
+    body?: never;
+    path: {
+        workflowId: string;
+    };
+    query?: {
+        q?: string;
+        offset?: number;
+        limit?: number;
+    };
+    url: '/api/workflows/{workflowId}/node-catalog';
+};
+export type GetApiWorkflowsByWorkflowIdNodeCatalogErrors = {
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+};
+export type GetApiWorkflowsByWorkflowIdNodeCatalogError = GetApiWorkflowsByWorkflowIdNodeCatalogErrors[keyof GetApiWorkflowsByWorkflowIdNodeCatalogErrors];
+export type GetApiWorkflowsByWorkflowIdNodeCatalogResponses = {
+    /**
+     * Success
+     */
+    200: {
+        items: Array<{
+            id: string;
+            label: string;
+            symbol?: string;
+            category: string;
+            description: string;
+            icon: string;
+            kind: 'native';
+            params?: {
+                [key: string]: unknown;
+            };
+            defaultParams?: {
+                [key: string]: unknown;
+            };
+        } | {
+            id: string;
+            label: string;
+            symbol?: string;
+            category: string;
+            description: string;
+            icon: string;
+            kind: 'workflow';
+            workflowId: string;
+        }>;
+        total: number;
+        offset: number;
+        limit: number;
+    };
+};
+export type GetApiWorkflowsByWorkflowIdNodeCatalogResponse = GetApiWorkflowsByWorkflowIdNodeCatalogResponses[keyof GetApiWorkflowsByWorkflowIdNodeCatalogResponses];
+export type GetApiWorkflowsByWorkflowIdGraphData = {
+    body?: never;
+    path: {
+        workflowId: string;
+    };
+    query?: {
+        project?: string;
+        workspace?: string;
+    };
+    url: '/api/workflows/{workflowId}/graph';
+};
+export type GetApiWorkflowsByWorkflowIdGraphErrors = {
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+};
+export type GetApiWorkflowsByWorkflowIdGraphError = GetApiWorkflowsByWorkflowIdGraphErrors[keyof GetApiWorkflowsByWorkflowIdGraphErrors];
+export type GetApiWorkflowsByWorkflowIdGraphResponses = {
+    /**
+     * Success
+     */
+    200: {
+        triggers?: Array<{
+            id: string;
+            name: string;
+            enabled?: boolean;
+            kind: 'cron';
+            provider: 'native' | 'external';
+            expression: string;
+            timezone: string;
+            input?: {
+                [key: string]: unknown;
+            };
+        } | {
+            id: string;
+            name: string;
+            enabled?: boolean;
+            kind: 'webhook';
+            payloadPath?: string;
+        }>;
+        id: string;
+        executionId?: string;
+        revision: string;
+        source?: {
+            path: string;
+            symbol: string;
+            kind: 'module' | 'function';
+            checksum: string;
+        };
+        inputs?: {
+            [key: string]: unknown;
+        };
+        types?: {
+            [key: string]: {
+                [key: string]: unknown;
+            };
+        };
+        nodes: Array<{
+            role?: 'entry' | 'step';
+            symbol?: string;
+            description?: string;
+            id: string;
+            language?: string;
+            icon?: string;
+            label?: string;
+            inputs?: {
+                [key: string]: unknown;
+            };
+            outputs?: {
+                [key: string]: unknown;
+            };
+            sourceExpressions?: {
+                [key: string]: string;
+            };
+            kind?: 'function' | 'class' | 'service' | 'const';
+            setup?: {
+                [key: string]: unknown;
+            };
+            provides?: Array<string>;
+            runtime?: {
+                timeout_ms?: number;
+                retries?: number;
+                retry_backoff_ms?: number;
+                concurrency?: number;
+                async?: boolean;
+            };
+            command?: string;
+            disabled?: boolean;
+            position?: {
+                x: number;
+                y: number;
+            };
+            scope?: 'user' | 'group' | 'org' | 'public';
+            owner?: string;
+            expressions?: {
+                [key: string]: string;
+            };
+            bindings?: {
+                [key: string]: {
+                    kind: 'literal';
+                    value?: unknown;
+                } | {
+                    kind: 'symbol';
+                    symbol: string;
+                    value?: unknown;
+                };
+            };
+        }>;
+        edges: Array<{
+            from: {
+                node: string;
+                output?: string;
+            };
+            to: {
+                node: string;
+                input?: string;
+            };
+            kind?: 'data' | 'dependency' | 'control';
+        }>;
+        promises?: Array<{
+            node: string;
+            mode: 'all' | 'allSettled' | 'race' | 'any' | 'reject' | 'settled' | 'then' | 'catch' | 'finally';
+        }>;
+        roots: Array<string>;
+        terminals: Array<string>;
+        stickyNotes?: Array<{
+            id: string;
+            position: {
+                x: number;
+                y: number;
+            };
+            size: {
+                width: number;
+                height: number;
+            };
+            text: string;
+            color: string;
+        }>;
+        groups?: Array<{
+            id: string;
+            position: {
+                x: number;
+                y: number;
+            };
+            size: {
+                width: number;
+                height: number;
+            };
+            label?: string;
+            nodeIds: Array<string>;
+        }>;
+    };
+};
+export type GetApiWorkflowsByWorkflowIdGraphResponse = GetApiWorkflowsByWorkflowIdGraphResponses[keyof GetApiWorkflowsByWorkflowIdGraphResponses];
+export type PostApiWorkflowsByWorkflowIdRunData = {
+    body: {
+        env?: string;
+        input?: unknown;
+    };
+    path: {
+        workflowId: string;
+    };
+    query?: never;
+    url: '/api/workflows/{workflowId}/run';
+};
+export type PostApiWorkflowsByWorkflowIdRunResponses = {
+    /**
+     * SSE stream
+     */
+    200: unknown;
+};
+export type PostApiWorkflowsByWorkflowIdTopologyData = {
+    body: {
+        baseRevision: string;
+        entry?: string;
+        edges: Array<{
+            from: {
+                node: string;
+                output?: string;
+            };
+            to: {
+                node: string;
+                input?: string;
+            };
+            kind?: 'data' | 'dependency' | 'control';
+        }>;
+        nodes?: Array<string>;
+        expressions?: {
+            [key: string]: {
+                [key: string]: string;
+            };
+        };
+        bindings?: {
+            [key: string]: {
+                [key: string]: {
+                    kind: 'literal';
+                    value?: unknown;
+                } | {
+                    kind: 'symbol';
+                    symbol: string;
+                    value?: unknown;
+                };
+            };
+        };
+        positions?: {
+            [key: string]: {
+                x: number;
+                y: number;
+            };
+        };
+        stickyNotes?: Array<{
+            id: string;
+            position: {
+                x: number;
+                y: number;
+            };
+            size: {
+                width: number;
+                height: number;
+            };
+            text: string;
+            color: string;
+        }>;
+        groups?: Array<{
+            id: string;
+            position: {
+                x: number;
+                y: number;
+            };
+            size: {
+                width: number;
+                height: number;
+            };
+            label?: string;
+            nodeIds?: Array<string>;
+        }>;
+    };
+    path: {
+        workflowId: string;
+    };
+    query?: never;
+    url: '/api/workflows/{workflowId}/topology';
+};
+export type PostApiWorkflowsByWorkflowIdTopologyErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    409: {
+        conflict: true;
+        error: string;
+        graph: {
+            triggers?: Array<{
+                id: string;
+                name: string;
+                enabled?: boolean;
+                kind: 'cron';
+                provider: 'native' | 'external';
+                expression: string;
+                timezone: string;
+                input?: {
+                    [key: string]: unknown;
+                };
+            } | {
+                id: string;
+                name: string;
+                enabled?: boolean;
+                kind: 'webhook';
+                payloadPath?: string;
+            }>;
+            id: string;
+            executionId?: string;
+            revision: string;
+            source?: {
+                path: string;
+                symbol: string;
+                kind: 'module' | 'function';
+                checksum: string;
+            };
+            inputs?: {
+                [key: string]: unknown;
+            };
+            types?: {
+                [key: string]: {
+                    [key: string]: unknown;
+                };
+            };
+            nodes: Array<{
+                role?: 'entry' | 'step';
+                symbol?: string;
+                description?: string;
+                id: string;
+                language?: string;
+                icon?: string;
+                label?: string;
+                inputs?: {
+                    [key: string]: unknown;
+                };
+                outputs?: {
+                    [key: string]: unknown;
+                };
+                sourceExpressions?: {
+                    [key: string]: string;
+                };
+                kind?: 'function' | 'class' | 'service' | 'const';
+                setup?: {
+                    [key: string]: unknown;
+                };
+                provides?: Array<string>;
+                runtime?: {
+                    timeout_ms?: number;
+                    retries?: number;
+                    retry_backoff_ms?: number;
+                    concurrency?: number;
+                    async?: boolean;
+                };
+                command?: string;
+                disabled?: boolean;
+                position?: {
+                    x: number;
+                    y: number;
+                };
+                scope?: 'user' | 'group' | 'org' | 'public';
+                owner?: string;
+                expressions?: {
+                    [key: string]: string;
+                };
+                bindings?: {
+                    [key: string]: {
+                        kind: 'literal';
+                        value?: unknown;
+                    } | {
+                        kind: 'symbol';
+                        symbol: string;
+                        value?: unknown;
+                    };
+                };
+            }>;
+            edges: Array<{
+                from: {
+                    node: string;
+                    output?: string;
+                };
+                to: {
+                    node: string;
+                    input?: string;
+                };
+                kind?: 'data' | 'dependency' | 'control';
+            }>;
+            promises?: Array<{
+                node: string;
+                mode: 'all' | 'allSettled' | 'race' | 'any' | 'reject' | 'settled' | 'then' | 'catch' | 'finally';
+            }>;
+            roots: Array<string>;
+            terminals: Array<string>;
+            stickyNotes?: Array<{
+                id: string;
+                position: {
+                    x: number;
+                    y: number;
+                };
+                size: {
+                    width: number;
+                    height: number;
+                };
+                text: string;
+                color: string;
+            }>;
+            groups?: Array<{
+                id: string;
+                position: {
+                    x: number;
+                    y: number;
+                };
+                size: {
+                    width: number;
+                    height: number;
+                };
+                label?: string;
+                nodeIds: Array<string>;
+            }>;
+        };
+        revision: string;
+    };
+};
+export type PostApiWorkflowsByWorkflowIdTopologyError = PostApiWorkflowsByWorkflowIdTopologyErrors[keyof PostApiWorkflowsByWorkflowIdTopologyErrors];
+export type PostApiWorkflowsByWorkflowIdTopologyResponses = {
+    /**
+     * Success
+     */
+    200: {
+        graph: {
+            triggers?: Array<{
+                id: string;
+                name: string;
+                enabled?: boolean;
+                kind: 'cron';
+                provider: 'native' | 'external';
+                expression: string;
+                timezone: string;
+                input?: {
+                    [key: string]: unknown;
+                };
+            } | {
+                id: string;
+                name: string;
+                enabled?: boolean;
+                kind: 'webhook';
+                payloadPath?: string;
+            }>;
+            id: string;
+            executionId?: string;
+            revision: string;
+            source?: {
+                path: string;
+                symbol: string;
+                kind: 'module' | 'function';
+                checksum: string;
+            };
+            inputs?: {
+                [key: string]: unknown;
+            };
+            types?: {
+                [key: string]: {
+                    [key: string]: unknown;
+                };
+            };
+            nodes: Array<{
+                role?: 'entry' | 'step';
+                symbol?: string;
+                description?: string;
+                id: string;
+                language?: string;
+                icon?: string;
+                label?: string;
+                inputs?: {
+                    [key: string]: unknown;
+                };
+                outputs?: {
+                    [key: string]: unknown;
+                };
+                sourceExpressions?: {
+                    [key: string]: string;
+                };
+                kind?: 'function' | 'class' | 'service' | 'const';
+                setup?: {
+                    [key: string]: unknown;
+                };
+                provides?: Array<string>;
+                runtime?: {
+                    timeout_ms?: number;
+                    retries?: number;
+                    retry_backoff_ms?: number;
+                    concurrency?: number;
+                    async?: boolean;
+                };
+                command?: string;
+                disabled?: boolean;
+                position?: {
+                    x: number;
+                    y: number;
+                };
+                scope?: 'user' | 'group' | 'org' | 'public';
+                owner?: string;
+                expressions?: {
+                    [key: string]: string;
+                };
+                bindings?: {
+                    [key: string]: {
+                        kind: 'literal';
+                        value?: unknown;
+                    } | {
+                        kind: 'symbol';
+                        symbol: string;
+                        value?: unknown;
+                    };
+                };
+            }>;
+            edges: Array<{
+                from: {
+                    node: string;
+                    output?: string;
+                };
+                to: {
+                    node: string;
+                    input?: string;
+                };
+                kind?: 'data' | 'dependency' | 'control';
+            }>;
+            promises?: Array<{
+                node: string;
+                mode: 'all' | 'allSettled' | 'race' | 'any' | 'reject' | 'settled' | 'then' | 'catch' | 'finally';
+            }>;
+            roots: Array<string>;
+            terminals: Array<string>;
+            stickyNotes?: Array<{
+                id: string;
+                position: {
+                    x: number;
+                    y: number;
+                };
+                size: {
+                    width: number;
+                    height: number;
+                };
+                text: string;
+                color: string;
+            }>;
+            groups?: Array<{
+                id: string;
+                position: {
+                    x: number;
+                    y: number;
+                };
+                size: {
+                    width: number;
+                    height: number;
+                };
+                label?: string;
+                nodeIds: Array<string>;
+            }>;
+        };
+        revision: string;
+        code?: string;
+    };
+};
+export type PostApiWorkflowsByWorkflowIdTopologyResponse = PostApiWorkflowsByWorkflowIdTopologyResponses[keyof PostApiWorkflowsByWorkflowIdTopologyResponses];
+export type PostApiWorkflowsByWorkflowIdValidateConnectionData = {
+    body: {
+        from: {
+            node: string;
+            output?: string;
+        };
+        to: {
+            node: string;
+            input?: string;
+        };
+    };
+    path: {
+        workflowId: string;
+    };
+    query?: never;
+    url: '/api/workflows/{workflowId}/validate-connection';
+};
+export type PostApiWorkflowsByWorkflowIdValidateConnectionErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+};
+export type PostApiWorkflowsByWorkflowIdValidateConnectionError = PostApiWorkflowsByWorkflowIdValidateConnectionErrors[keyof PostApiWorkflowsByWorkflowIdValidateConnectionErrors];
+export type PostApiWorkflowsByWorkflowIdValidateConnectionResponses = {
+    /**
+     * Success
+     */
+    200: {
+        ok: true;
+    } | {
+        ok: false;
+        code: 'from_node_missing' | 'to_node_missing' | 'self_edge' | 'duplicate_edge' | 'from_port_missing' | 'to_port_missing' | 'type_mismatch' | 'cycle';
+        message: string;
+    };
+};
+export type PostApiWorkflowsByWorkflowIdValidateConnectionResponse = PostApiWorkflowsByWorkflowIdValidateConnectionResponses[keyof PostApiWorkflowsByWorkflowIdValidateConnectionResponses];
+export type GetApiMarketplaceData = {
+    body?: never;
+    path?: never;
+    query?: {
+        q?: string;
+        category?: string;
+        tag?: string;
+        installed?: 'true' | 'false';
+        offset?: number;
+        limit?: number;
+        scope?: string;
+        fields?: string;
+    };
+    url: '/api/marketplace';
+};
+export type GetApiMarketplaceErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+};
+export type GetApiMarketplaceError = GetApiMarketplaceErrors[keyof GetApiMarketplaceErrors];
+export type GetApiMarketplaceResponses = {
+    /**
+     * Success
+     */
+    200: {
+        items: Array<{
+            id: string;
+            name: string;
+            version: string;
+            description?: string;
+            icon?: string;
+            author?: string;
+            homepage?: string;
+            category?: string;
+            tags: Array<string>;
+            nodes?: Array<{
+                id: string;
+                label?: string;
+                symbol?: string;
+                description?: string;
+                inputs?: {
+                    [key: string]: unknown;
+                };
+                outputs?: {
+                    [key: string]: unknown;
+                };
+                defaults?: {
+                    [key: string]: unknown;
+                };
+                connections?: Array<string>;
+            }>;
+            installed: boolean;
+            scope?: 'user' | 'group' | 'org' | 'public';
+            permissions?: Array<{
+                resource: string;
+                access: string;
+            }>;
+        }>;
+        total: number;
+        offset: number;
+        limit: number;
+        facets: {
+            categories: Array<string>;
+            tags: Array<string>;
+        };
+    };
+};
+export type GetApiMarketplaceResponse = GetApiMarketplaceResponses[keyof GetApiMarketplaceResponses];
+export type GetApiMarketplacePluginsByIdData = {
+    body?: never;
+    path: {
+        id: string;
+    };
+    query?: {
+        q?: string;
+        offset?: number;
+        limit?: number;
+        scope?: string;
+    };
+    url: '/api/marketplace/plugins/{id}';
+};
+export type GetApiMarketplacePluginsByIdErrors = {
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+};
+export type GetApiMarketplacePluginsByIdError = GetApiMarketplacePluginsByIdErrors[keyof GetApiMarketplacePluginsByIdErrors];
+export type GetApiMarketplacePluginsByIdResponses = {
+    /**
+     * Success
+     */
+    200: {
+        id: string;
+        name: string;
+        version: string;
+        description?: string;
+        icon?: string;
+        author?: string;
+        homepage?: string;
+        license?: string;
+        source: 'marketplace';
+        nodeCount: number;
+        category?: string;
+        tags: Array<string>;
+        nodes: Array<{
+            id: string;
+            label?: string;
+            symbol?: string;
+            description?: string;
+            inputs?: {
+                [key: string]: unknown;
+            };
+            outputs?: {
+                [key: string]: unknown;
+            };
+            defaults?: {
+                [key: string]: unknown;
+            };
+            connections?: Array<string>;
+        }>;
+        connections?: {
+            [key: string]: {
+                label: string;
+                description?: string;
+                fields: {
+                    [key: string]: {
+                        label: string;
+                        description?: string;
+                        secret?: boolean;
+                        required?: boolean;
+                    };
+                };
+            };
+        };
+        installed: boolean;
+        scope: Array<'user' | 'group' | 'org' | 'public'>;
+        permissions: Array<{
+            resource: string;
+            access: string;
+        }>;
+        nodesTotal: number;
+        nodesOffset: number;
+        nodesLimit: number;
+        attachedProjects: Array<unknown>;
+    };
+};
+export type GetApiMarketplacePluginsByIdResponse = GetApiMarketplacePluginsByIdResponses[keyof GetApiMarketplacePluginsByIdResponses];
+export type GetApiPluginsData = {
+    body?: never;
+    path?: never;
+    query?: {
+        global?: 'true';
+        fields?: string;
+    };
+    url: '/api/plugins';
+};
+export type GetApiPluginsResponses = {
+    /**
+     * Success
+     */
+    200: Array<{
+        id: string;
+        name: string;
+        version: string;
+        description?: string;
+        icon?: string;
+        author?: string;
+        homepage?: string;
+        license?: string;
+        source: string;
+        nodeCount: number;
+        category?: string;
+        tags: Array<string>;
+        nodes?: Array<{
+            id: string;
+            label?: string;
+            symbol?: string;
+            description?: string;
+            inputs?: {
+                [key: string]: unknown;
+            };
+            outputs?: {
+                [key: string]: unknown;
+            };
+            defaults?: {
+                [key: string]: unknown;
+            };
+            connections?: Array<string>;
+        }>;
+    }>;
+};
+export type GetApiPluginsResponse = GetApiPluginsResponses[keyof GetApiPluginsResponses];
+export type GetApiPluginsSearchData = {
+    body?: never;
+    path?: never;
+    query?: {
+        q?: string;
+        offset?: number;
+        limit?: number;
+        global?: 'true';
+        fields?: string;
+    };
+    url: '/api/plugins/search';
+};
+export type GetApiPluginsSearchResponses = {
+    /**
+     * Success
+     */
+    200: {
+        items: Array<{
+            id: string;
+            name: string;
+            version: string;
+            description?: string;
+            icon?: string;
+            author?: string;
+            homepage?: string;
+            license?: string;
+            source: string;
+            nodeCount: number;
+            category?: string;
+            tags: Array<string>;
+            nodes?: Array<{
+                id: string;
+                label?: string;
+                symbol?: string;
+                description?: string;
+                inputs?: {
+                    [key: string]: unknown;
+                };
+                outputs?: {
+                    [key: string]: unknown;
+                };
+                defaults?: {
+                    [key: string]: unknown;
+                };
+                connections?: Array<string>;
+            }>;
+        }>;
+        total: number;
+        offset: number;
+        limit: number;
+    };
+};
+export type GetApiPluginsSearchResponse = GetApiPluginsSearchResponses[keyof GetApiPluginsSearchResponses];
+export type GetApiPluginsNodesData = {
+    body?: never;
+    path?: never;
+    query?: {
+        q?: string;
+        offset?: number;
+        limit?: number;
+        global?: 'true';
+    };
+    url: '/api/plugins/nodes';
+};
+export type GetApiPluginsNodesErrors = {
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+};
+export type GetApiPluginsNodesError = GetApiPluginsNodesErrors[keyof GetApiPluginsNodesErrors];
+export type GetApiPluginsNodesResponses = {
+    /**
+     * Success
+     */
+    200: {
+        items: Array<{
+            id: string;
+            label?: string;
+            symbol?: string;
+            description?: string;
+            inputs?: {
+                [key: string]: unknown;
+            };
+            outputs?: {
+                [key: string]: unknown;
+            };
+            defaults?: {
+                [key: string]: unknown;
+            };
+            connections?: Array<string>;
+            pluginId: string;
+            pluginName: string;
+            pluginVersion: string;
+        }>;
+        total: number;
+        offset: number;
+        limit: number;
+    };
+};
+export type GetApiPluginsNodesResponse = GetApiPluginsNodesResponses[keyof GetApiPluginsNodesResponses];
+export type GetApiPluginsByPluginIdData = {
+    body?: never;
+    path: {
+        pluginId: string;
+    };
+    query?: {
+        global?: 'true';
+        q?: string;
+        offset?: number;
+        limit?: number;
+    };
+    url: '/api/plugins/{pluginId}';
+};
+export type GetApiPluginsByPluginIdErrors = {
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+};
+export type GetApiPluginsByPluginIdError = GetApiPluginsByPluginIdErrors[keyof GetApiPluginsByPluginIdErrors];
+export type GetApiPluginsByPluginIdResponses = {
+    /**
+     * Success
+     */
+    200: {
+        id: string;
+        name: string;
+        version: string;
+        description?: string;
+        icon?: string;
+        author?: string;
+        homepage?: string;
+        license?: string;
+        source: string;
+        nodeCount: number;
+        category?: string;
+        tags: Array<string>;
+        nodes: Array<{
+            id: string;
+            label?: string;
+            symbol?: string;
+            description?: string;
+            inputs?: {
+                [key: string]: unknown;
+            };
+            outputs?: {
+                [key: string]: unknown;
+            };
+            defaults?: {
+                [key: string]: unknown;
+            };
+            connections?: Array<string>;
+            language?: string;
+            command: string;
+            icon?: string;
+            trigger?: boolean;
+            env?: Array<string>;
+        }>;
+        installed: true;
+        connections?: {
+            [key: string]: {
+                label: string;
+                description?: string;
+                fields: {
+                    [key: string]: {
+                        label: string;
+                        description?: string;
+                        secret?: boolean;
+                        required?: boolean;
+                    };
+                };
+            };
+        };
+        scope: Array<'user' | 'group' | 'org' | 'public'>;
+        permissions: Array<{
+            resource: string;
+            access: string;
+        }>;
+        nodesTotal: number;
+        nodesOffset: number;
+        nodesLimit: number;
+        attachedProjects: Array<{
+            id: string;
+            name: string;
+            path?: string;
+        }>;
+    };
+};
+export type GetApiPluginsByPluginIdResponse = GetApiPluginsByPluginIdResponses[keyof GetApiPluginsByPluginIdResponses];
+export type PostApiPluginsByPluginIdNodesByNodeIdAddData = {
+    body: {
+        instanceId?: string;
+        workflowId?: string;
+        draft?: boolean;
+        position?: {
+            x: number;
+            y: number;
+        };
+    };
+    path: {
+        pluginId: string;
+        nodeId: string;
+    };
+    query?: never;
+    url: '/api/plugins/{pluginId}/nodes/{nodeId}/add';
+};
+export type PostApiPluginsByPluginIdNodesByNodeIdAddErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    409: {
+        error: string;
+    };
+};
+export type PostApiPluginsByPluginIdNodesByNodeIdAddError = PostApiPluginsByPluginIdNodesByNodeIdAddErrors[keyof PostApiPluginsByPluginIdNodesByNodeIdAddErrors];
+export type PostApiPluginsByPluginIdNodesByNodeIdAddResponses = {
+    /**
+     * Success
+     */
+    200: {
+        instanceId: string;
+        node: {
+            role?: 'entry' | 'step';
+            symbol?: string;
+            description?: string;
+            id: string;
+            language?: string;
+            icon?: string;
+            label?: string;
+            inputs?: {
+                [key: string]: unknown;
+            };
+            outputs?: {
+                [key: string]: unknown;
+            };
+            sourceExpressions?: {
+                [key: string]: string;
+            };
+            kind?: 'function' | 'class' | 'service' | 'const';
+            setup?: {
+                [key: string]: unknown;
+            };
+            provides?: Array<string>;
+            runtime?: {
+                timeout_ms?: number;
+                retries?: number;
+                retry_backoff_ms?: number;
+                concurrency?: number;
+                async?: boolean;
+            };
+            command?: string;
+            disabled?: boolean;
+            position?: {
+                x: number;
+                y: number;
+            };
+            scope?: 'user' | 'group' | 'org' | 'public';
+            owner?: string;
+            expressions?: {
+                [key: string]: string;
+            };
+            bindings?: {
+                [key: string]: {
+                    kind: 'literal';
+                    value?: unknown;
+                } | {
+                    kind: 'symbol';
+                    symbol: string;
+                    value?: unknown;
+                };
+            };
+        };
+    };
+};
+export type PostApiPluginsByPluginIdNodesByNodeIdAddResponse = PostApiPluginsByPluginIdNodesByNodeIdAddResponses[keyof PostApiPluginsByPluginIdNodesByNodeIdAddResponses];
+export type GetApiMarketplaceAnalyticsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/marketplace/analytics';
+};
+export type GetApiMarketplaceAnalyticsErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+};
+export type GetApiMarketplaceAnalyticsError = GetApiMarketplaceAnalyticsErrors[keyof GetApiMarketplaceAnalyticsErrors];
+export type GetApiMarketplaceAnalyticsResponses = {
+    /**
+     * Success
+     */
+    200: {
+        summary: {
+            pluginCount: number;
+            installs: number;
+            activeInstalls: number;
+            invokes: number;
+            errors: number;
+            attempts: number;
+            activeRate: number;
+            reliability: number;
+        };
+        plugins: Array<{
+            pluginId: string;
+            installs: number;
+            activeInstalls: number;
+            invokes: number;
+            errors: number;
+            attempts: number;
+            errorRate: number;
+            activityShare: number;
+        }>;
+    };
+};
+export type GetApiMarketplaceAnalyticsResponse = GetApiMarketplaceAnalyticsResponses[keyof GetApiMarketplaceAnalyticsResponses];
+export type GetApiTemplatesData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/templates';
+};
+export type GetApiTemplatesResponses = {
+    /**
+     * Success
+     */
+    200: Array<{
+        id: string;
+        name: string;
+        description: string;
+        nodeCount: number;
+    }>;
+};
+export type GetApiTemplatesResponse = GetApiTemplatesResponses[keyof GetApiTemplatesResponses];
+export type GetApiNativeNodesData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/native-nodes';
+};
+export type GetApiNativeNodesResponses = {
+    /**
+     * Success
+     */
+    200: Array<{
+        id: string;
+        label: string;
+        symbol?: string;
+        category: 'math' | 'flow' | 'data' | 'text' | 'logic' | 'datetime' | 'code' | 'console' | 'integration';
+        description: string;
+        icon: string;
+        params?: {
+            [key: string]: unknown;
+        };
+        defaultParams?: {
+            [key: string]: unknown;
+        };
+        inputs: {
+            [key: string]: unknown;
+        };
+        outputs: {
+            [key: string]: unknown;
+        };
+    }>;
+};
+export type GetApiNativeNodesResponse = GetApiNativeNodesResponses[keyof GetApiNativeNodesResponses];
+export type PostApiNativeNodesByCatalogIdMaterializeData = {
+    body: {
+        workflowId?: string;
+        draft?: boolean;
+        instanceId?: string;
+        language?: 'typescript';
+        position?: {
+            x: number;
+            y: number;
+        };
+        params?: {
+            [key: string]: unknown;
+        };
+    };
+    path: {
+        catalogId: string;
+    };
+    query?: never;
+    url: '/api/native-nodes/{catalogId}/materialize';
+};
+export type PostApiNativeNodesByCatalogIdMaterializeErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    403: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    404: {
+        error: string;
+    };
+    /**
+     * Error
+     */
+    409: {
+        error: string;
+    };
+};
+export type PostApiNativeNodesByCatalogIdMaterializeError = PostApiNativeNodesByCatalogIdMaterializeErrors[keyof PostApiNativeNodesByCatalogIdMaterializeErrors];
+export type PostApiNativeNodesByCatalogIdMaterializeResponses = {
+    /**
+     * Success
+     */
+    200: {
+        role: 'entry' | 'step';
+        ok: true;
+        instanceId: string;
+        filePath: string;
+        artifactPath?: string;
+        command: string;
+        language: 'typescript';
+        signature: {
+            language: string;
+            command: string;
+            sourceExpressions?: {
+                [key: string]: string;
+            };
+            sourceExcerpt?: {
+                path: string;
+                start: number;
+                end: number;
+                line: number;
+                column: number;
+                content: string;
+            };
+            defaults?: {
+                [key: string]: unknown;
+            };
+            requiredEnv?: Array<string>;
+            workflowId?: string;
+            kind?: 'function' | 'class' | 'service' | 'const';
+            cwd?: string;
+            inputs?: {
+                [key: string]: unknown;
+            };
+            outputs?: {
+                [key: string]: unknown;
+            };
+            setup?: {
+                [key: string]: unknown;
+            };
+            checksum?: string;
+            orphaned?: boolean;
+            service?: {
+                host: string;
+                method?: string;
+                lifecycle: 'invocation' | 'workflow-run' | 'worker';
+            };
+        };
+        presentation: {
+            icon?: string;
+            label?: string;
+            symbol?: string;
+            description?: string;
+            color?: string;
+            position?: {
+                x: number;
+                y: number;
+            };
+        };
+    };
+};
+export type PostApiNativeNodesByCatalogIdMaterializeResponse = PostApiNativeNodesByCatalogIdMaterializeResponses[keyof PostApiNativeNodesByCatalogIdMaterializeResponses];
+export type GetApiWorkspacesData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/workspaces';
+};
+export type GetApiWorkspacesErrors = {
+    /**
+     * Error
+     */
+    502: {
+        error: string;
+    };
+};
+export type GetApiWorkspacesError = GetApiWorkspacesErrors[keyof GetApiWorkspacesErrors];
+export type GetApiWorkspacesResponses = {
+    /**
+     * Success
+     */
+    200: {
+        personal: {
+            kind: 'user';
+            id: string;
+            name: string;
+        };
+        orgs: Array<{
+            kind: 'org';
+            id: string;
+            name: string;
+            role: string;
+            permissions: {
+                [key: string]: boolean;
+            };
+            teams: Array<{
+                kind: 'team';
+                id: string;
+                name: string;
+                role: string;
+                permissions: {
+                    [key: string]: boolean;
+                };
+            }>;
+        }>;
+        remote: boolean;
+    };
+};
+export type GetApiWorkspacesResponse = GetApiWorkspacesResponses[keyof GetApiWorkspacesResponses];
+export type GetApiWorkspacesPermissionsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/api/workspaces/permissions';
+};
+export type GetApiWorkspacesPermissionsErrors = {
+    /**
+     * Error
+     */
+    400: {
+        error: string;
+    };
+};
+export type GetApiWorkspacesPermissionsError = GetApiWorkspacesPermissionsErrors[keyof GetApiWorkspacesPermissionsErrors];
+export type GetApiWorkspacesPermissionsResponses = {
+    /**
+     * Success
+     */
+    200: {
+        role: string;
+        actions: Array<string>;
+        permissions: {
+            [key: string]: boolean;
+        };
+        projectId?: string | null;
+        capabilities: {
+            collaboration: boolean;
+        };
+    };
+};
+export type GetApiWorkspacesPermissionsResponse = GetApiWorkspacesPermissionsResponses[keyof GetApiWorkspacesPermissionsResponses];
+//# sourceMappingURL=types.gen.d.ts.map