import type { RevenueOrganizationTypes } from "@cargo-ai/types";
import { z } from "zod";
import type { ApiType, DateToString } from "../types.js";
import type { Segmentation } from "./segmentation.js";
export declare namespace RevenueOrganization {
    type AllocationExpirationPolicy = ApiType<RevenueOrganizationTypes.AllocationExpirationPolicy>;
    type AllocationExpirationPolicyInterval = ApiType<RevenueOrganizationTypes.AllocationExpirationPolicyInterval>;
    type Allocation = ApiType<RevenueOrganizationTypes.Allocation>;
    type TerritoryColor = ApiType<RevenueOrganizationTypes.TerritoryColor>;
    type TerritoryMember = ApiType<RevenueOrganizationTypes.TerritoryMember>;
    type Territory = ApiType<RevenueOrganizationTypes.Territory>;
    type Member = ApiType<RevenueOrganizationTypes.Member>;
    type CapacityColor = ApiType<RevenueOrganizationTypes.CapacityColor>;
    type Capacity = ApiType<RevenueOrganizationTypes.Capacity>;
    namespace Api {
        type GetAllocationResult = {
            allocation: Allocation;
        };
        type ListAllocationsPayload = DateToString<{
            membersUuids?: string[];
            capacityUuid?: string | null;
            expirationPolicy?: AllocationExpirationPolicy;
            territoryUuid?: string;
            limit?: number;
            offset?: number;
        }>;
        type ListAllocationsResult = {
            allocations: Allocation[];
        };
        const zodRemoveAllocationErrorReason: z.ZodEnum<{
            allocationNotFound: "allocationNotFound";
        }>;
        type CreateCapacityPayload = DateToString<{
            name: string;
            color: CapacityColor;
            description?: string;
            modelUuid?: string;
            idColumnSlug?: string;
            timeColumnSlug?: string;
            memberCapacity?: number;
            allocationExpirationPolicy?: AllocationExpirationPolicy;
            filter?: Segmentation.Filter;
        }>;
        const zodCreateCapacityErrorReason: z.ZodEnum<{
            invalidFilter: "invalidFilter";
            emptyFilter: "emptyFilter";
            invalidIdColumnSlug: "invalidIdColumnSlug";
            invalidTimeColumnSlug: "invalidTimeColumnSlug";
        }>;
        type CreateCapacityResult = {
            capacity: Capacity;
        };
        type GetCapacityResult = {
            capacity: Capacity;
        };
        type ListCapacitiesResult = {
            capacities: Capacity[];
        };
        const zodRemoveCapacityErrorReason: z.ZodEnum<{
            capacityNotFound: "capacityNotFound";
        }>;
        const zodUpdateCapacityErrorReason: z.ZodEnum<{
            invalidFilter: "invalidFilter";
            emptyFilter: "emptyFilter";
            invalidIdColumnSlug: "invalidIdColumnSlug";
            invalidTimeColumnSlug: "invalidTimeColumnSlug";
            capacityNotFound: "capacityNotFound";
        }>;
        type UpdateCapacityPayload = DateToString<{
            uuid: string;
            name?: string;
            color?: CapacityColor;
            description?: string | null;
            memberCapacity?: number | null;
            modelUuid?: string | null;
            idColumnSlug?: string | null;
            timeColumnSlug?: string | null;
            allocationExpirationPolicy?: AllocationExpirationPolicy | null;
            filter: Segmentation.Filter | null;
        }>;
        type UpdateCapacityResult = {
            capacity: Capacity;
        };
        type SyncMemberPayload = DateToString<{
            connectorUuid?: string;
        }>;
        const zodArchiveMemberErrorReason: z.ZodEnum<{
            memberNotFound: "memberNotFound";
        }>;
        type ArchiveMemberResult = {
            member: Member;
        };
        const zodUnarchiveMemberErrorReason: z.ZodEnum<{
            memberNotFound: "memberNotFound";
        }>;
        type UnarchiveMemberResult = {
            member: Member;
        };
        type GetMemberResult = {
            member: Member;
        };
        type ListMembersResult = {
            members: Member[];
        };
        const zodUpdateMemberErrorReason: z.ZodEnum<{
            memberNotFound: "memberNotFound";
            mailboxNotFound: "mailboxNotFound";
            mailboxAlreadyAttached: "mailboxAlreadyAttached";
        }>;
        type UpdateMemberPayload = DateToString<{
            uuid: string;
            meta?: Record<string, any> | null;
            mailboxUuids?: string[];
        }>;
        type UpdateMemberResult = {
            member: Member;
        };
        type CreateTerritoryPayload = DateToString<{
            label: string;
            color: TerritoryColor;
            description?: string;
            members: RevenueOrganizationTypes.TerritoryMember[];
            fallbackMemberUuid?: string;
        }>;
        type CreateTerritoryResult = {
            territory: Territory;
        };
        type GetTerritoryResult = {
            territory: Territory;
        };
        type ListTerritoriesResult = {
            territories: Territory[];
        };
        const zodRemoveTerritoryErrorReason: z.ZodEnum<{
            territoryNotFound: "territoryNotFound";
        }>;
        const zodUpdateTerritoryErrorReason: z.ZodEnum<{
            territoryNotFound: "territoryNotFound";
        }>;
        type UpdateTerritoryPayload = DateToString<{
            uuid: string;
            label?: string;
            color?: TerritoryColor;
            description?: string | null;
            members?: RevenueOrganizationTypes.TerritoryMember[];
            fallbackMemberUuid?: string | null;
        }>;
        type UpdateTerritoryResult = {
            territory: Territory;
        };
    }
    const territoryKeys: {
        all: (workspaceUuid: string) => readonly ["territories", string];
    };
    const memberKeys: {
        all: (workspaceUuid: string) => readonly ["members", string];
    };
    const capacityKeys: {
        all: (workspaceUuid: string) => readonly ["capacities", string];
    };
    const allocationKeys: {
        all: (workspaceUuid: string) => readonly ["allocations", string];
        list: (workspaceUuid: string, payload: Api.ListAllocationsPayload) => readonly ["allocations", string, {
            membersUuids?: string[] | undefined;
            capacityUuid?: string | null | undefined;
            expirationPolicy?: {
                interval: "hourly";
                minute?: number | undefined;
            } | {
                interval: "daily";
                time?: string | undefined;
            } | {
                interval: "weekly";
                time?: string | undefined;
                weekDay?: number | undefined;
            } | {
                interval: "monthly";
                time?: string | undefined;
                day?: number | undefined;
            } | {
                interval: "quarterly" | "yearly";
                time?: string | undefined;
                day?: number | undefined;
                month?: number | undefined;
            } | undefined;
            territoryUuid?: string | undefined;
            limit?: number | undefined;
            offset?: number | undefined;
        }];
    };
}
//# sourceMappingURL=revenueOrganization.d.ts.map