import {z} from 'zod'

export type LandscapeActionType = 'comment-create' | 'comment-delete' | 'comment-reply-create' | 'comment-reply-delete' | 'comment-reply-update' | 'comment-update' | 'diagram-content-create' | 'diagram-content-delete' | 'diagram-content-update' | 'diagram-content-view' | 'diagram-create' | 'diagram-delete' | 'diagram-export' | 'diagram-group-create' | 'diagram-group-delete' | 'diagram-group-update' | 'diagram-update' | 'domain-create' | 'domain-delete' | 'domain-update' | 'draft-create' | 'draft-delete' | 'draft-merge' | 'draft-task-create' | 'draft-update' | 'draft-view' | 'flow-create' | 'flow-delete' | 'flow-update' | 'flow-view' | 'landscape-copy' | 'landscape-create' | 'landscape-delete' | 'landscape-duplicate' | 'landscape-export' | 'landscape-import' | 'landscape-update' | 'model-connection-create' | 'model-connection-delete' | 'model-connection-update' | 'model-connections-export' | 'model-object-create' | 'model-object-delete' | 'model-object-dependencies-export' | 'model-object-update' | 'model-objects-export' | 'share-link-create' | 'share-link-delete' | 'share-link-update' | 'tag-create' | 'tag-delete' | 'tag-group-create' | 'tag-group-delete' | 'tag-group-update' | 'tag-update' | 'version-create' | 'version-delete' | 'version-revert-create';

export type ActionLogFilterActionType = LandscapeActionType | Array<LandscapeActionType> | {$not?: (LandscapeActionType | Array<LandscapeActionType>) | undefined};

export type AuthType = 'user' | 'api-key' | 'notification-key' | 'service';

export type ActionLogFilter = {actionId?: string | undefined, actionType?: ActionLogFilterActionType | undefined, endAtDate?: string | undefined, endAtId?: string | undefined, endBeforeDate?: string | undefined, endBeforeId?: string | undefined, includeActionsInContext?: boolean | undefined, performedBy?: (AuthType | Array<AuthType>) | undefined, performedById?: (string | Array<string>) | undefined, startAfterDate?: string | undefined, startAfterId?: string | undefined, startAtDate?: string | undefined, startAtId?: string | undefined};

export type SortDirection = 'asc' | 'desc';

export type GetApiLandscapesLandscapeIdActionLogsActionLogIdChildrenArgs = {landscapeId: string, actionLogId: string, filter?: ActionLogFilter | undefined, cursor?: string | undefined, limit?: number | undefined, order?: SortDirection | undefined};

export type GetApiLandscapesLandscapeIdActionLogsActionLogIdChildrenOptions = {baseUrl?: string | undefined, ApiKeyAuth?: string | undefined, fetch?: typeof fetch | undefined};

export const permissionType = z.enum(["billing", "read", "write", "admin"]);

export const apiKeyRequired = z.object({name: z.string().max(4000), permission: permissionType});

export const actionApiKeyCreate = z.object({id: z.string(), props: apiKeyRequired, type: z.literal("api-key-create")});

export const actionApiKeyContext = z.object({name: z.string()});

export const apiKeyPartial = z.object({name: z.string().max(4000).optional(), permission: permissionType.optional()});

export const actionApiKeyUpdate = z.object({context: actionApiKeyContext, id: z.string(), props: apiKeyPartial, type: z.literal("api-key-update")});

export const actionApiKeyDelete = z.object({context: actionApiKeyContext, id: z.string(), type: z.literal("api-key-delete")});

export const actionApiKey = z.union([actionApiKeyCreate, actionApiKeyUpdate, actionApiKeyDelete]);

export const actionOAuthConsentDenyProps = z.object({clientName: z.string()});

export const actionOAuthConsentDeny = z.object({id: z.string(), props: actionOAuthConsentDenyProps, type: z.literal("oauth-consent-deny")});

export const actionOAuthConsentGrantProps = z.object({clientName: z.string(), landscapeId: z.string()});

export const actionOAuthConsentGrant = z.object({id: z.string(), props: actionOAuthConsentGrantProps, type: z.literal("oauth-consent-grant")});

export const actionOAuth = z.union([actionOAuthConsentDeny, actionOAuthConsentGrant]);

export const actionOrganizationCreateContext = z.object({name: z.string()});

export const organizationAIFeatures = z.object({generateDetailedDescriptions: z.boolean().optional(), generateDisplayDescriptions: z.boolean().optional(), generateDraftSummary: z.boolean().optional(), generateObjectSummary: z.boolean().optional()});

export const organizationAiModel = z.enum(["gpt-5", "gpt-5-mini", "gpt-5-nano"]);

export const organizationBillingCurrency = z.enum(["usd", "cad", "eur", "gbp"]);

export const organizationBillingCycle = z.enum(["monthly", "annually"]);

export const organizationLanguage = z.enum(["en-US", "en-GB", "fr-FR", "es-ES", "es-419"]);

export const lineShape = z.enum(["curved", "square", "straight"]);

export const organizationRequired = z.object({aiFeatures: organizationAIFeatures.optional(), aiFeaturesEnabled: z.boolean().optional(), aiModel: organizationAiModel.optional(), billingCurrency: organizationBillingCurrency.optional(), billingCycle: organizationBillingCycle.optional(), billingEmail: z.string().optional(), experiments: z.record(z.string(), z.boolean()).optional(), language: organizationLanguage.optional(), lineShapeDefault: lineShape.optional(), name: z.string().max(4000), oauthLandscapeWriteEnabled: z.boolean().optional(), shareLinkAuthDomains: z.array(z.string()).nullable().optional(), shareLinksEnabled: z.boolean().optional()});

export const actionOrganizationCreate = z.object({context: actionOrganizationCreateContext, id: z.string(), props: organizationRequired, type: z.literal("organization-create")});

export const actionOrganizationUpdateContext = z.object({name: z.string()});

export const organizationPartial = z.object({aiFeatures: organizationAIFeatures.optional(), aiFeaturesEnabled: z.boolean().optional(), aiModel: organizationAiModel.optional(), billingCurrency: organizationBillingCurrency.optional(), billingCycle: organizationBillingCycle.optional(), billingEmail: z.string().optional(), experiments: z.record(z.string(), z.boolean()).optional(), language: organizationLanguage.optional(), lineShapeDefault: lineShape.optional(), name: z.string().max(4000).optional(), oauthLandscapeWriteEnabled: z.boolean().optional(), shareLinkAuthDomains: z.array(z.string()).nullable().optional(), shareLinksEnabled: z.boolean().optional()});

export const actionOrganizationUpdate = z.object({context: actionOrganizationUpdateContext, id: z.string(), props: organizationPartial, type: z.literal("organization-update")});

export const actionOrganizationDeleteContext = z.object({name: z.string()});

export const actionOrganizationDelete = z.object({context: actionOrganizationDeleteContext, id: z.string(), type: z.literal("organization-delete")});

export const actionOrganization = z.union([actionOrganizationCreate, actionOrganizationUpdate, actionOrganizationDelete]);

export const actionOrganizationUserAddContext = z.object({email: z.string(), landscapeNames: z.record(z.string(), z.string()).optional(), name: z.string().optional()});

export const organizationUser = z.object({landscapePermissions: z.record(z.string(), z.boolean()).optional(), permission: permissionType});

export const actionOrganizationUserAdd = z.object({context: actionOrganizationUserAddContext, id: z.string(), props: organizationUser, type: z.literal("organization-user-add")});

export const actionOrganizationUserUpdateContext = z.object({email: z.string(), landscapeNames: z.record(z.string(), z.string()).optional(), name: z.string().optional()});

export const actionOrganizationUserUpdate = z.object({context: actionOrganizationUserUpdateContext, id: z.string(), props: organizationUser, type: z.literal("organization-user-update")});

export const actionOrganizationUserRemoveContext = z.object({email: z.string(), landscapeNames: z.record(z.string(), z.string()).optional(), landscapePermissions: z.record(z.string(), z.boolean()).optional(), name: z.string().optional(), permission: permissionType});

export const actionOrganizationUserRemove = z.object({context: actionOrganizationUserRemoveContext, id: z.string(), type: z.literal("organization-user-remove")});

export const actionOrganizationUser = z.union([actionOrganizationUserAdd, actionOrganizationUserUpdate, actionOrganizationUserRemove]);

export const actionOrganizationUserInviteCreateContext = z.object({landscapeNames: z.record(z.string(), z.string()).optional()});

export const organizationUserInviteRequired = z.object({email: z.string(), expiresAt: z.string(), landscapePermissions: z.record(z.string(), z.boolean()).optional(), permission: permissionType});

export const actionOrganizationUserInviteCreate = z.object({context: actionOrganizationUserInviteCreateContext, id: z.string(), props: organizationUserInviteRequired, type: z.literal("organization-user-invite-create")});

export const actionOrganizationUserInviteRevokeContext = z.object({email: z.string(), landscapeNames: z.record(z.string(), z.string()).optional(), permission: permissionType});

export const actionOrganizationUserInviteRevoke = z.object({context: actionOrganizationUserInviteRevokeContext, id: z.string(), type: z.literal("organization-user-invite-revoke")});

export const actionOrganizationUserInvite = z.union([actionOrganizationUserInviteCreate, actionOrganizationUserInviteRevoke]);

export const actionTeamCreateContext = z.object({userNames: z.record(z.string(), z.string()).optional()});

export const tagColor = z.enum(["blue", "green", "yellow", "orange", "red", "beaver", "dark-blue", "purple", "pink", "white", "grey", "black"]);

export const teamRequired = z.object({color: tagColor.optional(), name: z.string().max(4000), userIds: z.array(z.string()).optional()});

export const actionTeamCreate = z.object({context: actionTeamCreateContext, id: z.string(), props: teamRequired, type: z.literal("team-create")});

export const actionTeamUpdateContext = z.object({name: z.string(), userNames: z.record(z.string(), z.string()).optional()});

export const teamPartial = z.object({color: tagColor.optional(), name: z.string().max(4000).optional(), userIds: z.array(z.string()).optional()});

export const actionTeamUpdate = z.object({context: actionTeamUpdateContext, id: z.string(), props: teamPartial, type: z.literal("team-update")});

export const actionTeamDeleteContext = z.object({name: z.string(), userNames: z.record(z.string(), z.string()).optional()});

export const actionTeamDelete = z.object({context: actionTeamDeleteContext, id: z.string(), type: z.literal("team-delete")});

export const actionTeam = z.union([actionTeamCreate, actionTeamUpdate, actionTeamDelete]);

export const actionUserLogin = z.object({id: z.string(), type: z.literal("user-login")});

export const actionUserLoginFailedProps = z.object({code: z.string(), message: z.string()});

export const actionUserLoginFailed = z.object({id: z.string(), props: actionUserLoginFailedProps, type: z.literal("user-login-failed")});

export const actionUserLogout = z.object({id: z.string(), type: z.literal("user-logout")});

export const actionUser = z.union([actionUserLogin, actionUserLoginFailed, actionUserLogout]);

export const organizationAction = z.union([actionApiKey, actionOAuth, actionOrganization, actionOrganizationUser, actionOrganizationUserInvite, actionTeam, actionUser]);

export const modelObjectType = z.enum(["actor", "app", "component", "group", "root", "store", "system"]);

export const actionContextModelObject = z.object({handleId: z.string(), name: z.string(), type: modelObjectType});

export const actionCommentCreateContext = z.object({domainHandleId: z.string().optional(), domainName: z.string().optional(), modelFamily: z.array(actionContextModelObject).optional(), targetHandleId: z.string().optional(), targetName: z.string().optional()});

export const commentBodyQuestion = z.object({content: z.string().max(950000), showContentPreview: z.boolean().optional(), status: z.enum(["open", "resolved"]), type: z.literal("question")});

export const commentBodyInaccuracy = z.object({content: z.string().max(950000), showContentPreview: z.boolean().optional(), status: z.enum(["open", "resolved"]), type: z.literal("inaccurate")});

export const commentBodyIdea = z.object({content: z.string().max(950000), showContentPreview: z.boolean().optional(), status: z.enum(["active", "dismissed"]), type: z.literal("idea")});

export const commentBodyNewQuestion = z.object({content: z.string().max(950000), showContentPreview: z.boolean().optional(), status: z.literal("create"), type: z.literal("new-question")});

export const commentBodyNewInaccuracy = z.object({content: z.string().max(950000), showContentPreview: z.boolean().optional(), status: z.literal("create"), type: z.literal("new-inaccurate")});

export const commentBodyNewIdea = z.object({content: z.string().max(950000), showContentPreview: z.boolean().optional(), status: z.literal("create"), type: z.literal("new-idea")});

export const commentBody = z.union([commentBodyQuestion, commentBodyInaccuracy, commentBodyIdea, commentBodyNewQuestion, commentBodyNewInaccuracy, commentBodyNewIdea]);

export const commentRequired = z.object({body: commentBody, commit: z.number().optional(), mentionedUserIds: z.array(z.string()).optional(), handleId: z.string().optional()});

export const actionCommentCreate = z.object({context: actionCommentCreateContext, id: z.string(), props: commentRequired, type: z.literal("comment-create")});

export const actionCommentUpdateContext = z.object({domainHandleId: z.string().optional(), domainName: z.string().optional(), modelFamily: z.array(actionContextModelObject).optional(), targetHandleId: z.string().optional(), targetName: z.string().optional()});

export const commentPartial = z.object({body: commentBody.optional(), commit: z.number().optional(), mentionedUserIds: z.array(z.string()).optional()});

export const actionCommentUpdate = z.object({context: actionCommentUpdateContext, id: z.string(), props: commentPartial, type: z.literal("comment-update")});

export const actionCommentDeleteContext = z.object({domainHandleId: z.string().optional(), domainName: z.string().optional(), modelFamily: z.array(actionContextModelObject).optional(), targetHandleId: z.string().optional(), targetName: z.string().optional()});

export const actionCommentDelete = z.object({context: actionCommentDeleteContext, id: z.string(), type: z.literal("comment-delete")});

export const actionCommentReplyCreateContext = z.object({commentHandleId: z.string().optional(), domainHandleId: z.string().optional(), domainName: z.string().optional()});

export const commentReplyRequired = z.object({content: z.string().max(950000), mentionedUserIds: z.array(z.string()).optional()});

export const actionCommentReplyCreate = z.object({context: actionCommentReplyCreateContext, id: z.string(), props: commentReplyRequired, type: z.literal("comment-reply-create")});

export const actionCommentReplyUpdateContext = z.object({commentHandleId: z.string().optional(), domainHandleId: z.string().optional(), domainName: z.string().optional()});

export const commentReplyPartial = z.object({content: z.string().max(950000).optional(), mentionedUserIds: z.array(z.string()).optional()});

export const actionCommentReplyUpdate = z.object({context: actionCommentReplyUpdateContext, id: z.string(), props: commentReplyPartial, type: z.literal("comment-reply-update")});

export const actionCommentReplyDeleteContext = z.object({commentHandleId: z.string().optional(), domainHandleId: z.string().optional(), domainName: z.string().optional()});

export const actionCommentReplyDelete = z.object({context: actionCommentReplyDeleteContext, id: z.string(), type: z.literal("comment-reply-delete")});

export const commentBodyType = z.enum(["idea", "inaccurate", "new-idea", "new-inaccurate", "new-question", "question"]);

export const actionDiagramContentContextComment = z.object({commentBodyType: commentBodyType, commentHandleId: z.string()});

export const actionDiagramContentContextConnection = z.object({modelHandleId: z.string().nullable(), modelName: z.string().nullable()});

export const diagramObjectType = z.enum(["actor", "app", "component", "group", "store", "system"]);

export const actionDiagramContentContextObject = z.object({modelHandleId: z.string(), modelName: z.string(), modelType: modelObjectType, type: diagramObjectType});

export const diagramType = z.enum(["app-diagram", "component-diagram", "context-diagram"]);

export const actionDiagramContentCreateContext = z.object({comments: z.record(z.string(), actionDiagramContentContextComment).optional(), connections: z.record(z.string(), actionDiagramContentContextConnection).optional(), domainHandleId: z.string().optional(), domainName: z.string().optional(), groupHandleId: z.string().optional(), groupName: z.string().optional(), modelFamily: z.array(actionContextModelObject).optional(), name: z.string(), objects: z.record(z.string(), actionDiagramContentContextObject).optional(), type: diagramType});

export const diagramComment = z.object({commentId: z.string(), id: z.string(), x: z.number(), y: z.number()});

export const diagramObjectConnector = z.enum(["top-left", "top-center", "top-right", "right-top", "right-middle", "right-bottom", "bottom-right", "bottom-center", "bottom-left", "left-bottom", "left-middle", "left-top"]).nullable();

export const diagramConnectionRequired = z.object({breakpoints: z.array(z.object({x: z.number(), y: z.number()})).optional(), labelPosition: z.number().gte(0).lte(100).optional(), lineShape: lineShape.optional(), modelId: z.string().nullable(), originConnector: diagramObjectConnector.optional(), originId: z.string().nullable(), points: z.array(z.object({x: z.number(), y: z.number()})).optional(), targetConnector: diagramObjectConnector.optional(), targetId: z.string().nullable()});

export const diagramObjectShape = z.enum(["area", "box"]);

export const diagramObjectRequired = z.object({height: z.number().optional(), modelId: z.string(), shape: diagramObjectShape, type: diagramObjectType, width: z.number().optional(), x: z.number(), y: z.number()});

export const diagramContentRequired = z.object({comments: z.record(z.string(), diagramComment).optional(), commit: z.number().optional(), connections: z.record(z.string(), diagramConnectionRequired).optional(), objects: z.record(z.string(), diagramObjectRequired).optional()});

export const actionDiagramContentCreate = z.object({context: actionDiagramContentCreateContext, id: z.string(), props: diagramContentRequired, type: z.literal("diagram-content-create")});

export const actionDiagramContentUpdateContext = z.object({comments: z.record(z.string(), actionDiagramContentContextComment).optional(), connections: z.record(z.string(), actionDiagramContentContextConnection).optional(), domainHandleId: z.string().optional(), domainName: z.string().optional(), groupHandleId: z.string().optional(), groupName: z.string().optional(), modelFamily: z.array(actionContextModelObject).optional(), name: z.string(), objects: z.record(z.string(), actionDiagramContentContextObject).optional(), type: diagramType});

export const diagramCommentPartial = z.object({commentId: z.string().optional(), id: z.string().optional(), x: z.number().optional(), y: z.number().optional()});

export const diagramConnectionPartial = z.object({breakpoints: z.array(z.object({x: z.number(), y: z.number()})).optional(), labelPosition: z.number().gte(0).lte(100).optional(), lineShape: lineShape.optional(), modelId: z.string().nullable().optional(), originConnector: diagramObjectConnector.optional(), originId: z.string().nullable().optional(), points: z.array(z.object({x: z.number(), y: z.number()})).optional(), targetConnector: diagramObjectConnector.optional(), targetId: z.string().nullable().optional()});

export const diagramObjectPartial = z.object({height: z.number().optional(), modelId: z.string().optional(), shape: diagramObjectShape.optional(), type: diagramObjectType.optional(), width: z.number().optional(), x: z.number().optional(), y: z.number().optional()});

export const diagramContentPartial = z.object({comments: z.object({$add: z.record(z.string(), diagramComment).optional(), $remove: z.array(z.string()).optional(), $replace: z.record(z.string(), diagramComment).optional(), $update: z.record(z.string(), diagramCommentPartial).optional()}).optional(), commit: z.number().optional(), connections: z.object({$add: z.record(z.string(), diagramConnectionRequired).optional(), $remove: z.array(z.string()).optional(), $replace: z.record(z.string(), diagramConnectionRequired).optional(), $update: z.record(z.string(), diagramConnectionPartial).optional()}).optional(), objects: z.object({$add: z.record(z.string(), diagramObjectRequired).optional(), $remove: z.array(z.string()).optional(), $replace: z.record(z.string(), diagramObjectRequired).optional(), $update: z.record(z.string(), diagramObjectPartial).optional()}).optional()});

export const actionDiagramContentUpdate = z.object({context: actionDiagramContentUpdateContext, id: z.string(), props: diagramContentPartial, type: z.literal("diagram-content-update")});

export const actionDiagramContentDeleteContext = z.object({domainHandleId: z.string().optional(), domainName: z.string().optional(), modelFamily: z.array(actionContextModelObject).optional(), name: z.string(), type: diagramType});

export const actionDiagramContentDelete = z.object({context: actionDiagramContentDeleteContext, id: z.string(), type: z.literal("diagram-content-delete")});

export const actionDiagramContentViewContext = z.object({domainHandleId: z.string().optional(), domainName: z.string().optional(), modelFamily: z.array(actionContextModelObject).optional(), name: z.string(), type: diagramType});

export const actionDiagramContentView = z.object({context: actionDiagramContentViewContext, id: z.string(), type: z.literal("diagram-content-view")});

export const actionDiagramCreateContext = z.object({domainHandleId: z.string().optional(), domainName: z.string().optional(), groupHandleId: z.string().optional(), groupName: z.string().optional(), modelFamily: z.array(actionContextModelObject).optional()});

export const diagramStatus = z.literal("current");

export const diagramZoomOverridesNullable = z.record(z.string(), z.string());

export const diagramRequired = z.object({commit: z.number().optional(), description: z.string().max(950000).optional(), groupId: z.string().nullable().optional(), index: z.number(), labels: z.record(z.string(), z.string().max(5000)).optional(), modelId: z.string(), name: z.string().max(4000), parentId: z.string().nullable().optional(), pinned: z.boolean().optional(), pinnedAt: z.string().optional(), pinnedIndex: z.number().optional(), status: diagramStatus.optional(), zoomOverrides: diagramZoomOverridesNullable.optional(), handleId: z.string().optional(), type: diagramType});

export const actionDiagramCreate = z.object({context: actionDiagramCreateContext, id: z.string(), props: diagramRequired, type: z.literal("diagram-create")});

export const actionDiagramUpdateContext = z.object({domainHandleId: z.string().optional(), domainName: z.string().optional(), groupHandleId: z.string().optional(), groupName: z.string().optional(), modelFamily: z.array(actionContextModelObject).optional(), name: z.string(), type: diagramType});

export const diagramPartial = z.object({commit: z.number().optional(), description: z.string().max(950000).optional(), groupId: z.string().nullable().optional(), index: z.number().optional(), labels: z.record(z.string(), z.string().max(5000)).optional(), modelId: z.string().optional(), name: z.string().max(4000).optional(), parentId: z.string().nullable().optional(), pinned: z.boolean().optional(), pinnedAt: z.string().optional(), pinnedIndex: z.number().optional(), status: diagramStatus.optional(), zoomOverrides: diagramZoomOverridesNullable.optional()});

export const actionDiagramUpdate = z.object({context: actionDiagramUpdateContext, id: z.string(), props: diagramPartial, type: z.literal("diagram-update")});

export const actionDiagramExportContext = z.object({diagramName: z.string(), diagramType: diagramType, draftHandleId: z.string().optional(), draftName: z.string().optional(), flowHandleId: z.string().optional(), flowName: z.string().optional(), versionName: z.string()});

export const theme = z.enum(["light", "dark"]);

export const diagramExportImageOptions = z.object({draftId: z.string().optional(), flowId: z.string().optional(), flowPathIds: z.array(z.string()).optional(), focusIds: z.array(z.string()).optional(), groupId: z.string().optional(), hideIds: z.array(z.string()).optional(), maxWidth: z.number().int().gte(100).lte(10240).optional(), pinIds: z.array(z.string()).optional(), tab: z.enum(["tags", "technology", "status", "teams"]).optional(), theme: theme.optional()});

export const actionDiagramExportProps = z.object({bucketPath: z.string(), filename: z.string(), options: diagramExportImageOptions.optional(), versionId: z.string()});

export const actionDiagramExport = z.object({context: actionDiagramExportContext, id: z.string(), props: actionDiagramExportProps, type: z.literal("diagram-export")});

export const actionDiagramDeleteContext = z.object({domainHandleId: z.string().optional(), domainName: z.string().optional(), modelFamily: z.array(actionContextModelObject).optional(), name: z.string(), type: diagramType});

export const actionDiagramDelete = z.object({context: actionDiagramDeleteContext, id: z.string(), type: z.literal("diagram-delete")});

export const actionDiagram = z.union([actionDiagramCreate, actionDiagramUpdate, actionDiagramExport, actionDiagramDelete]);

export const actionDiagramGroupCreateContext = z.object({domainHandleId: z.string().optional(), domainName: z.string().optional(), modelFamily: z.array(actionContextModelObject).optional()});

export const diagramGroupRequired = z.object({commit: z.number().optional(), index: z.number().optional(), labels: z.record(z.string(), z.string().max(5000)).optional(), modelId: z.string(), name: z.string().max(4000), handleId: z.string().optional()});

export const actionDiagramGroupCreate = z.object({context: actionDiagramGroupCreateContext, id: z.string(), props: diagramGroupRequired, type: z.literal("diagram-group-create")});

export const actionDiagramGroupUpdateContext = z.object({domainHandleId: z.string().optional(), domainName: z.string().optional(), modelFamily: z.array(actionContextModelObject).optional(), name: z.string()});

export const diagramGroupPartial = z.object({commit: z.number().optional(), index: z.number().optional(), labels: z.record(z.string(), z.string().max(5000)).optional(), modelId: z.string().optional(), name: z.string().max(4000).optional()});

export const actionDiagramGroupUpdate = z.object({context: actionDiagramGroupUpdateContext, id: z.string(), props: diagramGroupPartial, type: z.literal("diagram-group-update")});

export const actionDiagramGroupDeleteContext = z.object({domainHandleId: z.string().optional(), domainName: z.string().optional(), modelFamily: z.array(actionContextModelObject).optional(), name: z.string()});

export const actionDiagramGroupDelete = z.object({context: actionDiagramGroupDeleteContext, id: z.string(), type: z.literal("diagram-group-delete")});

export const domainRequired = z.object({commit: z.number().optional(), index: z.number().optional(), labels: z.record(z.string(), z.string().max(5000)).optional(), name: z.string().max(4000), handleId: z.string().optional()});

export const actionDomainCreate = z.object({id: z.string(), props: domainRequired, type: z.literal("domain-create")});

export const actionDomainUpdateContext = z.object({name: z.string()});

export const domainPartial = z.object({commit: z.number().optional(), index: z.number().optional(), labels: z.record(z.string(), z.string().max(5000)).optional(), name: z.string().max(4000).optional()});

export const actionDomainUpdate = z.object({context: actionDomainUpdateContext, id: z.string(), props: domainPartial, type: z.literal("domain-update")});

export const actionDomainDeleteContext = z.object({name: z.string()});

export const actionDomainDelete = z.object({context: actionDomainDeleteContext, id: z.string(), type: z.literal("domain-delete")});

export const actionDraftCreateContext = z.object({name: z.string(), versionName: z.string().optional()});

export const draftChangeSummary = z.object({createdAt: z.string(), summary: z.string(), updatedAt: z.string()});

export const draftStatus = z.enum(["in-progress", "merged", "archived"]);

export const draftRequired = z.object({changeSummary: draftChangeSummary.optional(), commit: z.number().optional(), handleId: z.string().optional(), labels: z.record(z.string(), z.string().max(5000)).optional(), name: z.string().max(4000), status: draftStatus, summaryDirtiedAt: z.string().optional()});

export const actionDraftCreate = z.object({context: actionDraftCreateContext, id: z.string(), ids: z.array(z.string()).optional(), props: draftRequired, type: z.literal("draft-create")});

export const actionDraftUpdateContext = z.object({name: z.string()});

export const draftPartial = z.object({changeSummary: draftChangeSummary.optional(), commit: z.number().optional(), handleId: z.string().optional(), labels: z.record(z.string(), z.string().max(5000)).optional(), name: z.string().max(4000).optional(), status: draftStatus.optional(), summaryDirtiedAt: z.string().optional()});

export const actionDraftUpdate = z.object({context: actionDraftUpdateContext, id: z.string(), props: draftPartial, type: z.literal("draft-update")});

export const actionDraftViewContext = z.object({name: z.string()});

export const actionDraftView = z.object({context: actionDraftViewContext, id: z.string(), type: z.literal("draft-view")});

export const actionDraftMergeContext = z.object({name: z.string()});

export const actionDraftMerge = z.object({context: actionDraftMergeContext, id: z.string(), type: z.literal("draft-merge")});

export const actionDraftDeleteContext = z.object({name: z.string(), versionName: z.string().optional()});

export const actionDraftDelete = z.object({context: actionDraftDeleteContext, id: z.string(), type: z.literal("draft-delete")});

export const actionDraft = z.union([actionDraftCreate, actionDraftUpdate, actionDraftView, actionDraftMerge, actionDraftDelete]);

export const actionDraftTaskCreateContext = z.object({draftName: z.string()});

export const draftTaskCommentCreateProps = z.object({body: commentBody, commit: z.number().optional(), mentionedUserIds: z.array(z.string()).optional(), handleId: z.string().optional()});

export const draftTaskCommentCreate = z.object({entityId: z.string(), props: draftTaskCommentCreateProps, type: z.literal("draft-comment-create")});

export const draftTaskCommentUpdateProps = z.object({body: commentBody.optional(), commit: z.number().optional(), mentionedUserIds: z.array(z.string()).optional()});

export const draftTaskCommentUpdate = z.object({entityId: z.string(), props: draftTaskCommentUpdateProps, snapshot: draftTaskCommentUpdateProps, type: z.literal("draft-comment-update")});

export const draftTaskCommentDelete = z.object({entityId: z.string(), type: z.literal("draft-comment-delete")});

export const draftTaskCommentReplyCreateProps = z.object({content: z.string().max(950000), mentionedUserIds: z.array(z.string()).optional()});

export const draftTaskCommentReplyCreate = z.object({commentId: z.string(), entityId: z.string(), props: draftTaskCommentReplyCreateProps, type: z.literal("draft-comment-reply-create")});

export const draftTaskCommentReplyUpdateProps = z.object({content: z.string().max(950000).optional(), mentionedUserIds: z.array(z.string()).optional()});

export const draftTaskCommentReplyUpdate = z.object({commentId: z.string(), entityId: z.string(), props: draftTaskCommentReplyUpdateProps, snapshot: draftTaskCommentReplyUpdateProps, type: z.literal("draft-comment-reply-update")});

export const draftTaskCommentReplyDelete = z.object({commentId: z.string(), entityId: z.string(), type: z.literal("draft-comment-reply-delete")});

export const draftTaskDiagramCreateProps = z.object({commit: z.number().optional(), description: z.string().max(950000).optional(), groupId: z.string().nullable().optional(), index: z.number(), labels: z.record(z.string(), z.string().max(5000)).optional(), modelId: z.string(), name: z.string().max(4000), parentId: z.string().nullable().optional(), pinned: z.boolean().optional(), pinnedAt: z.string().optional(), pinnedIndex: z.number().optional(), status: diagramStatus.optional(), zoomOverrides: diagramZoomOverridesNullable.optional(), handleId: z.string().optional(), type: diagramType, comments: z.record(z.string(), diagramComment).optional(), connections: z.record(z.string(), diagramConnectionRequired).optional(), objects: z.record(z.string(), diagramObjectRequired).optional()});

export const draftTaskDiagramCreate = z.object({entityId: z.string(), props: draftTaskDiagramCreateProps, type: z.literal("draft-diagram-create")});

export const draftTaskDiagramUpdateProps = z.object({commit: z.number().optional(), description: z.string().max(950000).optional(), groupId: z.string().nullable().optional(), index: z.number().optional(), labels: z.record(z.string(), z.string().max(5000)).optional(), modelId: z.string().optional(), name: z.string().max(4000).optional(), parentId: z.string().nullable().optional(), pinned: z.boolean().optional(), pinnedAt: z.string().optional(), pinnedIndex: z.number().optional(), status: diagramStatus.optional(), zoomOverrides: diagramZoomOverridesNullable.optional(), comments: z.object({$add: z.record(z.string(), diagramComment).optional(), $remove: z.array(z.string()).optional(), $replace: z.record(z.string(), diagramComment).optional(), $update: z.record(z.string(), diagramCommentPartial).optional()}).optional(), connections: z.object({$add: z.record(z.string(), diagramConnectionRequired).optional(), $remove: z.array(z.string()).optional(), $replace: z.record(z.string(), diagramConnectionRequired).optional(), $update: z.record(z.string(), diagramConnectionPartial).optional()}).optional(), objects: z.object({$add: z.record(z.string(), diagramObjectRequired).optional(), $remove: z.array(z.string()).optional(), $replace: z.record(z.string(), diagramObjectRequired).optional(), $update: z.record(z.string(), diagramObjectPartial).optional()}).optional()});

export const draftTaskDiagramUpdate = z.object({entityId: z.string(), props: draftTaskDiagramUpdateProps, snapshot: draftTaskDiagramUpdateProps, type: z.literal("draft-diagram-update")});

export const draftTaskDiagramDelete = z.object({entityId: z.string(), type: z.literal("draft-diagram-delete")});

export const draftTaskDiagramContentUpdateProps = z.object({comments: z.object({$add: z.record(z.string(), diagramComment).optional(), $remove: z.array(z.string()).optional(), $replace: z.record(z.string(), diagramComment).optional(), $update: z.record(z.string(), diagramCommentPartial).optional()}).optional(), commit: z.number().optional(), connections: z.object({$add: z.record(z.string(), diagramConnectionRequired).optional(), $remove: z.array(z.string()).optional(), $replace: z.record(z.string(), diagramConnectionRequired).optional(), $update: z.record(z.string(), diagramConnectionPartial).optional()}).optional(), objects: z.object({$add: z.record(z.string(), diagramObjectRequired).optional(), $remove: z.array(z.string()).optional(), $replace: z.record(z.string(), diagramObjectRequired).optional(), $update: z.record(z.string(), diagramObjectPartial).optional()}).optional()});

export const draftTaskDiagramContentUpdate = z.object({entityId: z.string(), props: draftTaskDiagramContentUpdateProps, snapshot: draftTaskDiagramContentUpdateProps, type: z.literal("draft-diagram-content-update")});

export const draftTaskDiagramGroupCreateProps = z.object({commit: z.number().optional(), index: z.number().optional(), labels: z.record(z.string(), z.string().max(5000)).optional(), modelId: z.string(), name: z.string().max(4000), handleId: z.string().optional()});

export const draftTaskDiagramGroupCreate = z.object({entityId: z.string(), props: draftTaskDiagramGroupCreateProps, type: z.literal("draft-diagram-group-create")});

export const draftTaskDiagramGroupUpdateProps = z.object({commit: z.number().optional(), index: z.number().optional(), labels: z.record(z.string(), z.string().max(5000)).optional(), modelId: z.string().optional(), name: z.string().max(4000).optional()});

export const draftTaskDiagramGroupUpdate = z.object({entityId: z.string(), props: draftTaskDiagramGroupUpdateProps, snapshot: draftTaskDiagramGroupUpdateProps, type: z.literal("draft-diagram-group-update")});

export const draftTaskDiagramGroupDelete = z.object({entityId: z.string(), type: z.literal("draft-diagram-group-delete")});

export const modelObjectIconNullable = z.object({catalogTechnologyId: z.string(), name: z.string().optional(), url: z.string().optional(), urlDark: z.string().optional(), urlLight: z.string().optional()});

export const realityConnectorUrl = z.object({type: z.literal("url"), url: z.string()});

export const realityConnectorAzureDevopsRepo = z.object({accountName: z.string(), projectId: z.string(), repositoryId: z.string(), type: z.literal("azure-devops-repo")});

export const realityConnectorAzureDevopsBranch = z.object({accountName: z.string(), branchName: z.string(), projectId: z.string(), repositoryId: z.string(), type: z.literal("azure-devops-branch")});

export const realityConnectorAzureDevopsFolder = z.object({accountName: z.string(), branchName: z.string(), path: z.string(), projectId: z.string(), repositoryId: z.string(), type: z.literal("azure-devops-folder")});

export const realityConnectorAzureDevopsFile = z.object({accountName: z.string(), branchName: z.string(), path: z.string(), projectId: z.string(), repositoryId: z.string(), type: z.literal("azure-devops-file")});

export const realityConnectorBitbucketRepo = z.object({projectId: z.string(), repositoryId: z.string(), type: z.literal("bitbucket-repo"), workspaceId: z.string()});

export const realityConnectorBitbucketBranch = z.object({branchName: z.string(), projectId: z.string(), repositoryId: z.string(), type: z.literal("bitbucket-branch"), workspaceId: z.string()});

export const realityConnectorBitbucketFolder = z.object({branchName: z.string(), path: z.string(), projectId: z.string(), repositoryId: z.string(), type: z.literal("bitbucket-folder"), workspaceId: z.string()});

export const realityConnectorBitbucketFile = z.object({branchName: z.string(), path: z.string(), projectId: z.string(), repositoryId: z.string(), type: z.literal("bitbucket-file"), workspaceId: z.string()});

export const realityConnectorBitbucketServerRepo = z.object({projectId: z.number(), repositoryId: z.number(), serverUrl: z.string(), type: z.literal("bitbucket-server-repo")});

export const realityConnectorBitbucketServerBranch = z.object({branchName: z.string(), projectId: z.number(), repositoryId: z.number(), serverUrl: z.string(), type: z.literal("bitbucket-server-branch")});

export const realityConnectorBitbucketServerFolder = z.object({branchName: z.string(), path: z.string(), projectId: z.number(), repositoryId: z.number(), serverUrl: z.string(), type: z.literal("bitbucket-server-folder")});

export const realityConnectorBitbucketServerFile = z.object({branchName: z.string(), path: z.string(), projectId: z.number(), repositoryId: z.number(), serverUrl: z.string(), type: z.literal("bitbucket-server-file")});

export const realityConnectorGithubRepo = z.object({ownerId: z.number(), repositoryId: z.number(), type: z.literal("github-repo")});

export const realityConnectorGithubBranch = z.object({branchName: z.string(), ownerId: z.number(), repositoryId: z.number(), type: z.literal("github-branch")});

export const realityConnectorGithubFolder = z.object({branchName: z.string(), ownerId: z.number(), path: z.string(), repositoryId: z.number(), type: z.literal("github-folder")});

export const realityConnectorGithubFile = z.object({branchName: z.string(), ownerId: z.number(), path: z.string(), repositoryId: z.number(), type: z.literal("github-file")});

export const realityConnectorGitlabRepo = z.object({projectId: z.number(), type: z.literal("gitlab-repo")});

export const realityConnectorGitlabBranch = z.object({branchName: z.string(), projectId: z.number(), type: z.literal("gitlab-branch")});

export const realityConnectorGitlabFolder = z.object({branchName: z.string(), path: z.string(), projectId: z.number(), type: z.literal("gitlab-folder")});

export const realityConnectorGitlabFile = z.object({branchName: z.string(), path: z.string(), projectId: z.number(), type: z.literal("gitlab-file")});

export const realityConnector = z.union([realityConnectorUrl, realityConnectorAzureDevopsRepo, realityConnectorAzureDevopsBranch, realityConnectorAzureDevopsFolder, realityConnectorAzureDevopsFile, realityConnectorBitbucketRepo, realityConnectorBitbucketBranch, realityConnectorBitbucketFolder, realityConnectorBitbucketFile, realityConnectorBitbucketServerRepo, realityConnectorBitbucketServerBranch, realityConnectorBitbucketServerFolder, realityConnectorBitbucketServerFile, realityConnectorGithubRepo, realityConnectorGithubBranch, realityConnectorGithubFolder, realityConnectorGithubFile, realityConnectorGitlabRepo, realityConnectorGitlabBranch, realityConnectorGitlabFolder, realityConnectorGitlabFile]);

export const realityLinkRequired = z.object({connectionResolveUrl: z.string().optional(), connector: realityConnector.optional(), customName: z.string().nullable().optional(), index: z.number().optional(), url: z.string().optional()});

export const modelObjectStatus = z.enum(["deprecated", "future", "live", "removed"]);

export const draftTaskModelObjectCreateProps = z.object({caption: z.string().max(50000).optional(), commit: z.number().optional(), description: z.string().max(950000).optional(), external: z.boolean().optional(), groupIds: z.array(z.string()).optional(), icon: modelObjectIconNullable.optional(), labels: z.record(z.string(), z.string().max(5000)).optional(), links: z.record(z.string(), realityLinkRequired).optional(), name: z.string().max(4000), parentId: z.string().min(1).nullable(), status: modelObjectStatus.optional(), tagIds: z.array(z.string()).optional(), teamIds: z.array(z.string()).optional(), teamOnlyEditing: z.boolean().optional(), technologyIds: z.array(z.string()).optional(), type: modelObjectType, domainId: z.string().optional(), handleId: z.string().optional()});

export const draftTaskModelObjectCreate = z.object({entityId: z.string(), props: draftTaskModelObjectCreateProps, type: z.literal("draft-model-object-create")});

export const realityLinkPartial = z.object({connectionResolveUrl: z.string().optional(), connector: realityConnector.optional(), customName: z.string().nullable().optional(), index: z.number().optional(), url: z.string().optional()});

export const draftTaskModelObjectUpdateProps = z.object({caption: z.string().max(50000).optional(), commit: z.number().optional(), description: z.string().max(950000).optional(), external: z.boolean().optional(), groupIds: z.union([z.array(z.string()), z.object({$add: z.array(z.string()).optional(), $remove: z.array(z.string()).optional()})]).optional(), icon: modelObjectIconNullable.optional(), labels: z.record(z.string(), z.string().max(5000)).optional(), links: z.object({$add: z.record(z.string(), realityLinkRequired).optional(), $remove: z.array(z.string()).optional(), $replace: z.record(z.string(), realityLinkRequired).optional(), $update: z.record(z.string(), realityLinkPartial).optional()}).optional(), name: z.string().max(4000).optional(), parentId: z.string().min(1).nullable().optional(), status: modelObjectStatus.optional(), tagIds: z.union([z.array(z.string()), z.object({$add: z.array(z.string()).optional(), $remove: z.array(z.string()).optional()})]).optional(), teamIds: z.union([z.array(z.string()), z.object({$add: z.array(z.string()).optional(), $remove: z.array(z.string()).optional()})]).optional(), teamOnlyEditing: z.boolean().optional(), technologyIds: z.union([z.array(z.string()), z.object({$add: z.array(z.string()).optional(), $remove: z.array(z.string()).optional()})]).optional(), type: modelObjectType.optional()});

export const draftTaskModelObjectUpdate = z.object({entityId: z.string(), props: draftTaskModelObjectUpdateProps, snapshot: draftTaskModelObjectUpdateProps, type: z.literal("draft-model-object-update")});

export const draftTaskModelObjectDelete = z.object({entityId: z.string(), type: z.literal("draft-model-object-delete")});

export const modelConnectionDirectionNullable = z.enum(["outgoing", "bidirectional"]);

export const modelConnectionStatus = z.enum(["deprecated", "future", "live", "removed"]);

export const draftTaskModelConnectionCreateProps = z.object({commit: z.number().optional(), description: z.string().max(950000).optional(), direction: modelConnectionDirectionNullable, labels: z.record(z.string(), z.string().max(5000)).optional(), links: z.record(z.string(), realityLinkRequired).optional(), name: z.string().max(4000), originId: z.string(), status: modelConnectionStatus.optional(), tagIds: z.array(z.string()).optional(), targetId: z.string(), technologyIds: z.array(z.string()).optional(), viaId: z.string().nullable().optional(), handleId: z.string().optional()});

export const draftTaskModelConnectionCreate = z.object({entityId: z.string(), props: draftTaskModelConnectionCreateProps, type: z.literal("draft-model-connection-create")});

export const draftTaskModelConnectionUpdateProps = z.object({commit: z.number().optional(), description: z.string().max(950000).optional(), direction: modelConnectionDirectionNullable.optional(), labels: z.record(z.string(), z.string().max(5000)).optional(), links: z.object({$add: z.record(z.string(), realityLinkRequired).optional(), $remove: z.array(z.string()).optional(), $replace: z.record(z.string(), realityLinkRequired).optional(), $update: z.record(z.string(), realityLinkPartial).optional()}).optional(), name: z.string().max(4000).optional(), originId: z.string().optional(), status: modelConnectionStatus.optional(), tagIds: z.union([z.array(z.string()), z.object({$add: z.array(z.string()).optional(), $remove: z.array(z.string()).optional()})]).optional(), targetId: z.string().optional(), technologyIds: z.union([z.array(z.string()), z.object({$add: z.array(z.string()).optional(), $remove: z.array(z.string()).optional()})]).optional(), viaId: z.string().nullable().optional()});

export const draftTaskModelConnectionUpdate = z.object({entityId: z.string(), props: draftTaskModelConnectionUpdateProps, snapshot: draftTaskModelConnectionUpdateProps, type: z.literal("draft-model-connection-update")});

export const draftTaskModelConnectionDelete = z.object({entityId: z.string(), type: z.literal("draft-model-connection-delete")});

export const flowStepPath = z.object({id: z.string(), index: z.number(), name: z.string()});

export const flowStepPathsNullable = z.record(z.string(), flowStepPath);

export const flowStep = z.object({description: z.string().max(20000), detailedDescription: z.string().max(20000).optional(), flowId: z.string().nullable(), id: z.string(), index: z.number(), originId: z.string().nullable(), parentId: z.string().nullable(), paths: flowStepPathsNullable, targetId: z.string().nullable(), type: z.enum(["alternate-path", "subflow", "outgoing", "parallel-path", "reply", "self-action", "introduction", "information", "conclusion", "null"]).nullable(), viaId: z.string().nullable()});

export const draftTaskFlowCreateProps = z.object({commit: z.number().optional(), index: z.number().optional(), labels: z.record(z.string(), z.string().max(5000)).optional(), name: z.string().max(4000), pinned: z.boolean().optional(), pinnedAt: z.string().optional(), pinnedIndex: z.number().optional(), showAllSteps: z.boolean().optional(), showConnectionNames: z.boolean().optional(), steps: z.record(z.string(), flowStep).optional(), diagramId: z.string(), handleId: z.string().optional()});

export const draftTaskFlowCreate = z.object({entityId: z.string(), props: draftTaskFlowCreateProps, type: z.literal("draft-flow-create")});

export const flowStepPartial = z.object({description: z.string().max(20000).optional(), detailedDescription: z.string().max(20000).optional(), flowId: z.string().nullable().optional(), id: z.string().optional(), index: z.number().optional(), originId: z.string().nullable().optional(), parentId: z.string().nullable().optional(), paths: flowStepPathsNullable.optional(), targetId: z.string().nullable().optional(), type: z.enum(["alternate-path", "subflow", "outgoing", "parallel-path", "reply", "self-action", "introduction", "information", "conclusion", "null"]).nullable().optional(), viaId: z.string().nullable().optional()});

export const draftTaskFlowUpdateProps = z.object({commit: z.number().optional(), index: z.number().optional(), labels: z.record(z.string(), z.string().max(5000)).optional(), name: z.string().max(4000).optional(), pinned: z.boolean().optional(), pinnedAt: z.string().optional(), pinnedIndex: z.number().optional(), showAllSteps: z.boolean().optional(), showConnectionNames: z.boolean().optional(), steps: z.object({$add: z.record(z.string(), flowStep).optional(), $remove: z.array(z.string()).optional(), $replace: z.record(z.string(), flowStep).optional(), $update: z.record(z.string(), flowStepPartial).optional()}).optional()});

export const draftTaskFlowUpdate = z.object({entityId: z.string(), props: draftTaskFlowUpdateProps, snapshot: draftTaskFlowUpdateProps, type: z.literal("draft-flow-update")});

export const draftTaskFlowDelete = z.object({entityId: z.string(), type: z.literal("draft-flow-delete")});

export const draftTaskTagCreateProps = z.object({color: tagColor, commit: z.number().optional(), groupId: z.string(), index: z.number(), labels: z.record(z.string(), z.string().max(5000)).optional(), name: z.string().max(4000), handleId: z.string().optional()});

export const draftTaskTagCreate = z.object({entityId: z.string(), props: draftTaskTagCreateProps, type: z.literal("draft-tag-create")});

export const draftTaskTagUpdateProps = z.object({color: tagColor.optional(), commit: z.number().optional(), groupId: z.string().optional(), index: z.number().optional(), labels: z.record(z.string(), z.string().max(5000)).optional(), name: z.string().max(4000).optional()});

export const draftTaskTagUpdate = z.object({entityId: z.string(), props: draftTaskTagUpdateProps, snapshot: draftTaskTagUpdateProps, type: z.literal("draft-tag-update")});

export const draftTaskTagDelete = z.object({entityId: z.string(), type: z.literal("draft-tag-delete")});

export const tagGroupIcon = z.enum(["bug", "calendar-check", "calendar-times", "cloud", "cog", "database", "exclamation-triangle", "file", "globe", "laptop-code", "lightbulb", "lock", "microchip", "minus", "mobile", "network-wired", "plus", "poo", "robot", "rocket", "sack-dollar", "server", "sledding", "snowman", "star", "times", "toolbox", "trash", "users", "wifi"]);

export const draftTaskTagGroupCreateProps = z.object({commit: z.number().optional(), icon: tagGroupIcon, index: z.number(), labels: z.record(z.string(), z.string().max(5000)).optional(), name: z.string().max(4000), handleId: z.string().optional()});

export const draftTaskTagGroupCreate = z.object({entityId: z.string(), props: draftTaskTagGroupCreateProps, type: z.literal("draft-tag-group-create")});

export const draftTaskTagGroupUpdateProps = z.object({commit: z.number().optional(), icon: tagGroupIcon.optional(), index: z.number().optional(), labels: z.record(z.string(), z.string().max(5000)).optional(), name: z.string().max(4000).optional()});

export const draftTaskTagGroupUpdate = z.object({entityId: z.string(), props: draftTaskTagGroupUpdateProps, snapshot: draftTaskTagGroupUpdateProps, type: z.literal("draft-tag-group-update")});

export const draftTaskTagGroupDelete = z.object({entityId: z.string(), type: z.literal("draft-tag-group-delete")});

export const draftTask = z.union([draftTaskCommentCreate, draftTaskCommentUpdate, draftTaskCommentDelete, draftTaskCommentReplyCreate, draftTaskCommentReplyUpdate, draftTaskCommentReplyDelete, draftTaskDiagramCreate, draftTaskDiagramUpdate, draftTaskDiagramDelete, draftTaskDiagramContentUpdate, draftTaskDiagramGroupCreate, draftTaskDiagramGroupUpdate, draftTaskDiagramGroupDelete, draftTaskModelObjectCreate, draftTaskModelObjectUpdate, draftTaskModelObjectDelete, draftTaskModelConnectionCreate, draftTaskModelConnectionUpdate, draftTaskModelConnectionDelete, draftTaskFlowCreate, draftTaskFlowUpdate, draftTaskFlowDelete, draftTaskTagCreate, draftTaskTagUpdate, draftTaskTagDelete, draftTaskTagGroupCreate, draftTaskTagGroupUpdate, draftTaskTagGroupDelete]);

export const draftTaskRequired = z.object({commit: z.number().optional(), task: draftTask});

export const actionDraftTaskCreate = z.object({context: actionDraftTaskCreateContext, id: z.string(), props: draftTaskRequired, type: z.literal("draft-task-create")});

export const actionLandscapeCreateContext = z.object({backstageImport: z.boolean().optional(), name: z.string(), structurizrImport: z.boolean().optional()});

export const actionLandscapeCreate = z.object({context: actionLandscapeCreateContext, id: z.string(), type: z.literal("landscape-create")});

export const actionLandscapeUpdateContext = z.object({name: z.string()});

export const landscapePartial = z.object({name: z.string().max(4000).optional(), organizationId: z.string().optional(), scheduledVersions: z.boolean().optional()});

export const actionLandscapeUpdate = z.object({context: actionLandscapeUpdateContext, id: z.string(), props: landscapePartial, type: z.literal("landscape-update")});

export const actionLandscapeDuplicateContext = z.object({name: z.string(), targetOrganizationName: z.string().optional()});

export const actionLandscapeDuplicateProps = z.object({targetOrganizationId: z.string().optional()});

export const actionLandscapeDuplicate = z.object({context: actionLandscapeDuplicateContext, id: z.string(), props: actionLandscapeDuplicateProps, type: z.literal("landscape-duplicate")});

export const actionLandscapeCopyContext = z.object({name: z.string(), targetLandscapeName: z.string()});

export const actionLandscapeCopy = z.object({context: actionLandscapeCopyContext, id: z.string(), props: z.object({targetLandscapeId: z.string()}), type: z.literal("landscape-copy")});

export const actionLandscapeDeleteContext = z.object({name: z.string()});

export const actionLandscapeDelete = z.object({context: actionLandscapeDeleteContext, id: z.string(), type: z.literal("landscape-delete")});

export const actionLandscapeExportContext = z.object({draftHandleId: z.string().optional(), draftName: z.string().optional(), filterDiagramHandleId: z.string().optional(), filterDiagramName: z.string().optional(), filterDiagramType: diagramType.optional(), filterFlowHandleId: z.string().optional(), filterFlowName: z.string().optional(), filterModelObjectHandleId: z.string().optional(), filterModelObjectName: z.string().optional(), filterModelObjectType: modelObjectType.optional(), landscapeName: z.string(), versionName: z.string()});

export const landscapeExportFilter = z.object({diagramId: z.string().optional(), flowId: z.string().optional(), includeDiagrams: z.boolean().optional(), includeFlows: z.boolean().optional(), modelObjectId: z.string().optional()});

export const landscapeExportOrientation = z.enum(["portrait", "landscape"]);

export const landscapeExportSchema = z.enum(["v1", "v2"]);

export const landscapeExportOptions = z.object({draftId: z.string().optional(), orientation: landscapeExportOrientation.optional(), schema: landscapeExportSchema.optional()});

export const landscapeExportType = z.enum(["pdf", "markdown", "html", "llms", "json", "object-csv", "connection-csv"]);

export const actionLandscapeExportProps = z.object({bucketPath: z.string(), filename: z.string(), filter: landscapeExportFilter.optional(), options: landscapeExportOptions.optional(), type: landscapeExportType, versionId: z.string()});

export const actionLandscapeExport = z.object({context: actionLandscapeExportContext, id: z.string(), props: actionLandscapeExportProps, type: z.literal("landscape-export")});

export const actionLandscapeImportContext = z.object({landscapeName: z.string(), versionName: z.string()});

export const actionLandscapeImportProps = z.object({bucketPath: z.string(), modelConnectionCount: z.number(), modelObjectCount: z.number(), modelObjectTypeCount: z.record(z.string(), z.number()), prune: z.boolean().optional(), tagCount: z.number(), tagGroupCount: z.number(), versionId: z.string()});

export const actionLandscapeImport = z.object({context: actionLandscapeImportContext, id: z.string(), props: actionLandscapeImportProps, type: z.literal("landscape-import")});

export const actionLandscape = z.union([actionLandscapeCreate, actionLandscapeUpdate, actionLandscapeDuplicate, actionLandscapeCopy, actionLandscapeDelete, actionLandscapeExport, actionLandscapeImport]);

export const actionModelObjectCreateContext = z.object({domainHandleId: z.string().optional(), domainName: z.string().optional(), groupNames: z.record(z.string(), z.string()).optional(), modelFamily: z.array(actionContextModelObject).optional(), tagNames: z.record(z.string(), z.string()).optional(), teamNames: z.record(z.string(), z.string()).optional(), technologyNames: z.record(z.string(), z.string()).optional()});

export const modelObjectRequired = z.object({caption: z.string().max(50000).optional(), commit: z.number().optional(), description: z.string().max(950000).optional(), external: z.boolean().optional(), groupIds: z.array(z.string()).optional(), icon: modelObjectIconNullable.optional(), labels: z.record(z.string(), z.string().max(5000)).optional(), links: z.record(z.string(), realityLinkRequired).optional(), name: z.string().max(4000), parentId: z.string().min(1).nullable(), status: modelObjectStatus.optional(), tagIds: z.array(z.string()).optional(), teamIds: z.array(z.string()).optional(), teamOnlyEditing: z.boolean().optional(), technologyIds: z.array(z.string()).optional(), type: modelObjectType, domainId: z.string().optional(), handleId: z.string().optional()});

export const actionModelObjectCreate = z.object({context: actionModelObjectCreateContext, id: z.string(), props: modelObjectRequired, type: z.literal("model-object-create")});

export const actionModelObjectUpdateContext = z.object({domainHandleId: z.string().optional(), domainName: z.string().optional(), groupNames: z.record(z.string(), z.string()).optional(), modelFamily: z.array(actionContextModelObject).optional(), name: z.string(), tagNames: z.record(z.string(), z.string()).optional(), teamNames: z.record(z.string(), z.string()).optional(), technologyNames: z.record(z.string(), z.string()).optional(), type: modelObjectType});

export const modelObjectPartial = z.object({caption: z.string().max(50000).optional(), commit: z.number().optional(), description: z.string().max(950000).optional(), external: z.boolean().optional(), groupIds: z.union([z.array(z.string()), z.object({$add: z.array(z.string()).optional(), $remove: z.array(z.string()).optional()})]).optional(), icon: modelObjectIconNullable.optional(), labels: z.record(z.string(), z.string().max(5000)).optional(), links: z.object({$add: z.record(z.string(), realityLinkRequired).optional(), $remove: z.array(z.string()).optional(), $replace: z.record(z.string(), realityLinkRequired).optional(), $update: z.record(z.string(), realityLinkPartial).optional()}).optional(), name: z.string().max(4000).optional(), parentId: z.string().min(1).nullable().optional(), status: modelObjectStatus.optional(), tagIds: z.union([z.array(z.string()), z.object({$add: z.array(z.string()).optional(), $remove: z.array(z.string()).optional()})]).optional(), teamIds: z.union([z.array(z.string()), z.object({$add: z.array(z.string()).optional(), $remove: z.array(z.string()).optional()})]).optional(), teamOnlyEditing: z.boolean().optional(), technologyIds: z.union([z.array(z.string()), z.object({$add: z.array(z.string()).optional(), $remove: z.array(z.string()).optional()})]).optional(), type: modelObjectType.optional()});

export const actionModelObjectUpdate = z.object({context: actionModelObjectUpdateContext, id: z.string(), props: modelObjectPartial, type: z.literal("model-object-update")});

export const actionModelObjectDependenciesExportContext = z.object({domainHandleId: z.string().optional(), domainName: z.string().optional(), modelFamily: z.array(actionContextModelObject).optional(), name: z.string(), type: modelObjectType, versionName: z.string()});

export const actionModelObjectDependenciesExportProps = z.object({type: z.literal("json"), versionId: z.string()});

export const actionModelObjectDependenciesExport = z.object({context: actionModelObjectDependenciesExportContext, id: z.string(), props: actionModelObjectDependenciesExportProps, type: z.literal("model-object-dependencies-export")});

export const actionModelObjectsExportContext = z.object({landscapeName: z.string(), versionName: z.string()});

export const actionModelObjectsExportProps = z.object({type: z.literal("csv"), versionId: z.string()});

export const actionModelObjectsExport = z.object({context: actionModelObjectsExportContext, id: z.string(), props: actionModelObjectsExportProps, type: z.literal("model-objects-export")});

export const actionModelObjectDeleteContext = z.object({domainHandleId: z.string().optional(), domainName: z.string().optional(), groupNames: z.record(z.string(), z.string()).optional(), modelFamily: z.array(actionContextModelObject).optional(), name: z.string(), tagNames: z.record(z.string(), z.string()).optional(), teamNames: z.record(z.string(), z.string()).optional(), technologyNames: z.record(z.string(), z.string()).optional(), type: modelObjectType});

export const actionModelObjectDelete = z.object({context: actionModelObjectDeleteContext, id: z.string(), type: z.literal("model-object-delete")});

export const actionModelObject = z.union([actionModelObjectCreate, actionModelObjectUpdate, actionModelObjectDependenciesExport, actionModelObjectsExport, actionModelObjectDelete]);

export const actionModelConnectionCreateContext = z.object({domainHandleId: z.string().optional(), domainName: z.string().optional(), originModelFamily: z.array(actionContextModelObject).optional(), tagNames: z.record(z.string(), z.string()).optional(), targetModelFamily: z.array(actionContextModelObject).optional(), technologyNames: z.record(z.string(), z.string()).optional(), viaModelFamily: z.array(actionContextModelObject).optional()});

export const modelConnectionRequired = z.object({commit: z.number().optional(), description: z.string().max(950000).optional(), direction: modelConnectionDirectionNullable, labels: z.record(z.string(), z.string().max(5000)).optional(), links: z.record(z.string(), realityLinkRequired).optional(), name: z.string().max(4000), originId: z.string(), status: modelConnectionStatus.optional(), tagIds: z.array(z.string()).optional(), targetId: z.string(), technologyIds: z.array(z.string()).optional(), viaId: z.string().nullable().optional(), handleId: z.string().optional()});

export const actionModelConnectionCreate = z.object({context: actionModelConnectionCreateContext, id: z.string(), props: modelConnectionRequired, type: z.literal("model-connection-create")});

export const actionModelConnectionUpdateContext = z.object({domainHandleId: z.string().optional(), domainName: z.string().optional(), name: z.string(), originModelFamily: z.array(actionContextModelObject).optional(), tagNames: z.record(z.string(), z.string()).optional(), targetModelFamily: z.array(actionContextModelObject).optional(), technologyNames: z.record(z.string(), z.string()).optional(), viaModelFamily: z.array(actionContextModelObject).optional()});

export const modelConnectionPartial = z.object({commit: z.number().optional(), description: z.string().max(950000).optional(), direction: modelConnectionDirectionNullable.optional(), labels: z.record(z.string(), z.string().max(5000)).optional(), links: z.object({$add: z.record(z.string(), realityLinkRequired).optional(), $remove: z.array(z.string()).optional(), $replace: z.record(z.string(), realityLinkRequired).optional(), $update: z.record(z.string(), realityLinkPartial).optional()}).optional(), name: z.string().max(4000).optional(), originId: z.string().optional(), status: modelConnectionStatus.optional(), tagIds: z.union([z.array(z.string()), z.object({$add: z.array(z.string()).optional(), $remove: z.array(z.string()).optional()})]).optional(), targetId: z.string().optional(), technologyIds: z.union([z.array(z.string()), z.object({$add: z.array(z.string()).optional(), $remove: z.array(z.string()).optional()})]).optional(), viaId: z.string().nullable().optional()});

export const actionModelConnectionUpdate = z.object({context: actionModelConnectionUpdateContext, id: z.string(), props: modelConnectionPartial, type: z.literal("model-connection-update")});

export const actionModelConnectionsExportContext = z.object({landscapeName: z.string(), versionName: z.string()});

export const actionModelConnectionsExportProps = z.object({type: z.literal("csv"), versionId: z.string()});

export const actionModelConnectionsExport = z.object({context: actionModelConnectionsExportContext, id: z.string(), props: actionModelConnectionsExportProps, type: z.literal("model-connections-export")});

export const actionModelConnectionDeleteContext = z.object({domainHandleId: z.string().optional(), domainName: z.string().optional(), name: z.string(), originModelFamily: z.array(actionContextModelObject).optional(), tagNames: z.record(z.string(), z.string()).optional(), targetModelFamily: z.array(actionContextModelObject).optional(), technologyNames: z.record(z.string(), z.string()).optional(), viaModelFamily: z.array(actionContextModelObject).optional()});

export const actionModelConnectionDelete = z.object({context: actionModelConnectionDeleteContext, id: z.string(), type: z.literal("model-connection-delete")});

export const actionModelConnection = z.union([actionModelConnectionCreate, actionModelConnectionUpdate, actionModelConnectionsExport, actionModelConnectionDelete]);

export const actionShareLinkCreateContext = z.object({draftHandleId: z.string().nullable().optional(), draftName: z.string().optional(), versionModelHandleId: z.string().nullable(), versionName: z.string()});

export const shareLinkRequired = z.object({password: z.string().min(8).max(64).optional(), protected: z.boolean(), draftId: z.string().nullable().optional()});

export const actionShareLinkCreate = z.object({context: actionShareLinkCreateContext, id: z.string(), props: shareLinkRequired, type: z.literal("share-link-create")});

export const actionShareLinkUpdateContext = z.object({draftHandleId: z.string().nullable().optional(), draftName: z.string().optional(), shortId: z.string(), versionModelHandleId: z.string().nullable(), versionName: z.string()});

export const actionShareLinkUpdate = z.object({context: actionShareLinkUpdateContext, id: z.string(), props: z.object({password: z.string().min(8).max(64).optional(), protected: z.boolean().optional(), resetShortId: z.boolean()}), type: z.literal("share-link-update")});

export const actionShareLinkDeleteContext = z.object({draftHandleId: z.string().nullable().optional(), draftName: z.string().optional(), shortId: z.string(), versionModelHandleId: z.string().nullable(), versionName: z.string()});

export const actionShareLinkDelete = z.object({context: actionShareLinkDeleteContext, id: z.string(), type: z.literal("share-link-delete")});

export const actionShareLink = z.union([actionShareLinkCreate, actionShareLinkUpdate, actionShareLinkDelete]);

export const actionFlowCreateContext = z.object({diagramHandleId: z.string().optional(), diagramName: z.string().optional(), diagramType: diagramType.optional(), domainHandleId: z.string().optional(), domainName: z.string().optional(), modelFamily: z.array(actionContextModelObject).optional()});

export const flowRequired = z.object({commit: z.number().optional(), index: z.number().optional(), labels: z.record(z.string(), z.string().max(5000)).optional(), name: z.string().max(4000), pinned: z.boolean().optional(), pinnedAt: z.string().optional(), pinnedIndex: z.number().optional(), showAllSteps: z.boolean().optional(), showConnectionNames: z.boolean().optional(), steps: z.record(z.string(), flowStep).optional(), diagramId: z.string(), handleId: z.string().optional()});

export const actionFlowCreate = z.object({context: actionFlowCreateContext, id: z.string(), props: flowRequired, type: z.literal("flow-create")});

export const actionFlowContextObject = z.object({type: diagramObjectType});

export const actionFlowUpdateContext = z.object({diagramHandleId: z.string().optional(), diagramName: z.string().optional(), diagramType: diagramType.optional(), domainHandleId: z.string().optional(), domainName: z.string().optional(), modelFamily: z.array(actionContextModelObject).optional(), name: z.string(), objects: z.record(z.string(), actionFlowContextObject).optional()});

export const flowPartial = z.object({commit: z.number().optional(), index: z.number().optional(), labels: z.record(z.string(), z.string().max(5000)).optional(), name: z.string().max(4000).optional(), pinned: z.boolean().optional(), pinnedAt: z.string().optional(), pinnedIndex: z.number().optional(), showAllSteps: z.boolean().optional(), showConnectionNames: z.boolean().optional(), steps: z.object({$add: z.record(z.string(), flowStep).optional(), $remove: z.array(z.string()).optional(), $replace: z.record(z.string(), flowStep).optional(), $update: z.record(z.string(), flowStepPartial).optional()}).optional()});

export const actionFlowUpdate = z.object({context: actionFlowUpdateContext, id: z.string(), props: flowPartial, type: z.literal("flow-update")});

export const actionFlowDeleteContext = z.object({diagramHandleId: z.string().optional(), diagramName: z.string().optional(), diagramType: diagramType.optional(), domainHandleId: z.string().optional(), domainName: z.string().optional(), modelFamily: z.array(actionContextModelObject).optional(), name: z.string()});

export const actionFlowDelete = z.object({context: actionFlowDeleteContext, id: z.string(), type: z.literal("flow-delete")});

export const actionFlowViewContext = z.object({diagramHandleId: z.string().optional(), diagramName: z.string().optional(), diagramType: diagramType.optional(), domainHandleId: z.string().optional(), domainName: z.string().optional(), modelFamily: z.array(actionContextModelObject).optional(), name: z.string()});

export const actionFlowView = z.object({context: actionFlowViewContext, id: z.string(), type: z.literal("flow-view")});

export const actionTagCreateContext = z.object({groupHandleId: z.string().optional(), groupName: z.string().optional()});

export const tagRequired = z.object({color: tagColor, commit: z.number().optional(), groupId: z.string(), index: z.number(), labels: z.record(z.string(), z.string().max(5000)).optional(), name: z.string().max(4000), handleId: z.string().optional()});

export const actionTagCreate = z.object({context: actionTagCreateContext, id: z.string(), props: tagRequired, type: z.literal("tag-create")});

export const actionTagUpdateContext = z.object({groupHandleId: z.string().optional(), groupName: z.string().optional(), name: z.string()});

export const tagPartial = z.object({color: tagColor.optional(), commit: z.number().optional(), groupId: z.string().optional(), index: z.number().optional(), labels: z.record(z.string(), z.string().max(5000)).optional(), name: z.string().max(4000).optional()});

export const actionTagUpdate = z.object({context: actionTagUpdateContext, id: z.string(), props: tagPartial, type: z.literal("tag-update")});

export const actionTagDeleteContext = z.object({groupHandleId: z.string().optional(), groupName: z.string().optional(), name: z.string()});

export const actionTagDelete = z.object({context: actionTagDeleteContext, id: z.string(), type: z.literal("tag-delete")});

export const tagGroupRequired = z.object({commit: z.number().optional(), icon: tagGroupIcon, index: z.number(), labels: z.record(z.string(), z.string().max(5000)).optional(), name: z.string().max(4000), handleId: z.string().optional()});

export const actionTagGroupCreate = z.object({id: z.string(), props: tagGroupRequired, type: z.literal("tag-group-create")});

export const actionTagGroupUpdateContext = z.object({name: z.string()});

export const tagGroupPartial = z.object({commit: z.number().optional(), icon: tagGroupIcon.optional(), index: z.number().optional(), labels: z.record(z.string(), z.string().max(5000)).optional(), name: z.string().max(4000).optional()});

export const actionTagGroupUpdate = z.object({context: actionTagGroupUpdateContext, id: z.string(), props: tagGroupPartial, type: z.literal("tag-group-update")});

export const actionTagGroupDeleteContext = z.object({name: z.string()});

export const actionTagGroupDelete = z.object({context: actionTagGroupDeleteContext, id: z.string(), type: z.literal("tag-group-delete")});

export const actionVersionCreateContext = z.object({domainHandleId: z.string().optional(), domainName: z.string().optional(), modelFamily: z.array(actionContextModelObject).optional()});

export const versionRequired = z.object({modelHandleId: z.string().nullable(), name: z.string().min(1).max(4000), notes: z.string().min(10).max(20000)});

export const actionVersionCreate = z.object({context: actionVersionCreateContext, id: z.string(), props: versionRequired, type: z.literal("version-create")});

export const actionVersionDeleteContext = z.object({domainHandleId: z.string().optional(), domainName: z.string().optional(), modelFamily: z.array(actionContextModelObject).optional(), versionName: z.string()});

export const actionVersionDelete = z.object({context: actionVersionDeleteContext, id: z.string(), type: z.literal("version-delete")});

export const actionVersionRevertContext = z.object({name: z.string()});

export const versionRevertRequired = z.object({notes: z.string().min(10), versionId: z.string()});

export const actionVersionRevertCreate = z.object({context: actionVersionRevertContext, id: z.string(), props: versionRevertRequired, type: z.literal("version-revert-create")});

export const actionVersion = z.union([actionVersionCreate, actionVersionDelete, actionVersionRevertCreate]);

export const landscapeAction = z.union([actionCommentCreate, actionCommentUpdate, actionCommentDelete, actionCommentReplyCreate, actionCommentReplyUpdate, actionCommentReplyDelete, actionDiagramContentCreate, actionDiagramContentUpdate, actionDiagramContentDelete, actionDiagramContentView, actionDiagram, actionDiagramGroupCreate, actionDiagramGroupUpdate, actionDiagramGroupDelete, actionDomainCreate, actionDomainUpdate, actionDomainDelete, actionDraft, actionDraftTaskCreate, actionLandscape, actionModelObject, actionModelConnection, actionShareLink, actionFlowCreate, actionFlowUpdate, actionFlowDelete, actionFlowView, actionTagCreate, actionTagUpdate, actionTagDelete, actionTagGroupCreate, actionTagGroupUpdate, actionTagGroupDelete, actionVersion]);

export const action = z.union([organizationAction, landscapeAction]);

export const authType = z.enum(["user", "api-key", "notification-key", "service"]);

export const actionLog = z.object({action: action, actionIds: z.array(z.string()), id: z.string(), landscapeId: z.string(), parentId: z.string().nullable(), performedAt: z.string(), performedBy: authType, performedByAuthProvider: z.string().optional(), performedByClientId: z.string().optional(), performedById: z.string(), performedByIp: z.string().optional(), performedByName: z.string().optional(), performedByUserAgent: z.string().optional()});

export const getApiLandscapesLandscapeIdActionLogsActionLogIdChildrenResponse = z.object({actionLogs: z.array(actionLog), nextCursor: z.string().optional()});

export const validateResponse = async <Output>(
  schema: {
    readonly '~standard': {
      readonly validate: (value: unknown) => ({ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }) | Promise<{ readonly value: Output; readonly issues?: undefined } | { readonly issues: ReadonlyArray<{ readonly message: string; readonly path?: ReadonlyArray<PropertyKey | { readonly key: PropertyKey }> | undefined }> }>
    }
  },
  value: unknown
): Promise<Output> => {
  const result = await schema['~standard'].validate(value)

  if (result.issues !== undefined) {
    const detail = result.issues
      .map(({ message, path }) =>
        path?.length
          ? `${path.map((segment) => String(typeof segment === 'object' ? segment.key : segment)).join('.')}: ${message}`
          : message
      )
      .join('; ')

    throw new Error(`Response does not match the schema: ${detail}`, { cause: { issues: result.issues } })
  }

  return result.value
};

/**
 * List Children
 * 
 * GET /landscapes/{landscapeId}/action-logs/{actionLogId}/children
 * 
 * Also accepts auth: BearerAuth
 */
export const getApiLandscapesLandscapeIdActionLogsActionLogIdChildren = async (args: GetApiLandscapesLandscapeIdActionLogsActionLogIdChildrenArgs, options?: GetApiLandscapesLandscapeIdActionLogsActionLogIdChildrenOptions) => {
const {baseUrl = "https://api.icepanel.io/v1", fetch: fetchFn = fetch, ApiKeyAuth} = options ?? {}

const query = new URLSearchParams()
const headers = new Headers()
headers.set('accept', "application/json")

if (args.filter != null) query.append("filter", JSON.stringify(args.filter))
if (args.cursor != null) query.append("cursor", String(args.cursor))
if (args.limit != null) query.append("limit", String(args.limit))
if (args.order != null) query.append("order", String(args.order))
if (ApiKeyAuth !== undefined) headers.set("X-API-Key", ApiKeyAuth)

const url = `${baseUrl.replace(/\/+$/, '')}/landscapes/${encodeURIComponent(String(args.landscapeId))}/action-logs/${encodeURIComponent(String(args.actionLogId))}/children${query.size > 0 ? `?${query}` : ''}`

const res = await fetchFn(url, {method: "GET", headers})

if (!res.ok) throw new Error(`Request failed with status ${res.status}`, {cause: {status: res.status, body: await res.text()}})

return validateResponse(getApiLandscapesLandscapeIdActionLogsActionLogIdChildrenResponse, await res.json())
};