import type { WorkspaceManagementTypes } from "@cargo-ai/types";
import { z } from "zod";
import type { ApiType, DateToString } from "../types.js";
export declare namespace WorkspaceManagement {
    type Workspace = ApiType<WorkspaceManagementTypes.Workspace>;
    type WorkspaceSync = ApiType<WorkspaceManagementTypes.WorkspaceSync>;
    type LoginProvider = ApiType<WorkspaceManagementTypes.LoginProvider>;
    type Role = ApiType<WorkspaceManagementTypes.Role>;
    type RoleColor = ApiType<WorkspaceManagementTypes.RoleColor>;
    type Permission = ApiType<WorkspaceManagementTypes.Permission>;
    type Action = ApiType<WorkspaceManagementTypes.Action>;
    type PermissionLevel = ApiType<WorkspaceManagementTypes.PermissionLevel>;
    type Token = ApiType<WorkspaceManagementTypes.Token>;
    type EnvVar = ApiType<WorkspaceManagementTypes.EnvVar>;
    type User = ApiType<WorkspaceManagementTypes.User>;
    type Folder = ApiType<WorkspaceManagementTypes.Folder>;
    type FolderKind = ApiType<WorkspaceManagementTypes.FolderKind>;
    type Report = ApiType<WorkspaceManagementTypes.Report>;
    type Session = ApiType<WorkspaceManagementTypes.Session>;
    type State = ApiType<WorkspaceManagementTypes.State>;
    type StateLock = ApiType<WorkspaceManagementTypes.StateLock>;
    namespace Api {
        type AllWorkspacesPayload = DateToString<{
            refresh: boolean;
        }>;
        type AllWorkspacesResult = {
            workspaces: Workspace[];
        };
        type CreateWorkspacePayload = DateToString<{
            name: string;
            logoBase64?: string;
            metadata?: WorkspaceManagementTypes.Metadata;
        }>;
        type CreateWorkspaceResult = {
            workspace: Workspace;
        };
        const zodCreateWorkspaceErrorReason: z.ZodEnum<{
            missingPermissions: "missingPermissions";
            systemOfRecordAlreadyUsedByAnotherWorkspace: "systemOfRecordAlreadyUsedByAnotherWorkspace";
            userNotFound: "userNotFound";
            roleNotFound: "roleNotFound";
            failedToScheduleSync: "failedToScheduleSync";
            workspaceCreateLimitReached: "workspaceCreateLimitReached";
            disposableEmailNotAllowed: "disposableEmailNotAllowed";
            cannotSetupClient: "cannotSetupClient";
        }>;
        type UpdateWorkspacePayload = DateToString<{
            name?: string;
            allowedEmailDomains?: string[];
            logoBase64?: string | null;
            openAiApiKey?: string | null;
            syncs?: Omit<WorkspaceSync, "temporalScheduleWorkflowId">[];
            metadata?: WorkspaceManagementTypes.Metadata;
            chromeExtensionMasterAgentUuid?: string | null;
            chromeExtensionAvailableAgentUuids?: string[] | null;
            defaultRoleUuid?: string | null;
            allowedLoginProviders?: WorkspaceManagementTypes.LoginProvider[] | null;
        }>;
        type UpdateWorkspaceResult = {
            workspace: Workspace;
        };
        const zodUpdateWorkspaceErrorReason: z.ZodEnum<{
            failedToScheduleSync: "failedToScheduleSync";
            workspaceNotFound: "workspaceNotFound";
        }>;
        type GetCurrentWorkspaceResult = {
            workspace: Workspace;
        };
        type UploadFilePayload = {
            file: File;
            onProgress: (progressPercentage: number) => void;
            onComplete: (payload: {
                s3Filename: string;
                contentType: string;
                name: string;
            }) => void;
            onError: () => void;
        };
        type StartMultipartUploadPayload = {
            contentType: string;
            filename?: string;
        };
        type StartMultipartUploadResult = {
            s3Filename: string;
            uploadId: string;
        };
        type SignMultipartUploadPartPayload = {
            s3Filename: string;
            uploadId: string;
            partNumber: number;
        };
        type SignMultipartUploadPartResult = {
            url: string;
        };
        type CompleteMultipartUploadPayload = {
            s3Filename: string;
            uploadId: string;
            parts: Array<{
                partNumber: number;
                etag: string;
            }>;
        };
        type CompleteMultipartUploadResult = {
            s3Filename: string;
        };
        type AbortMultipartUploadPayload = {
            s3Filename: string;
            uploadId: string;
        };
        type ListFileColumnsPayload = DateToString<{
            s3Filename: string;
        }>;
        type ListFileColumnsResult = {
            columns: Array<{
                type: "string";
                name: string;
            }>;
        };
        const zodListFileColumnsErrorReason: z.ZodEnum<{
            noColumnsFound: "noColumnsFound";
        }>;
        type GetCurrentUserResult = {
            user: User;
        };
        type CreateUserPayload = DateToString<{
            userEmail: string;
            roleSlug: string;
        }>;
        type AllUsersResult = {
            users: User[];
        };
        type UpsertUserPermissionPayload = ({
            userUuids: string[];
            emails?: string[];
        } | {
            emails: string[];
            userUuids?: string[];
        }) & {
            action: WorkspaceManagement.Action;
            resourceUuid: string;
            effect: "allow" | "deny";
        };
        type UpdateWorkspaceUserPayload = DateToString<{
            userUuid: string;
            roleSlug: string;
        }>;
        type RemoveUserPermissionPayload = DateToString<{
            userUuid: string;
            resourceUuid: string;
            effect: "allow" | "deny";
        }>;
        type RemoveUserPayload = DateToString<{
            userUuid: string;
        }>;
        const zodRemoveUserErrorReason: z.ZodEnum<{
            invalidUserEmail: "invalidUserEmail";
        }>;
        const zodUpdateUserErrorReason: z.ZodEnum<{
            userNotFound: "userNotFound";
        }>;
        const zodUpsertUserPermissionErrorReason: z.ZodEnum<{
            failedToCreateUsers: "failedToCreateUsers";
            failedToUpsertPermissions: "failedToUpsertPermissions";
        }>;
        const zodRemoveUserPermissionErrorReason: z.ZodEnum<{
            userNotFound: "userNotFound";
        }>;
        type CreateTokenPayload = {
            name: string;
            description?: string | null;
            permissions: WorkspaceManagementTypes.Permission[] | null;
        };
        type CreateTokenResult = {
            token: Token;
        };
        type UpdateTokenPayload = {
            uuid: string;
            name?: string;
            description?: string | null;
            permissions?: WorkspaceManagementTypes.Permission[] | null;
        };
        type UpdateTokenResult = {
            token: Token;
        };
        type AllTokensResult = {
            tokens: Token[];
        };
        type AllEnvVarsResult = {
            envVars: EnvVar[];
        };
        type CreateEnvVarPayload = {
            key: string;
            value: string;
            isSecret: boolean;
            description?: string | null;
        };
        type CreateEnvVarResult = {
            envVar: EnvVar;
        };
        const zodCreateEnvVarErrorReason: z.ZodEnum<{
            keyAlreadyExists: "keyAlreadyExists";
        }>;
        type UpdateEnvVarPayload = {
            uuid: string;
            /** Omit to keep the stored value — that is how a secret is left untouched. */
            value?: string;
            isSecret?: boolean;
            description?: string | null;
        };
        type UpdateEnvVarResult = {
            envVar: EnvVar;
        };
        const zodUpdateEnvVarErrorReason: z.ZodEnum<{
            envVarNotFound: "envVarNotFound";
        }>;
        const zodRemoveEnvVarErrorReason: z.ZodEnum<{
            envVarNotFound: "envVarNotFound";
        }>;
        type AllRolesResult = {
            roles: Role[];
        };
        type RoleExistsBySlugPayload = {
            slug: string;
        };
        type RoleExistsBySlugResult = {
            exists: boolean;
        };
        type CreateRolePayload = {
            name: string;
            slug: string;
            color: WorkspaceManagementTypes.RoleColor;
            description?: string;
            permissions: WorkspaceManagementTypes.Permission[];
        };
        type CreateRoleResult = {
            role: Role;
        };
        const zodCreateRoleErrorReason: z.ZodEnum<{
            slugAlreadyExists: "slugAlreadyExists";
            slugReserved: "slugReserved";
        }>;
        type UpdateRolePayload = {
            uuid: string;
            name?: string;
            color?: WorkspaceManagementTypes.RoleColor;
            description?: string | null;
            permissions?: WorkspaceManagementTypes.Permission[];
        };
        type UpdateRoleResult = {
            role: Role;
        };
        const zodUpdateRoleErrorReason: z.ZodEnum<{
            roleNotFound: "roleNotFound";
            slugReserved: "slugReserved";
        }>;
        const zodRemoveRoleErrorReason: z.ZodEnum<{
            roleNotFound: "roleNotFound";
            slugReserved: "slugReserved";
            roleInUse: "roleInUse";
        }>;
        type CreateFolderPayload = DateToString<{
            name: string;
            emojiSlug: string;
            kind: WorkspaceManagementTypes.FolderKind;
            parentUuid?: string;
        }>;
        type CreateFolderResult = {
            folder: Folder;
        };
        type ListFoldersResult = {
            folders: Folder[];
        };
        type GetFolderResult = {
            folder: Folder;
        };
        type UpdateFolderPayload = DateToString<{
            uuid: string;
            name?: string;
            emojiSlug?: string;
            order?: number;
            parentUuid?: string | null;
        }>;
        type UpdateFolderResult = {
            folder: Folder;
        };
        const zodCreateFolderErrorReason: z.ZodEnum<{
            duplicateName: "duplicateName";
        }>;
        const zodUpdateFolderErrorReason: z.ZodEnum<{
            folderNotFound: "folderNotFound";
            duplicateName: "duplicateName";
        }>;
        const zodRemoveFolderErrorReason: z.ZodEnum<{
            folderNotFound: "folderNotFound";
        }>;
        const zodGetFolderErrorReason: z.ZodEnum<{
            folderNotFound: "folderNotFound";
        }>;
        type CreateStatePayload = DateToString<{
            githubOwner?: string;
            githubRepo?: string;
            defaultBranch?: string;
            contents?: Record<string, unknown>;
        }>;
        type CreateStateResult = {
            state: State;
        };
        type ListStatesResult = {
            states: State[];
        };
        type GetStateResult = {
            state: State;
        };
        type UpdateStatePayload = DateToString<{
            uuid: string;
            contents: Record<string, unknown>;
            /** The version the read returned — see `contentsVersion` on the state. */
            contentsVersion: number;
            lockHolderId?: string;
            snapshotPrevious?: boolean;
        }>;
        type UpdateStateResult = {
            state: State;
        };
        type AcquireStateLockPayload = DateToString<{
            uuid: string;
            holderId: string;
            host: string;
            command: string;
            force?: boolean;
        }>;
        type AcquireStateLockResult = {
            state: State;
        };
        type ReleaseStateLockPayload = DateToString<{
            uuid: string;
            holderId: string;
            force?: boolean;
        }>;
        type ReleaseStateLockResult = {
            state: State;
        };
        const zodGetStateErrorReason: z.ZodEnum<{
            stateNotFound: "stateNotFound";
        }>;
        const zodCreateStateErrorReason: z.ZodEnum<{
            stateLimitReached: "stateLimitReached";
        }>;
        const zodUpdateStateErrorReason: z.ZodEnum<{
            stateNotFound: "stateNotFound";
            stateLocked: "stateLocked";
            contentsVersionMismatch: "contentsVersionMismatch";
        }>;
        const zodRemoveStateErrorReason: z.ZodEnum<{
            stateNotFound: "stateNotFound";
            stateLocked: "stateLocked";
        }>;
        const zodAcquireStateLockErrorReason: z.ZodEnum<{
            stateNotFound: "stateNotFound";
            stateLocked: "stateLocked";
        }>;
        const zodReleaseStateLockErrorReason: z.ZodEnum<{
            stateNotFound: "stateNotFound";
            notLockHolder: "notLockHolder";
        }>;
        type CreateReportPayload = DateToString<{
            title: string;
            description: string;
        }>;
        type CreateReportResult = {
            report: Report;
        };
        type UpsertSessionPayload = DateToString<{
            sessionId: string;
            title: string;
            summary: string;
            finishedAt?: Date | null;
        }>;
        type UpsertSessionResult = {
            session: Session;
        };
    }
    const workspaceKeys: {
        all: () => readonly ["workspaces"];
    };
    const fileKeys: {
        all: () => readonly ["files"];
        listColumns: (s3Filename: string) => readonly ["files", "listColumns", string];
    };
    const userKeys: {
        all: (workspaceUuid: string) => readonly ["users", string];
        getCurrent: () => readonly ["workspaces", "getCurrentUser"];
    };
    const tokenKeys: {
        all: (workspaceUuid: string) => readonly ["tokens", string];
    };
    const envVarKeys: {
        all: (workspaceUuid: string) => readonly ["envVars", string];
    };
    const stateKeys: {
        all: (workspaceUuid: string) => readonly ["states", string];
    };
    const roleKeys: {
        all: (workspaceUuid: string) => readonly ["roles", string];
    };
    const foldersKeys: {
        all: (workspaceUuid: string) => readonly ["folders", string];
    };
}
//# sourceMappingURL=workspaceManagement.d.ts.map