terse-types 0.0.1 → 0.0.3

package/dist/types.js

@@ -1,7 +1,128 @@
+import * as z from "zod";
+import { configDataSchema, configTypeEnum } from "./Configs.js";
+import { integrationTypeEnum } from "./Integrations.js";
+import { RUN_HISTORY_ACTION_TYPES, RunHistoryStatus, runHistoryActionBaseSchema } from "./RunHistoryTypes.js";
+import { slackUserResponseSchema } from "./Tools.js";
+const pointSchema = z.object({
+    x: z.number(),
+    y: z.number()
+});
+const unknownRecordSchema = z.record(z.string(), z.unknown());
+export const roleSchema = z.enum(["admin", "user"]);
+export const userSchema = z.object({
+    id: z.string(),
+    workosId: z.string(),
+    organizationId: z.string(),
+    organizationName: z.string(),
+    email: z.string(),
+    displayName: z.string(),
+    firstName: z.string().nullable(),
+    lastName: z.string().nullable(),
+    displayPhotoUrl: z.string(),
+    roles: z.array(roleSchema)
+});
+export const userNoOrganizationSchema = userSchema.omit({
+    organizationId: true,
+    organizationName: true,
+    roles: true
+});
+export const commitAssociationSchema = z.object({
+    sha: z.string(),
+    message: z.string(),
+    url: z.string()
+});
+export const subActivitySchema = z.object({
+    summary: z.string(),
+    commits: z.array(commitAssociationSchema)
+});
+export const activityEventSchema = z.object({
+    event_type: z.string(),
+    title: z.string(),
+    github_repository_owner_id: z.string(),
+    github_repository_name: z.string(),
+    created_at: z.date(),
+    sub_activities: z.array(subActivitySchema)
+});
+export const linearWorkspaceSchema = z.object({
+    id: z.string(),
+    name: z.string()
+});
+export const jiraProjectSchema = z.object({
+    id: z.string(),
+    key: z.string(),
+    name: z.string()
+});
+export const jiraCredentialsValidationResponseSchema = z.object({
+    valid: z.boolean(),
+    projects: z.array(jiraProjectSchema).optional(),
+    error: z.string().optional()
+});
+export const notionResourceTypeSchema = z.enum(["database", "page"]);
+export const notionResourceSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    url: z.string(),
+    type: notionResourceTypeSchema
+});
+export const notionResourcesResponseSchema = z.object({
+    resources: z.array(notionResourceSchema)
+});
+export const posthogProjectSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    organization_id: z.string().optional()
+});
+export const posthogProjectsResponseSchema = z.object({
+    projects: z.array(posthogProjectSchema)
+});
+export const launchDarklyProjectSchema = z.object({
+    key: z.string(),
+    name: z.string()
+});
+export const launchDarklyProjectsResponseSchema = z.object({
+    projects: z.array(launchDarklyProjectSchema)
+});
+export const launchDarklyEnvironmentSchema = z.object({
+    key: z.string(),
+    name: z.string()
+});
+export const launchDarklyEnvironmentsResponseSchema = z.object({
+    environments: z.array(launchDarklyEnvironmentSchema)
+});
+export const datadogIndexSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    isEnabled: z.boolean(),
+    dailyLimit: z.number().int().optional(),
+    retentionDays: z.number().int().optional()
+});
+export const datadogIndexesResponseSchema = z.object({
+    indexes: z.array(datadogIndexSchema)
+});
+export const slackChannelSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    isPrivate: z.boolean(),
+    isArchived: z.boolean(),
+    isMPIM: z.boolean()
+});
+export const slackChannelsResponseSchema = z.object({
+    channels: z.array(slackChannelSchema),
+    selectedChannelId: z.string().nullable()
+});
+export const slackUsersResponseSchema = z.object({
+    users: z.array(slackUserResponseSchema)
+});
 export const TERSE_AGENT_MESSAGE_EVENT_TYPE = "terse_agent_message";
-/**
- * Slack channel type enum
- */
+export const terseAgentMessageEventPayloadSchema = z.object({
+    run_id: z.string(),
+    automation_id: z.string(),
+    organization_id: z.string()
+});
+export const terseAgentMessageMetadataSchema = z.object({
+    event_type: z.literal(TERSE_AGENT_MESSAGE_EVENT_TYPE),
+    event_payload: terseAgentMessageEventPayloadSchema
+});
 export var SlackChannelType;
 (function (SlackChannelType) {
     SlackChannelType["CHANNEL"] = "channel";
@@ -9,107 +130,615 @@ export var SlackChannelType;
     SlackChannelType["MPIM"] = "mpim";
     SlackChannelType["IM"] = "im";
 })(SlackChannelType || (SlackChannelType = {}));
-// Figma webhook and API types
+export const slackChannelTypeSchema = z.enum(SlackChannelType);
+export const confluencePageSchema = z.object({
+    id: z.string(),
+    title: z.string(),
+    spaceId: z.string(),
+    spaceName: z.string(),
+    url: z.string(),
+    status: z.string(),
+    version: z.number().int()
+});
+export const confluencePagesQuerySchema = z
+    .object({
+    integrationId: z.string(),
+    spaceId: z.string().optional(),
+    spaceKey: z.string().optional()
+})
+    .refine(({ spaceId, spaceKey }) => spaceId != null || spaceKey != null, {
+    message: "Either spaceId or spaceKey is required"
+});
+export const confluencePagesResponseSchema = z.object({
+    pages: z.array(confluencePageSchema),
+    spaceId: z.string(),
+    total: z.number().int()
+});
+export const confluenceResourcesResponseSchema = z.object({
+    resources: z.array(confluencePageSchema),
+    spaceId: z.string(),
+    total: z.number().int()
+});
+export const jiraResourceProjectSchema = z.object({
+    id: z.string(),
+    key: z.string(),
+    name: z.string(),
+    projectTypeKey: z.string()
+});
+export const jiraResourcesPayloadSchema = z.object({
+    projects: z.array(jiraResourceProjectSchema),
+    baseUrl: z.string(),
+    cloudId: z.string()
+});
+export const jiraResourcesResponseSchema = z.object({
+    success: z.boolean(),
+    resources: jiraResourcesPayloadSchema
+});
+export const useConfluenceResourcesReturnBaseSchema = z.object({
+    resources: z.array(confluencePageSchema),
+    response: confluenceResourcesResponseSchema.optional(),
+    isLoading: z.boolean(),
+    isError: z.boolean(),
+    error: z.unknown(),
+    isValidating: z.boolean()
+});
+export const createUseConfluenceResourcesReturnSchema = (mutateSchema) => useConfluenceResourcesReturnBaseSchema.extend({
+    mutate: mutateSchema
+});
 export var FigmaEventTypes;
 (function (FigmaEventTypes) {
     FigmaEventTypes["FILE_COMMENT"] = "FILE_COMMENT";
 })(FigmaEventTypes || (FigmaEventTypes = {}));
-// export type SlackChannelListItem = z.infer<typeof slackChannelListItemSchema>
-// export type SlackConversationMessage = z.infer<typeof slackConversationMessageSchema>
-// export type GitHubPagination = z.infer<typeof gitHubPaginationSchema>
-// export type GitHubCodeSearchResult = z.infer<typeof gitHubCodeSearchResultSchema>
-// export type GitHubCodeGrepResult = z.infer<typeof gitHubCodeGrepResultSchema>
-// export type GitHubPullRequestSummary = z.infer<typeof gitHubPullRequestSummarySchema>
-// export type GitHubDirectoryEntry = z.infer<typeof gitHubDirectoryEntrySchema>
-// export type GitHubFileEntry = z.infer<typeof gitHubFileEntrySchema>
-// export type GitHubOtherEntry = z.infer<typeof gitHubOtherEntrySchema>
-// export type GitHubCommitSummary = z.infer<typeof gitHubCommitSummarySchema>
-// export type GitHubPullRequestRef = z.infer<typeof gitHubPullRequestRefSchema>
-// export type SnowflakeQueryRow = Record<string, unknown>
-// export type LinearIssueAssignee = z.infer<typeof linearIssueAssigneeSchema>
-// export type LinearIssueTeam = z.infer<typeof linearIssueTeamSchema>
-// export type LinearIssueProject = z.infer<typeof linearIssueProjectSchema>
-// export type LinearIssueSummary = z.infer<typeof linearIssueSummarySchema>
-// export type LinearIssueDetail = z.infer<typeof linearIssueDetailSchema>
-// export type LinearIssueHandle = z.infer<typeof linearIssueHandleSchema>
-// export type LinearCommentHandle = z.infer<typeof linearCommentHandleSchema>
-// export type LinearStateSummary = z.infer<typeof linearStateSummarySchema>
-// export type LinearLabelSummary = z.infer<typeof linearLabelSummarySchema>
-// export type LinearProjectSummary = z.infer<typeof linearProjectSummarySchema>
-// export type LinearUserSummary = z.infer<typeof linearUserSummarySchema>
-// export type LinearSearchPagination = z.infer<typeof linearSearchPaginationSchema>
-// export type JiraIssueState = z.infer<typeof jiraIssueStateSchema>
-// export type JiraIssueAssignee = z.infer<typeof jiraIssueAssigneeSchema>
-// export type JiraIssueProjectRef = z.infer<typeof jiraIssueProjectRefSchema>
-// export type JiraIssueTypeRef = z.infer<typeof jiraIssueTypeRefSchema>
-// export type JiraRichDescription = z.infer<typeof jiraRichDescriptionSchema>
-// export type JiraIssueSummary = z.infer<typeof jiraIssueSummarySchema>
-// export type GmailSendSummary = z.infer<typeof gmailSendSummarySchema>
-// export type GmailDraftSummary = z.infer<typeof gmailDraftSummarySchema>
-// export type NotionUserReference = z.infer<typeof notionUserReferenceSchema>
-// export type NotionFileReference = z.infer<typeof notionFileReferenceSchema>
-// export type NotionDateReference = z.infer<typeof notionDateReferenceSchema>
-// export type NotionReadablePropertyValue = z.infer<typeof notionReadablePropertyValueSchema>
-// export type NotionPageBlock = z.infer<typeof notionPageBlockSchema>
-// export type NotionPageParent = z.infer<typeof notionPageParentSchema>
-// export type NotionPageQueryMetadata = z.infer<typeof notionPageQueryMetadataSchema>
-// export type NotionDatabaseRowMutationResult = z.infer<typeof notionDatabaseRowMutationResultSchema>
-// export type NotionSchemaProperty = z.infer<typeof notionSchemaPropertySchema>
-// export type NotionDatabaseQueryPage = z.infer<typeof notionDatabaseQueryPageSchema>
-// export type NotionQueryDatabaseFailure = z.infer<typeof notionQueryDatabaseFailureSchema>
-// export type NotionQueryDatabaseSuccess = z.infer<typeof notionQueryDatabaseSuccessSchema>
-// export type NotionModifyBlocksAppendResult = z.infer<typeof notionModifyBlocksAppendResultSchema>
-// export type NotionModifyBlocksUpdateResult = z.infer<typeof notionModifyBlocksUpdateResultSchema>
-// export type NotionModifyBlocksDeleteResult = z.infer<typeof notionModifyBlocksDeleteResultSchema>
-// export type NotionModifyBlocksOperationResult = z.infer<typeof notionModifyBlocksOperationResultSchema>
-// export type NotionModifyBlocksSuccess = z.infer<typeof notionModifyBlocksSuccessSchema>
-// export type NotionModifyBlocksFailure = z.infer<typeof notionModifyBlocksFailureSchema>
-// export type NotionWorkspaceUser = z.infer<typeof notionWorkspaceUserSchema>
-// export type ConfluencePageSpace = z.infer<typeof confluencePageSpaceSchema>
-// export type ConfluencePageVersionAuthor = z.infer<typeof confluencePageVersionAuthorSchema>
-// export type ConfluencePageVersion = z.infer<typeof confluencePageVersionSchema>
-// export type ConfluenceBodyRepresentation = z.infer<typeof confluenceBodyRepresentationSchema>
-// export type ConfluenceBodyContent = z.infer<typeof confluenceBodyContentSchema>
-// export type ConfluencePageRelation = z.infer<typeof confluencePageRelationSchema>
-// export type ConfluencePageQueryResult = z.infer<typeof confluencePageQueryResultSchema>
-// export type ConfluenceCommentPosition = z.infer<typeof confluenceCommentPositionSchema>
-// export type PosthogSessionSummary = z.infer<typeof posthogSessionSummarySchema>
-// export type PosthogSearchSessionsPagination = z.infer<typeof posthogSearchSessionsPaginationSchema>
-// export type PosthogSearchSessionsFound = z.infer<typeof posthogSearchSessionsFoundSchema>
-// export type PosthogSearchSessionsNotFound = z.infer<typeof posthogSearchSessionsNotFoundSchema>
-// export type PosthogLogEntry = z.infer<typeof posthogLogEntrySchema>
-// export type PosthogOffsetPagination = z.infer<typeof posthogOffsetPaginationSchema>
-// export type PosthogEventCount = z.infer<typeof posthogEventCountSchema>
-// export type PosthogEventSummary = z.infer<typeof posthogEventSummarySchema>
-// export type PosthogSessionEvent = z.infer<typeof posthogSessionEventSchema>
-// export type PosthogSessionConsoleLog = z.infer<typeof posthogSessionConsoleLogSchema>
-// export type PosthogSessionEventsSummary = z.infer<typeof posthogSessionEventsSummarySchema>
-// export type LaunchDarklyFlagSummary = z.infer<typeof launchDarklyFlagSummarySchema>
-// export type LaunchDarklyFlagMetadata = z.infer<typeof launchDarklyFlagMetadataSchema>
-// export type LaunchDarklyEnvironmentConfig = z.infer<typeof launchDarklyEnvironmentConfigSchema>
-// export type LaunchDarklyHistoryEntry = z.infer<typeof launchDarklyHistoryEntrySchema>
-// export type LaunchDarklyHistoryResult = z.infer<typeof launchDarklyHistoryResultSchema>
-// export type DatadogLogEntry = z.infer<typeof datadogLogEntrySchema>
-// export type DatadogCursorPagination = z.infer<typeof datadogCursorPaginationSchema>
-// export type DatadogRumSessionDetails = z.infer<typeof datadogRumSessionDetailsSchema>
-// export type DatadogRumViewDetails = z.infer<typeof datadogRumViewDetailsSchema>
-// export type DatadogRumActionDetails = z.infer<typeof datadogRumActionDetailsSchema>
-// export type DatadogRumErrorDetails = z.infer<typeof datadogRumErrorDetailsSchema>
-// export type DatadogRumResourceDetails = z.infer<typeof datadogRumResourceDetailsSchema>
-// export type DatadogRumLongTaskDetails = z.infer<typeof datadogRumLongTaskDetailsSchema>
-// export type DatadogRumEvent = z.infer<typeof datadogRumEventSchema>
-// export type DatadogAggregationBucketCompute = z.infer<typeof datadogAggregationBucketComputeSchema>
-// export type DatadogAggregationBucket = z.infer<typeof datadogAggregationBucketSchema>
-// export type DatadogAggregationMeta = z.infer<typeof datadogAggregationMetaSchema>
-// export type WorkOSUserSummary = z.infer<typeof workOSUserSummarySchema>
-// export type WorkOSOrganizationSummary = z.infer<typeof workOSOrganizationSummarySchema>
-// export type WorkOSPagination = z.infer<typeof workOSPaginationSchema>
-// // TO DO manually define schemas here
-// export type WebSearchResultItem = z.infer<typeof webSearchResultItemSchema>
-// export type WebSearchOutput = z.infer<typeof webSearchOutputSchema>
-// export type WebExtractResultItem = z.infer<typeof webExtractResultItemSchema>
-// export type WebExtractOutput = z.infer<typeof webExtractOutputSchema>
-// export type WebResearchSource = z.infer<typeof webResearchSourceSchema>
-// export type WebResearchOutput = z.infer<typeof webResearchOutputSchema>
-// export type ImageEditSnippet = z.infer<typeof imageEditSnippetSchema>
-// export type ImageEditOutput = z.infer<typeof imageEditOutputSchema>
+export const figmaEventTypesSchema = z.enum(FigmaEventTypes);
+export const figmaWebhookUserSchema = z.object({
+    id: z.string(),
+    handle: z.string(),
+    email: z.string(),
+    img_url: z.string()
+});
+export const figmaCommentImageUrlsSchema = z.object({
+    nodeImage: z.string().optional(),
+    fullFrame: z.string().optional()
+});
+export const figmaVectorDataSchema = pointSchema;
+export const figmaFrameOffsetDataSchema = z.object({
+    node_id: z.string(),
+    node_offset: pointSchema
+});
+export const figmaRegionDataSchema = z.object({
+    x: z.number(),
+    y: z.number(),
+    width: z.number(),
+    height: z.number()
+});
+export const figmaFrameOffsetRegionDataSchema = z.object({
+    node_id: z.string(),
+    node_offset: pointSchema,
+    x: z.number(),
+    y: z.number(),
+    width: z.number(),
+    height: z.number()
+});
+export const figmaVectorPositioningSchema = z.object({ type: z.literal("Vector"), data: figmaVectorDataSchema });
+export const figmaFrameOffsetPositioningSchema = z.object({ type: z.literal("FrameOffset"), data: figmaFrameOffsetDataSchema });
+export const figmaRegionPositioningSchema = z.object({ type: z.literal("Region"), data: figmaRegionDataSchema });
+export const figmaFrameOffsetRegionPositioningSchema = z.object({ type: z.literal("FrameOffsetRegion"), data: figmaFrameOffsetRegionDataSchema });
+export const figmaPositioningDataSchema = z.discriminatedUnion("type", [
+    figmaVectorPositioningSchema,
+    figmaFrameOffsetPositioningSchema,
+    figmaRegionPositioningSchema,
+    figmaFrameOffsetRegionPositioningSchema
+]);
+export const figmaClientMetaSchema = z.object({
+    x: z.number(),
+    y: z.number(),
+    width: z.number(),
+    height: z.number(),
+    node_id: z.string(),
+    node_offset: pointSchema
+});
+export const figmaWebhookCommentSchema = z.object({
+    id: z.string(),
+    message: z.string(),
+    client_meta: figmaClientMetaSchema,
+    user: figmaWebhookUserSchema,
+    created_at: z.string(),
+    resolved_at: z.string().nullable()
+});
+export const figmaApiCommentSchema = z.object({
+    id: z.string(),
+    message: z.string(),
+    client_meta: figmaClientMetaSchema.nullable(),
+    user: figmaWebhookUserSchema,
+    created_at: z.string(),
+    resolved_at: z.string().nullable(),
+    parent_id: z.string().nullable().optional(),
+    order_id: z.string().optional(),
+    mentions: z.array(z.unknown()).optional(),
+    reactions: z.array(z.unknown()).optional()
+});
+export const figmaCommentThreadEntrySchema = z.object({
+    id: z.string(),
+    message: z.string(),
+    author: figmaWebhookUserSchema,
+    createdAt: z.string(),
+    resolvedAt: z.string().nullable(),
+    parentId: z.string().nullable(),
+    orderId: z.string().optional(),
+    isRoot: z.boolean().optional()
+});
+export const figmaFileMetadataSchema = z
+    .object({
+    name: z.string().optional(),
+    folder_name: z.string().optional(),
+    url: z.string().optional()
+})
+    .passthrough();
+export const figmaCommentEventDataSchema = z.object({
+    integrationId: z.string(),
+    commentId: z.string(),
+    fileKey: z.string(),
+    fileUrl: z.string(),
+    nodeId: z.string().optional(),
+    message: z.string(),
+    author: figmaWebhookUserSchema,
+    createdAt: z.string(),
+    resolved: z.boolean().optional(),
+    thread: z.array(figmaCommentThreadEntrySchema).optional(),
+    fileMetadata: figmaFileMetadataSchema.optional(),
+    positioningData: figmaPositioningDataSchema.optional(),
+    matchedNodeIds: z.array(z.string()).optional(),
+    imageUrls: figmaCommentImageUrlsSchema.optional()
+});
+export const apiTokenSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    tokenPrefix: z.string(),
+    createdAt: z.string(),
+    lastUsedAt: z.string().nullable()
+});
+export const apiTokenCreateResponseSchema = z.object({
+    token: apiTokenSchema,
+    rawToken: z.string()
+});
+export const deviceTokenExchangeUserSchema = z.object({
+    email: z.string(),
+    firstName: z.string().nullable(),
+    displayName: z.string().nullable()
+});
+export const deviceTokenExchangeResponseSchema = z.object({
+    apiKey: z.string(),
+    user: deviceTokenExchangeUserSchema
+});
+const configInstanceDataSchema = configDataSchema;
+export const triggerMetadataSchema = z.object({
+    webhookUrl: z.string().optional()
+});
+export const agentTriggerSchema = z.object({
+    id: z.string(),
+    config: configInstanceDataSchema,
+    metadata: triggerMetadataSchema.optional()
+});
+export const agentOutputSchema = z.object({
+    id: z.string(),
+    config: configInstanceDataSchema
+});
+export const agentPromptSchema = z.object({
+    text: z.string()
+});
+export const transientAgentTriggerSchema = z.object({
+    id: z.string(),
+    config: configInstanceDataSchema.optional(),
+    configType: configTypeEnum
+});
+export const transientAgentOutputSchema = z.object({
+    id: z.string(),
+    config: configInstanceDataSchema.optional(),
+    configType: configTypeEnum
+});
+export const templateConfigRefSchema = z.object({
+    configType: configTypeEnum,
+    integrationType: integrationTypeEnum
+});
+export const templateTriggerSchema = z.object({
+    config: templateConfigRefSchema
+});
+export const templateOutputSchema = z.object({
+    config: templateConfigRefSchema
+});
+export const templateCategorySchema = z.enum(["ship", "users", "sync", "track"]);
+export const agentTemplateSchema = z.object({
+    id: z.string(),
+    category: templateCategorySchema,
+    name: z.string(),
+    description: z.string(),
+    chatPrompt: z.string(),
+    prompt: agentPromptSchema,
+    triggers: z.array(templateTriggerSchema),
+    outputs: z.array(templateOutputSchema),
+    requireApproval: z.boolean(),
+    isActive: z.boolean()
+});
+const runHistoryActionTypeSchema = z.enum(RUN_HISTORY_ACTION_TYPES);
+const runHistoryStatusSchema = z.enum(RunHistoryStatus);
+const runHistoryTriggerSchema = z.object({
+    event: z.string(),
+    integration: integrationTypeEnum,
+    source: z.string(),
+    title: z.string().optional(),
+    subheader: z.string().optional(),
+    url: z.string().optional()
+});
+const runHistoryDecisionSchema = z.object({
+    action: z.enum(["processed", "skipped"]),
+    reasoning: z.string()
+});
+const runHistoryRecordSchema = z.object({
+    id: z.string(),
+    agentId: z.string(),
+    timestamp: z.string(),
+    trigger: runHistoryTriggerSchema,
+    filtered: z.boolean(),
+    decision: runHistoryDecisionSchema,
+    actions: z.array(runHistoryActionBaseSchema).optional(),
+    status: runHistoryStatusSchema,
+    isManuallyTriggered: z.boolean()
+});
+const runHistoryRecordWithAgentSchema = runHistoryRecordSchema.extend({
+    agentName: z.string()
+});
+export const agentNotificationSettingsSchema = z.object({
+    enabled: z.boolean(),
+    actionTypes: z.array(runHistoryActionTypeSchema)
+});
+export const agentSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    isActive: z.boolean(),
+    requireApproval: z.boolean(),
+    prompt: agentPromptSchema,
+    triggers: z.array(agentTriggerSchema),
+    outputs: z.array(agentOutputSchema),
+    createdByUserId: z.string(),
+    notificationSettings: agentNotificationSettingsSchema.nullable(),
+    toolApprovals: z.array(z.string()).nullable(),
+    updatedAt: z.string().nullable(),
+    source: z.enum(["WEB_UI", "SDK"]).nullable()
+});
+export const agentUpdateSchema = z.object({
+    name: z.string().optional(),
+    triggers: z.array(agentTriggerSchema).optional(),
+    outputs: z.array(agentOutputSchema).optional(),
+    prompt: agentPromptSchema.optional(),
+    isActive: z.boolean().optional(),
+    requireApproval: z.boolean().optional(),
+    notificationSettings: agentNotificationSettingsSchema.nullable().optional(),
+    toolApprovals: z.array(z.string()).nullable().optional()
+});
+export const agentCreateSchema = agentSchema.omit({
+    id: true,
+    createdByUserId: true,
+    source: true,
+    updatedAt: true
+});
+export const agentDraftSchema = agentCreateSchema.extend({
+    id: z.string().nullable(),
+    createdByUserId: z.string()
+});
+export const paginationSchema = z.object({
+    page: z.number(),
+    limit: z.number(),
+    total: z.number(),
+    totalPages: z.number()
+});
+export const agentsResponseSchema = z.object({
+    agents: z.array(agentSchema),
+    pagination: paginationSchema
+});
+export const recentAgentSchema = agentSchema.extend({
+    updatedAt: z.string(),
+    lastEventProcessedAt: z.string().nullable()
+});
+export const agentImprovementStatusSchema = z.enum(["PENDING", "APPLIED", "DISMISSED"]);
+export const agentImprovementTargetAreaSchema = z.enum(["prompt", "trigger_config", "output_config", "general", "code"]);
+export const agentReviewSchema = z.object({
+    id: z.string(),
+    automationId: z.string(),
+    title: z.string(),
+    summary: z.string(),
+    runsAnalyzed: z.number().int(),
+    reviewPeriodStart: z.string(),
+    reviewPeriodEnd: z.string(),
+    createdAt: z.string()
+});
+export const agentImprovementSchema = z.object({
+    id: z.string(),
+    reviewId: z.string(),
+    automationId: z.string(),
+    title: z.string(),
+    description: z.string(),
+    targetArea: agentImprovementTargetAreaSchema,
+    confidence: z.number(),
+    status: agentImprovementStatusSchema,
+    suggestedPatch: z.string().optional(),
+    appliedPrompt: z.string().optional(),
+    appliedAt: z.string().optional(),
+    dismissedAt: z.string().optional(),
+    createdAt: z.string(),
+    updatedAt: z.string()
+});
+export const getAgentImprovementsResponseSchema = z.object({
+    review: agentReviewSchema.nullable(),
+    improvements: z.array(agentImprovementSchema),
+    improvementsEnabled: z.boolean()
+});
+export const applyImprovementResponseSchema = z.object({
+    success: z.boolean(),
+    appliedPrompt: z.string()
+});
+export const dismissImprovementResponseSchema = z.object({
+    success: z.boolean()
+});
+export const toggleImprovementsEnabledResponseSchema = z.object({
+    success: z.boolean(),
+    improvementsEnabled: z.boolean()
+});
+export const repositorySchema = z.object({
+    name: z.string(),
+    owner: z.string(),
+    id: z.number().int()
+});
+export const githubAppInstallationCallbackRequestSchema = z.object({
+    name: z.string(),
+    email: z.string(),
+    username: z.string(),
+    installationId: z.number().int(),
+    accountName: z.string().nullable(),
+    repositories: z.array(repositorySchema)
+});
+export const getGithubRepositoriesForIntegrationRequestSchema = z.object({});
+export const getGithubRepositoriesForIntegrationResponseSchema = z.object({
+    repositories: z.array(repositorySchema)
+});
+export const oauthInstallationDetailsSchema = z.object({
+    oauthUrl: z.string()
+});
+export const formFieldTypeSchema = z.enum(["text", "password", "textarea"]);
+export const formFieldDefinitionSchema = z.object({
+    name: z.string(),
+    type: formFieldTypeSchema,
+    label: z.string(),
+    placeholder: z.string().optional(),
+    required: z.boolean().optional(),
+    hint: z.string().optional()
+});
+export const configurationFieldTypeSchema = z.enum(["radio", "select"]);
+export const configurationOptionSchema = z.object({
+    label: z.string(),
+    value: z.string()
+});
+export const configurationFieldDefinitionSchema = z.object({
+    name: z.string(),
+    type: configurationFieldTypeSchema,
+    label: z.string(),
+    options: z.array(configurationOptionSchema),
+    required: z.boolean().optional(),
+    hint: z.string().optional()
+});
+export const integrationFieldsResponseSchema = z.object({
+    installationType: z.enum(["form", "oauth"]),
+    fields: z.union([z.array(formFieldDefinitionSchema), z.array(configurationFieldDefinitionSchema)])
+});
+export const statsIntervalSchema = z.enum(["1h", "24h", "7d", "1mo", "3mo", "1y"]);
+export const dailyEventCountSchema = z.object({
+    date: z.string(),
+    events: z.number().int()
+});
+export const recentActionSchema = z.object({
+    action: z.string(),
+    integration: integrationTypeEnum,
+    target: z.string(),
+    details: z.string(),
+    url: z.string().optional(),
+    timestamp: z.string(),
+    agentName: z.string(),
+    type: runHistoryActionTypeSchema
+});
+export const agentActivityItemSchema = z.object({
+    agentId: z.string(),
+    agentName: z.string(),
+    runCount: z.number().int()
+});
+export const countByStringSchema = z.object({
+    label: z.string(),
+    count: z.number().int()
+});
+export const statsResponseSchema = z.object({
+    totalEventsProcessed: z.number(),
+    totalEventsProcessedChange: z.string(),
+    actionsTaken: z.number(),
+    actionsTakenChange: z.string(),
+    numberOfAgents: z.number(),
+    numberOfAgentsChange: z.string(),
+    dailyEvents: z.array(dailyEventCountSchema),
+    recentActions: z.array(recentActionSchema),
+    recentRuns: z.array(runHistoryRecordWithAgentSchema),
+    timezone: z.string(),
+    agentActivity: z.array(agentActivityItemSchema),
+    statusBreakdown: z.array(countByStringSchema),
+    triggerIntegrations: z.array(countByStringSchema),
+    actionIntegrations: z.array(countByStringSchema),
+    actionTypes: z.array(countByStringSchema)
+});
+export const triggerPayloadSchema = z.object({
+    integrationId: z.string(),
+    integrationType: integrationTypeEnum,
+    config: configDataSchema
+});
+export const serializedEventSchema = z.object({
+    integrationType: integrationTypeEnum,
+    eventType: z.string().optional(),
+    formattedContent: z.string(),
+    debugLog: z.string(),
+    metadata: unknownRecordSchema.optional()
+});
+export const sdkAgentRunEventPayloadSchema = z.object({
+    integrationType: integrationTypeEnum,
+    formattedContent: z.string(),
+    debugLog: z.string()
+});
+export const partialSdkAgentRunEventPayloadSchema = sdkAgentRunEventPayloadSchema.partial();
+export const sdkAgentRunOptionsPayloadSchema = z.object({
+    maxTurns: z.number().int().optional(),
+    requireApproval: z.boolean().optional()
+});
+export const sdkAgentRunRequestBodySchema = z.object({
+    prompt: z.string().optional(),
+    event: partialSdkAgentRunEventPayloadSchema.optional(),
+    skills: z.array(configDataSchema).optional(),
+    options: sdkAgentRunOptionsPayloadSchema.optional(),
+    toolApprovals: z.array(z.string()).optional()
+});
+export const sdkAgentRunResponseContractSchema = z.object({
+    responseMode: z.literal("streaming"),
+    supportsInterruptions: z.boolean()
+});
+export const sdkAgentRunNormalizedRequestOptionsSchema = z.object({
+    maxTurns: z.number().int(),
+    requireApproval: z.boolean()
+});
+export const sdkAgentRunNormalizedRequestSchema = z.object({
+    prompt: z.string(),
+    event: sdkAgentRunEventPayloadSchema,
+    skills: z.array(configDataSchema),
+    toolApprovals: z.array(z.string()),
+    options: sdkAgentRunNormalizedRequestOptionsSchema
+});
+export const sdkAgentRunResponseBodySchema = z.object({
+    success: z.boolean(),
+    error: z.string().optional(),
+    details: z.array(z.string()).optional(),
+    contract: sdkAgentRunResponseContractSchema.optional(),
+    normalizedRequest: sdkAgentRunNormalizedRequestSchema.optional()
+});
+export const toolApprovalRequestedPayloadSchema = z.object({
+    stepId: z.string(),
+    toolName: z.string(),
+    arguments: z.string()
+});
+export const sdkAgentStreamEventSchema = z.discriminatedUnion("type", [
+    z.object({ type: z.literal("run_started"), runId: z.string() }),
+    z.object({ type: z.literal("text"), text: z.string() }),
+    z.object({ type: z.literal("final_output"), finalOutput: z.string() }),
+    z.object({ type: z.literal("tool_call_params"), toolCallParams: z.string() }),
+    z.object({ type: z.literal("tool_call_started"), toolCallStarted: z.string() }),
+    z.object({ type: z.literal("tool_call_completed"), toolCallCompleted: z.string() }),
+    z.object({
+        type: z.literal("tool_approval_requested"),
+        toolApprovalRequested: toolApprovalRequestedPayloadSchema
+    }),
+    z.object({ type: z.literal("action"), action: runHistoryActionBaseSchema }),
+    z.object({ type: z.literal("error"), message: z.string() }),
+    z.object({ type: z.literal("done") })
+]);
+export const sdkApprovalDecisionRequestBodySchema = z.object({
+    runId: z.string(),
+    stepId: z.string(),
+    approved: z.boolean()
+});
+export const sdkDeployJobSchema = z.object({
+    jobName: z.string(),
+    triggers: z.array(configDataSchema),
+    outputs: z.array(configDataSchema),
+    toolApprovals: z.array(z.string()),
+    webhookURL: z.string().optional()
+});
+export const sdkDeployRequestBodySchema = z.object({
+    jobs: z.array(sdkDeployJobSchema),
+    sourceZipBase64: z.string()
+});
+export const sdkDeployResultSchema = z.object({
+    jobName: z.string(),
+    automationId: z.string(),
+    isUpdate: z.boolean(),
+    triggers: z
+        .array(z.object({
+        id: z.string(),
+        metadata: triggerMetadataSchema.optional()
+    }))
+        .optional()
+});
+export const sdkDeployRemovedSchema = z.object({
+    id: z.string(),
+    name: z.string()
+});
+export const sdkDeployResponseBodySchema = z.object({
+    success: z.boolean(),
+    results: z.array(sdkDeployResultSchema),
+    removed: z.array(sdkDeployRemovedSchema),
+    error: z.string().optional(),
+    details: z.string().optional()
+});
+// ─── Request / param schemas ─────────────────────────────────────────
+export const agentIdParamsSchema = z.object({
+    agentId: z.string()
+});
+export const agentAndImprovementParamsSchema = z.object({
+    agentId: z.string(),
+    id: z.string()
+});
+export const manualTriggerParamsSchema = z.object({
+    inputId: z.string()
+});
+export const triggerWithEventParamsSchema = z.object({
+    automationId: z.string()
+});
+export const logoUploadUrlQuerySchema = z.object({
+    contentType: z.string()
+});
+export const logoParamsSchema = z.object({
+    organizationId: z.string()
+});
+export const webhookWorkOSTriggerParamsSchema = z.object({
+    integrationId: z.string()
+});
+export const organizationCreateRequestSchema = z.object({
+    name: z.string(),
+    firstName: z.string().optional(),
+    lastName: z.string().optional()
+});
+export const organizationSwitchRequestSchema = z.object({
+    organizationId: z.string()
+});
+export const organizationUpdateRequestSchema = z.object({
+    name: z.string()
+});
+export const apiTokenCreateRequestSchema = z.object({
+    name: z.string().max(100)
+});
+export const apiTokenUpdateRequestSchema = z.object({
+    name: z.string().max(100)
+});
+export const deviceTokenExchangeRequestSchema = z.object({
+    accessToken: z.string()
+});
+export const sdkToolExecuteRequestSchema = z.object({
+    toolName: z.string(),
+    params: z.record(z.string(), z.unknown()).optional()
+});
+export const manualTriggerRequestSchema = z.object({
+    context: z.string().optional()
+});
+export const toggleImprovementsEnabledRequestSchema = z.object({
+    enabled: z.boolean()
+});
+export const workosWebhookSecretUpdateRequestSchema = z.object({
+    webhookSecret: z.string(),
+    state: z.string().optional()
+});
+export const sdkSampleEventsRequestSchema = z.object({
+    triggers: z.array(triggerPayloadSchema).min(1)
+});
+export const triggerWithEventRequestSchema = z.object({
+    event: serializedEventSchema
+});