const [person1, person2] = await client.batch((b) => [
  b.person.create(groupId, {
    name: 'Linus Bolls',
    initials: 'LB',
  }),
  b.person.create(groupId, {
    name: 'Florian König',
    initials: 'FK',
  }),
]);

function createGroup(): Promise<GroupInfo> {
    return Parse.Cloud.run("createGroup");
}

function fetchCodes(groupObjectId: string): Promise<Omit<GroupInfo, "objectId">> {
    return Parse.Cloud.run("fetchCodes", {
        group: groupObjectId
    });
}

type GroupInfo = {
    shortCode: string;
    longCode: string;
    extendedShortCode: string
    objectId: string;
}

type CurrencyCode = string;
type Person = {
    attributes: {
        name: string;
        initials: string;
        GlobalId: string;
        UpdateID: string;
        isDeleted: boolean,
        createdGlobally: Date;
        UpdateInstallationID: string; 
        createdAt: Date;
        updatedAt: Date;
        group: ParseUser;
    }
};

type ParseUser = {
    className: "_User";
    id: string;
}

type Entry = {
    attributes: {
        UpdateInstallationID: string;
        primaryPayer: string;
        UpdateID: string;
        title: string;
        GlobalId: string;
        isPayment: boolean,
        items: [
            {
                P: {
                    // This map is probably be used to model multiple people that purchased something
                    P: Record<string /* some uuid */, number>,
                }
                AM: number, // amount
            }
        ],
        currencyCode: CurrencyCode,
        createdGlobally: Date,
        group: ParseUser;
        createdAt: Date;
        updatedAt: Date;
    }
};

/**
 * @param code Despite the name, only `shortCode` is accepted.
 * @returns
 */
function joinGroupWithAnyCode(code: string): Promise<GroupInfo> {
    return Parse.Cloud.run("joinGroupWithAnyCode", { code });
}

function getCurrencyRates(): Promise<Record<CurrencyCode, number>> {
    return Parse.Cloud.run("getCurrencyRates");
}

function getCodeConfig(deviceType: "ios" | "android"): Promise<string> {
    return Parse.Cloud.run("getCodeConfig", { deviceType });
}

interface QueryParams {
    className: string;
    group: string;
    minDate?: Date;
    limit: number;
    skip: number;
}

function findObjects<T extends Parse.Attributes>(query: QueryParams) {
    return Parse.Cloud.run("findObjects", {
        ...query,
        minDate: query.minDate ?? new Date("1969-12-31T00:00:00.000Z"),
    }) as Promise<FindObjectsResponse<T>>;
}

type FindObjectsResponse<T extends Parse.Attributes> = {
    serverDate: Date;
    results: Parse.Object<T>[];
};

    const j = await joinGroupWithAnyCode("SHO RTC ODE")
    console.log(j);

    const o = await findObjects<Entry["attributes"]>({
        className: "Entry",
        group: j.objectId,
        minDate: undefined,
        limit: 10,
        skip: 0
    });

    console.log(o.results[0].attributes.items[0])