Agilix у вашому AI-асистенті

Accepts or rejects one person waiting to join the club. membershipId comes from list_join_requests; read it first and, with several people of a similar name, ask the user which one is meant. decision is accepted or rejected - always confirm it with the user before calling. skillLevel (novice, beginner, medium or advanced) is the level an accepted member gets; null gives them the club's default level, which get_club_settings shows as defaultSkillLevel - ask the user when they did not say. An accepted person is notified, becomes a club member and, when the club has a welcome message, gets it in their chat with the club; a rejected one is not notified and their request leaves the list. Refused for someone who is not waiting (already answered or never asked). For several people call it once per person. For full club admins only; clubId comes from list_my_clubs.

For the seminar's organizer and its co-admins, on a seminar that accepts each sign-up: accepts or rejects one sign-up (one dog, one day). Call list_seminar_submissions first: seminarId comes from list_my_organized_seminars, submissionId from its rows. Accepting seats the dog when a place is free (on a by-group seminar in the emptiest slot it picked) and otherwise answers acceptedWaiting - it waits for the organizer to hand it a place. groupId (from list_seminar_groups for that sign-up's day, or null) seats the dog in that group at once, even past its limit and whether the entrant picked it or not. Rejecting frees the dog's place, and it stays free until the organizer gives it out - nobody is moved up automatically; a rejection takes no groupId. A seated dog's owner joins the seminar chat and gets the calendar entry; losing the place takes both away. Nobody is notified. Show the user the dog, the day and the decision and call only after their yes. Answers the sign-up's real state afterwards. A seminar that does not approve sign-ups refuses a rejection: use set_seminar_submission_waitlist or remove_seminar_submission there. For several days or dogs call it once per submissionId.

Adds a venue (a place the club trains at: a hall, a field) to the club. Ask the user for its name, the street with its number, the city and the postal code; never make one up. The address is looked up in the club's country to place the venue on the map; when it cannot be found, the venue is saved without a pin as long as the city and postal code are given, otherwise nothing is saved and the answer says what is missing. The venue starts active with one training space; rename or add spaces with rename_training_space and create_training_space, open it for booking with set_opening_hours, and change its booking rules with update_venue. Check list_venues first so you do not add one the club already has, and confirm the details with the user. Returns the new venueId and its training spaces. For full club admins only; clubId comes from list_my_clubs.

Adds a person to a club group (and to its group chat, if it has one). groupId comes from list_club_groups, userId from find_club_member. When find_club_member finds nobody the person is not a club member and cannot be added: check with search_user - they must join the club first, or have their waiting join request accepted.

Adds a club member to the team as a full admin or a trainer. userId comes from find_club_member; when nobody matches there, the person is not a member yet - check search_user and tell the user they must join the club first, never look for a userId another way. With several matches ask which person is meant. hasFullAccess true makes them a full admin who manages the club settings, false a trainer who runs classes; showOnTrainersList shows them to members among the club trainers. Ask the user for both, never assume, and confirm before calling. The person gets a notification, joins the club's team chats and, when they sync every club class to their calendar, gets the club's classes there. Refused for someone already on the team (change them with update_club_admin) and for a non-member. Returns the new adminId. For several people call it once per person. For full club admins only; clubId comes from list_my_clubs.

Writes a training note about a club member's dog, for the club's trainers and admins. clubId comes from list_my_clubs, userId from find_club_member, dogId from list_member_dogs for that userId (a dog with canWriteNotes true). visibleToOwner: true notifies the owner (a push and an inbox entry) and lets them read it; false keeps it to you and the people it is shared with - ask the user which. shareWithUserIds are taken from that dog's shareCandidates in list_member_dogs ([] = nobody); each of them is notified. Show the user the note and whom it reaches, and confirm before calling. Photos are added in the Agilix app. Returns the noteId.

Adds a note to the trainer's agenda (a reminder, a day off, a seminar), for the club's trainers and admins. clubId comes from list_my_clubs: the club whose clock the note is written on, where you are an admin or trainer. sharedWithClubIds are clubs from list_my_clubs where you are an admin or trainer whose trainers and admins will see the note; [] keeps it to you only - ask the user which. startsAt and endsAt are local times on that club's clock, the same day; an all-day note (isAllDay true) runs from 00:00 of its day to 00:00 of the next. repeat: one, or weekly copies on that weekday toEndOfMonth, toEndOfNextMonth or forNextMonth. Nobody is notified; the note also appears in your connected calendar. Returns the noteIds written.

Adds a dues plan members can buy online, or changes one: planId null adds a plan, a planId from get_club_dues changes that plan. name, months (1, 3, 6 or 12) and price (digits with at most two decimals, from 2.00 to 9999.99, in the club's currency) are all required - ask the user for each, never assume; for a change take the ones the user did not mention from get_club_dues. A change applies to future purchases only: members who already paid or renew automatically keep the terms they bought. Confirm with the user first. Returns the planId, or null for a new plan that cannot be told apart from an identical one added at the same moment. For full club admins only; clubId comes from list_my_clubs.

Adds a punch card members can buy online, or changes one: punchCardTypeId null adds a type, a punchCardTypeId from list_punch_card_types changes that type. Every field is required - ask the user for each, never assume; for a change take the ones the user did not mention from list_punch_card_types. name; entries (how many classes it pays for) and validityDays (how many days it stays valid after purchase), both whole numbers from 1; price (digits with at most two decimals, above 0 and up to 9999.99, club currency); rateIds, at least one, from list_club_rates - the card pays only for classes charged at those rates. A change applies to future purchases and to which classes the cards already sold cover. Refused for a rate that is not on the club price list. Confirm with the user first. Returns the punchCardTypeId, or null for a new type that cannot be told apart from an identical one added at the same moment. For full club admins only; clubId comes from list_my_clubs.

Adds a discount code renters type when booking at a venue (voucherId null) or changes one (voucherId from list_venue_price_book). Every call sends the whole code: code (1 to 50 characters, stored in capitals and matched whatever the case), exactly one of percentOff (more than 0, at most 100) or amountOff (PLN off one rental, more than 0) with the other null, redeemLimit (how many rentals in total may use it, at least 1), expiresOn (YYYY-MM-DD, the last day it works, to the end of that day in Polish time; never a past day, except that a change keeping an expired code on its current day is allowed) and isActive (on a change only: false stops it, true brings a retired code back; null keeps it - a new code always starts active, and isActive false on one is refused). On a change, start from the current values in list_venue_price_book and change only what the user asked for. A code already used at this venue is refused. A discount never makes a rental cost less than nothing, and one that leaves too little to pay by card books the rental for free. Confirm the terms with the user first. Returns the code as saved. For full club admins only; clubId comes from list_my_clubs, venueId from list_venues.

Adds an item to a venue's rental price list (rentalServiceId null) or changes one (rentalServiceId from list_venue_price_book). Every call sends the whole item: name, durationMinutes (the rental length, 1 to 1440), price in PLN (1 to 100000, at most two decimals, like 45 or 45.50), trainingSpaceIds (the halls it books, all from list_venues for the same venue), vatRate (vat23, vat8, vat5, vat0 or zw; null on a new item means none, null on a change keeps the current rate) and isActive (on a change only: false takes it off sale, true puts a retired item back; null keeps it as it is - a new item always starts active, and isActive false on one is refused). On a change, start from the current values in list_venue_price_book and change only what the user asked for. While a venue has at least one active item, every rental of it by someone other than a club admin is paid for through that price list; with none left active, people with access book it for free again. Renters already booked keep their booking and price. Confirm the item with the user first. Returns the item as saved. For full club admins only; clubId comes from list_my_clubs, venueId from list_venues.

Tells club members who opted in to receive notifications about free places that this class has available places. Only a public, upcoming class with members at the right skill level actually notifies anyone; Agilix does not check whether places are free. No notifications are sent while the class has a waiting list. Notifications are sent in the background. Only a club admin can announce a class. classId comes from create_classes or list_club_classes. Always confirm with the user before calling.

Takes a dues plan off sale: members can no longer buy it, while those who already paid or renew automatically on it keep what they bought. planId comes from get_club_dues. Always confirm with the user before calling. For full club admins only; clubId comes from list_my_clubs.

Takes a punch card type off sale: members can no longer buy it, while the cards already sold keep working. punchCardTypeId comes from list_punch_card_types. Always confirm with the user before calling. For full club admins only; clubId comes from list_my_clubs.

Makes members accept the club terms again: with membershipId null every member of the club, with a membershipId (from find_club_member) that one member. Each of them is asked to accept the terms in Agilix before their next booking; nobody gets a notification. Refused when the club has no terms - set them first with set_club_terms. Confirm with the user first, and whether they mean everyone or one person; with several find_club_member matches ask which person. For full club admins only; clubId comes from list_my_clubs.

Lets one club member rent a venue without paying for each rental: their rentals there are added up and billed monthly instead. While a monthly bill of theirs is overdue they pay for each rental upfront again, until it is paid. userId comes from find_club_member - when several people match, ask the user which one they mean; someone who is not a member of the club is refused, and someone already among the postPaidRenters of list_venue_price_book too. Booking the venue still needs venue access (grant_venue_access). venueId comes from list_venues. For several people call it once per person. Confirm with the user first. For full club admins only; clubId comes from list_my_clubs.

Cancels (deletes) one class. Everyone with a place is notified and the class leaves their calendars; copies of the class shared with other clubs are not cancelled - to remove the class in every club use delete_class_in_every_club. Settle the club with list_class_form_options first if not yet settled in this conversation. classId comes from list_club_classes. Always confirm the class, date and time with the user before calling.

Stops a member's dues auto-renewal so they are not charged again: a renewal in good standing ends at the end of the period already paid, one whose last payment failed ends at once. The member is not notified, and what they already paid is not refunded (refunds are on the web, refundsPage in get_club_dues). userId comes from get_club_dues, which shows autoRenew; refused when the member has no auto-renewal or it is already cancelled. Always confirm with the user before calling. For full club admins only; clubId comes from list_my_clubs.

Cancels one message still waiting to go to a class's participants, for the club's trainers and admins; nobody is notified. classId comes from list_managed_classes, list_club_classes or get_class, messageId from list_class_messages. Refused for a message that has already been sent. Confirm the message with the user first.

Cancels (deletes) each listed class through the same single-class cancel as cancel_class; everyone with a place is notified and the class leaves their calendars; copies shared with other clubs are not cancelled; reports per class cancelled / not allowed / not found / error with its date; one failing class never stops the others; classIds come from list_club_classes; always confirm the list of classes with their dates and times with the user before calling; for one class use cancel_class.

Changes one club member's skill level (novice, beginner, medium or advanced); it also decides which of the club's level chats they are in. membershipId comes from find_club_member, whose skillLevel shows the current one; with several matches ask the user which person is meant, and confirm before calling. Nobody is notified. The level new members get is set with set_default_skill_level. For full club admins only; clubId comes from list_my_clubs.

Replaces one publishing schedule as a whole: send the complete new schedule - publishAt (YYYY-MM-DDTHH:mm, the club's local time, in the future), every class it should publish and the skill level - not only what changes; a class left out goes off the schedule and stays private. At that time Agilix makes the classes public and tells the club's members, exactly as the app does. For full club admins only; clubId comes from list_my_clubs, autoPublishId and the current classes from list_auto_publishes; classIds are the schedule's own classes plus any from publishableClasses. Show the user the new summary - which classes, which level, when - and save only once they confirm. Refused for a time already past, a class not allowed on it, and a class starting before the publish time. The schedule gets a new autoPublishId, which is returned.

Changes a team member's access and services. adminId comes from list_club_team. Send hasFullAccess and showOnTrainersList every time, taking what the user did not mention from list_club_team. hasFullAccess true makes them a full admin who manages the club settings, false a trainer who runs classes; showOnTrainersList shows them to members among the club trainers. serviceIds (from list_club_services) replaces the services they provide; null keeps them as they are, [] clears them. Refused for the founder. Taking your own full access away ends your access to the club's settings here - say so and confirm first; confirm every change with the user. Nobody is notified. For full club admins only; clubId comes from list_my_clubs.

Looks among all Agilix accounts for a person who is NOT a member of the club, by first name, last name, username or dog name (at least 2 characters; accents and case ignored). Use it only after find_club_member found nobody in this club. Each match carries name and username and no userId: a person outside the club cannot be invited to a class, added to a group or removed, and there is no way to add them to the club from here. A match means the person has an Agilix account but is not a member of this club. Before saying what they must do, call list_join_requests and look for the match's username: when it is there the person has already asked to join and waits for an answer - say so and offer to answer it with respond_to_join_request (membershipId from list_join_requests), after which find_club_member finds the person; never tell them to ask again. Only when it is not there, tell the user that the person must ask to join the club in Agilix first (on their own side: find_club, then join_club), after which their request shows in list_join_requests; then offer request_feature. With several matches ask the user which person they mean. No match means no account under that spelling: ask for another spelling or the username. For club admins and trainers; anyone else gets no matches. clubId comes from list_my_clubs.

For the seminar's organizer and its co-admins: copies every group of one seminar day (name, times, trainer, location, target size) onto another day of the same seminar that has no groups yet, and places each dog in the same group there when that dog also has a seated sign-up on the target day - the others are left out. seminarId comes from list_my_organized_seminars, fromDay and toDay from its days; list_seminar_groups shows both days. Refused when the source day has no groups or the target day already has some (delete or edit those instead). On a seminar priced by group, what the entrant owes is recalculated. Nobody is notified. Show the user both days and call only after their yes. Answers the target day's groups afterwards. For several days call it once per target day.

Gives everyone with access to one club venue (fromVenueId) access to another (toVenueId) too; nobody loses access, and people already on the target stay as they are. Both venueIds come from list_venues and must be two different venues of this club. Confirm with the user first, naming both venues. For full club admins only; clubId comes from list_my_clubs.

Creates an empty participant group in a club (for inviting people together or a group chat). The name is private to club admins (at most 80 characters). Returns the new groupId; add people with add_member_to_group. clubId comes from list_my_clubs.

Adds a rate to the club's price list, in the club's currency, so classes can be charged at it. name and amount are required - ask the user for both, never assume; amount is digits with at most two decimals, up to 9999.99 (e.g. "45" or "45.50"). Check list_club_rates first so you do not add one the club already has, and confirm the name and amount with the user. Returns the new rateId, or null when it cannot be told apart from another rate created with the same name at the same moment - then read it from list_club_rates. For full club admins only; clubId comes from list_my_clubs.

Adds a service to the club - something its trainers offer and a class can be set to in the class form (list_class_form_options). name is required; placeLimit is how many people may book it across the club at the same time (1 to 1000), null for unlimited - ask the user, never assume. Check list_club_services first so you do not add one the club already has, and confirm the name and limit with the user. Returns the new serviceId, or null when it cannot be told apart from another service created with the same name at the same moment - then read it from list_club_services. For full club admins only; clubId comes from list_my_clubs.

Adds a training space (a hall, ring or field) to a club venue. For club admins and trainers. venueId comes from list_venues; a venue the club does not have yet is added first with add_venue, which comes with one space. Confirm the name with the user first. Returns the new trainingSpaceId, or null when it cannot be told apart from another space created with the same name at the same moment - then read it from list_venues.

Creates one class per date after checking every date is free. Asks back (needs_input) instead of guessing club, venue, spaces, start, name or trainer. Call prepare_classes first and create only after the user confirmed the summary. Returns the created class IDs with their local start times, or the unavailable dates if any clash with the calendar or with each other, or asks for missing information. Classes created not public can be made public later at a set time with schedule_auto_publish.

For the seminar's organizer and its co-admins: creates a group on one day of a seminar (groupId null) or edits one (groupId from list_seminar_groups for that day). seminarId comes from list_my_organized_seminars, day from its days; read list_seminar_groups for that day first. A group has a name, start and end time (HH:mm, the end after the start), and optionally a trainer, a location and a target size (capacityTarget, 1-100). On a seminar where entrants pick time slots each group is a slot they sign up for, so it needs a limit, and a limit below the dogs already seated in it is refused. An edit replaces every field: send the group's current value for each field the user is not changing - null clears the trainer, location or limit. Never invent a time, name or limit the user did not give - ask. Show the user the day and every field of the group to be saved and call only after their yes. Nobody is notified. Answers the day's groups afterwards, with the new groupId for a created group. For several groups call it once per group, or copy a whole day with copy_seminar_groups_from_day.

Deletes this class AND every copy shared with other clubs - the app's "delete in every club" option; a class that is not shared is simply deleted. Each club's participants are notified and the class leaves their calendars, exactly as a class delete in the app. Refused whole - nothing deleted - when you may not delete one of the copies. classId comes from list_managed_classes or list_club_classes. Before calling, name the class, its date and time and the clubs it is shared with, and delete only once the trainer confirms.

Deletes one of your class templates for a club. Templates are per user AND club. The template is permanently removed and cannot be undone. Always confirm the template name with the user before calling. Settle the club first with list_class_form_options if not yet settled in this conversation.

Deletes a club group: its members stay in the club and keep their class bookings, but the group's chat closes for everyone in it. It cannot be undone. groupId comes from list_club_groups; confirm the exact group with the user before calling. Nobody is notified. For full club admins only; clubId comes from list_my_clubs.

Deletes a rate: it leaves the club price list and can no longer be picked for a class. rateId comes from list_club_rates. Always confirm with the user before calling. For full club admins only; clubId comes from list_my_clubs.

Deletes a club service: it leaves the list of services and can no longer be picked for a class or booked. serviceId comes from list_club_services. Always confirm with the user before calling. For full club admins only; clubId comes from list_my_clubs.

Deletes a club venue: it leaves the club, its training spaces can no longer be booked or picked for a class, and its venue chat ends. venueId comes from list_venues. Always confirm with the user before calling. For full club admins only; clubId comes from list_my_clubs.

Removes one template from the club's message library, for the club's trainers and admins; messages already scheduled from it still go out with their own text. clubId comes from list_my_clubs, templateId from list_message_templates. Nobody is notified; confirm the template with the user first.

Deletes one publishing schedule: its classes stay private and nobody is notified. For full club admins only; clubId comes from list_my_clubs, autoPublishId from list_auto_publishes. Confirm the schedule with the user first. To take only some classes off it, use remove_classes_from_auto_publish.

For the seminar's organizer and its co-admins: deletes one group of a seminar day. groupId comes from list_seminar_groups for that day. seminarId comes from list_my_organized_seminars, day from its days; read list_seminar_groups for that day first. On a seminar where entrants sign up by day the group, its members' places in it and its chat room go; the participants stay on the seminar and in its main chat. On a seminar where entrants pick time slots the group is a slot, and it is refused while any sign-up picked it, waiting ones included - the refusal names them. A sign-up keeps its pick even after it is moved to another slot, so only removing those sign-ups clears the way; otherwise keep the slot. It cannot be undone. Nobody is notified. Show the user the group, its day and its members and delete only after their yes. Answers the day's remaining groups.

Deletes one of your own training notes with its photos, for everyone who could read it. noteId comes from list_training_notes (a row with isMine true). Refused for a note you did not write. Nobody is notified; confirm the note with the user first.

Deletes a training space from a club venue; it can no longer be booked or chosen for classes. Needs full club admin access. trainingSpaceId comes from list_venues. Always confirm with the user before calling.

Deletes one of your own agenda notes (and its copy in your connected calendar), for trainers and admins. noteId comes from list_agenda_notes (a row with isMine true); a repeated note is several notes - delete each. Refused for a note you did not write. Nobody is notified; confirm the note with the user first.

Detaches one copy of a shared class from the others: it keeps its participants, venue and slots and becomes an ordinary class of its club; the other copies stay shared with each other. Nothing is deleted and nobody is notified. For trainers and admins of that copy. classId comes from list_managed_classes or list_club_classes (the copy in the club to detach). Refused for a class that is not shared. Confirm with the user first.

Sends one club member an e-mail from the club, as the app's member profile does: Agilix sends it in the club's name, and the member also gets a push notification with the same text that opens the club. Nobody's e-mail address is shown to anyone, the sender included. userId comes from find_club_member; with several matches ask the user which person is meant. Show the user the exact text and send only once they confirm it. For several members call it once per person; a club can send only a limited number of e-mails per hour. For club admins and trainers; clubId comes from list_my_clubs.

Ends a punch card at once: its unused entries can no longer be used. Nothing is refunded and the member is not notified; a refund of a card bought online is on the web (punchCardsPage of list_club_punch_cards). punchCardId comes from list_club_punch_cards - when the member has several cards, ask the user which one. Refused for a refunded card and for one that has already ended. It can be undone with set_punch_card_expiry. Always confirm with the user before calling. For full club admins only; clubId comes from list_my_clubs.

Moves a punch card's end 7 days later - counted from today when the card has already ended, which brings it back. The member is notified. punchCardId comes from list_club_punch_cards - when the member has several cards, ask the user which one. Refused for a refunded card and for a card that never expires (give it an end day with set_punch_card_expiry instead). For a different day than a week on, use set_punch_card_expiry. Confirm with the user first; every call adds another week. Returns the card with its new expiresOn. For full club admins only; clubId comes from list_my_clubs.

Finds club members by first name, last name, username or dog name (accents and case ignored; every word must match). Returns ALL matches: when there is more than one, ask the user which person they mean - never pick one yourself. When nobody matches, the person is not a member of this club: check with search_user whether they have an Agilix account, and never look for their userId any other way. Its userId is also what add_club_admin takes to put a member on the club team, and what list_member_dues, add_dues_entry and cancel_dues_auto_renew take for their membership dues, and grant_post_paid to bill their venue rentals monthly. Its membershipId is what set_member_paused (pause or resume; membershipPaused shows the state), set_member_skill_level (skillLevel shows the current one) and ask_members_to_accept_terms take, and list_member_rates, set_member_rate and remove_member_rate for the member's custom rates, set_member_prepayment for paying before booking, and issue_punch_card to give them a punch card; the level new members get is set with set_default_skill_level. Each match carries note, the club team's private note about them (null when there is none), which set_member_note replaces; its userId is also what email_club_member takes to e-mail them from the club, what get_member_attendance takes for a full admin to read their attendance, and what list_member_dogs and list_training_notes take for training notes about their dogs. For club admins and trainers; clubId comes from list_my_clubs.

Writes off a debt the club kept when someone was removed from a class: nothing is collected, the debt disappears from get_club_finances and the write-off stays in the club's payment history. It cannot be undone and the person is not notified. outstandingPaymentId comes from get_club_finances' retainedDebts. Always confirm with the user before calling; when the person actually paid, use mark_debt_paid instead. For full club admins only; clubId comes from list_my_clubs.

Gets the details of one of your class templates for a club. Templates are per user AND club. Returns all fields with resolved names (venue, spaces, trainers, services, rate) instead of ids. Deleted items are marked as stale. Settle the club first with list_class_form_options if not yet settled in this conversation.

Shows one club member's record in this club over the last 1 to 24 months (months), as the app's member attendance screen does: every class they were booked on with its start (the club's local time), length, dogs, training spaces, whether it is upcoming and whether they were marked absent; a summary of classes attended, missed and upcoming (a class with two dogs counts once); and the training spaces they rented themselves. userId comes from find_club_member; with several matches ask the user which person is meant. Refused for someone who is not a member. For full club admins only; clubId comes from list_my_clubs.

Lists the club's classes of one month that had at least one booking, as the app's monthly activity screen does: each with its start (the club's local time), length, places taken out of all places, the training spaces, the services booked, and every participant with participationId, name, dog and status (approved = booked, didNotParticipate = marked absent). year and month (1 to 12) are the calendar month the user names; ask when unclear. For the whole year in figures use get_club_stats. For full club admins only; clubId comes from list_my_clubs.

Shows how much one trainer ran in this club, as the app's trainer stats screen does: per month (YYYY-MM, the club's local time, newest first) the number of classes they were the trainer of and the minutes, counting classes with no bookings too, since the slot was held; with month set, also that month class by class (start, length, training spaces). trainerId is the userId of a team member from list_club_team; with several people of that name ask the user which one. For full club admins only; clubId comes from list_my_clubs.

Shows the club's membership dues: whether dues are tracked (duesTracking) and sold online (duesOnline), whether online sales could be turned on (onlineReady: dues tracking on, PLN, and the payout account ready), the dues plans on sale with their planId, and every member with userId, the day their paid membership ends (expiresOn, null when they never paid) and their auto-renewal (autoRenew, null when none). Read it before set_dues_tracking, set_dues_online, save_dues_plan or archive_dues_plan, and for the userId list_member_dues, add_dues_entry and cancel_dues_auto_renew take. Refunds are done on the web only: refundsPage is the link to give the user. For full club admins only; clubId comes from list_my_clubs.

Shows what the club is owed. unpaidTotal is the club's own total of unpaid class fees. classFees are what members owe for classes they attended and have not paid yet, each with participationId, the person, dog, class, its start (club clock) and price; by default from the last six months, includeOlderClasses true reaches every past class. retainedDebts are what the club kept when an admin removed someone from a class and chose to keep the fee, each with outstandingPaymentId. Read it before settle_class_fee, mark_debt_paid or forgive_debt, and when the user asks who owes the club money. For full club admins only; clubId comes from list_my_clubs.

Shows a club's settings: details (name, address text, country, time zone, agenda colour, description, phone, Facebook page, map pin), terms and welcome message, participation rules, the empty-class cleanup (null when off), the default skill level of new members, whether dues are tracked, the tags, and the Agilix Club licence (null when Agilix does not sell it yet). A club without the licence still records prices, who owes and payments marked by hand, but takes no money online: no card prepayment at booking, no online dues or punch-card sales, no card hall bookings. The licence is bought and managed only on the web - when canCollectOnline is false, give the user licencePage. For full club admins only; clubId comes from list_my_clubs. Read it before changing anything with update_club_details, set_club_pin, set_club_terms, set_participation_rules, set_empty_class_cleanup or set_default_skill_level, so you can tell the user what changes; the tags change with list_club_tags and set_club_tags, the services with list_club_services, the team of admins and trainers with list_club_team, membership dues with get_club_dues and set_dues_tracking. The logo, the photos and the contact e-mail are managed on the web only: logoPage and photosPage are the links to give the user.

Shows the club's statistics, as the app's club stats screen does: for each recent month (YYYY-MM) the number of classes, the minutes of training, the share of places taken (percent of all places in that month's classes) and the average group size; the members who trained the most hours; and how many bookings each service had. Read it when the user asks how the club is doing. For one month class by class use get_club_month_activity, for one trainer get_trainer_stats, for one member get_member_attendance. For full club admins only; clubId comes from list_my_clubs.

Lists the classes held at a venue between two local dates (the venue's local time, at most 31 days): who created each class, when, how long and in which training spaces, including other clubs using the venue. Classes only - it never shows rentals: for who rented training spaces call get_venue_rentals with the same venue and dates. Club admins and trainers only. venueId comes from list_venues.

Shows a venue's weekly opening hours, day by day: time windows (HH:mm, the venue's local time), the training spaces open in each, who may book them and the rental lengths offered. Club admins and trainers only. venueId comes from list_venues. openingHoursId is what set_opening_hours_access takes.

Lists who rented training spaces at a venue between two local dates (the venue's local time, at most 31 days): the renter's name, when, how long and which training spaces. Rentals only - classes held at the venue come from get_venue_bookings, so call both when the user asks who used the venue. Renters need not be club members. Club admins and trainers only. venueId comes from list_venues; when the club has several venues and the user did not name one, ask which venue, or call it once per venue.

Gives one club member access to a club venue: they may then rent its training spaces and join its venue chat. userId comes from find_club_member - when several people match, ask the user which one they mean; someone who is not a member of the club is refused, and someone already on list_venue_access too. venueId comes from list_venues. For several people call it once per person, or copy a whole list from another venue with copy_venue_access. Confirm with the user first. For full club admins only; clubId comes from list_my_clubs.

Moves one person from a class's waiting list onto the class with the dogs they asked for, for the club's trainers and admins, exactly as the app does: it takes the place even past the slot limit (the trainer decides), the place is unpaid like any new booking, and the person is notified they got the place. classId comes from list_managed_classes or list_club_classes, waitlistEntryId from list_class_waitlist. Confirm the person with the user first, and say when the class is already full.

Takes back one entry marked on a punch card by mistake, so the member has it again. punchAt is one of the card's punches from list_club_punch_cards, copied exactly - when the user names a day with several entries, ask which one. The member is not notified. punchCardId comes from list_club_punch_cards - when the member has several cards, ask the user which one. Refused for a refunded card and when the card has no entry used at exactly that moment. Confirm with the user first. For several entries call it once per entry. For full club admins only; clubId comes from list_my_clubs.

Invites every member of a club group to a class. People already on the class and members with a paused membership are skipped; the result says how many were invited. Settle the club with list_class_form_options first if not yet settled in this conversation. Never mention the group name to participants. groupId comes from list_club_groups, classId from list_club_classes.

Invites one person to a class; they get a notification and can accept. An invitation does not hold a slot. Settle the club with list_class_form_options first if not yet settled in this conversation. Refused when the person is already on the class. For several people call it once per person, or use invite_group_to_class. classId comes from list_club_classes, userId from find_club_member. When find_club_member finds nobody the person is not a club member and cannot be invited: check with search_user - they must join the club first, or have their waiting join request accepted.

Gives one club member a punch card (karnet) by hand, for entries they paid the club outside Agilix: no money is taken, and the member is notified about the new card. membershipId comes from find_club_member - when several people match, ask the user which one they mean; when nobody matches, the person is not a member of this club and cannot get a card. name, entries (whole number, 1 to 1000) and expiresOn (YYYY-MM-DD, the last valid day on the club calendar, today or later; null = never expires) are all required - ask the user for each, never assume. Check list_club_punch_cards first so the member does not get a second card by mistake (a new card like one the member already holds is renew_punch_card), confirm the person, entries and day with the user, and never call it again after a timeout or an error - read list_club_punch_cards to see whether it was issued. Returns the new punchCardId. For several members call it once per member. For full club admins only; clubId comes from list_my_clubs.

Lists everyone on one class for the club's trainers and admins: each row's participationId, the person (userId, name), their dog and status - approved (booked), didNotParticipate (booked, marked absent), invited (an invitation that holds no place), rejected (declined, holds no place) or forfeited (payment history). One person with two dogs has two rows. Counts only approved and didNotParticipate as booked places. classId comes from list_managed_classes, list_club_classes or get_class. The participationId is what mark_attendance, remind_class_invitation and set_participant_price take; people waiting for a place are in list_class_waitlist.

Lists the club's saved message texts for scheduled class messages, for the club's trainers and admins: templateId and text, newest first. clubId comes from list_my_clubs. Offer one when the user schedules a message with schedule_class_message (pass its templateId and its text, edited if the user wants); keep the library with save_message_template and delete_message_template.

Lists the club's publishing schedules: each schedule (autoPublishId) makes a set of not-yet-public classes public at a set time (the club's local time) with a chosen skill level, and tells the club's members about the new classes. Also lists publishableClasses - the club's upcoming classes that are not public yet and are on no schedule - which are the classIds schedule_auto_publish takes. For full club admins only; clubId comes from list_my_clubs; includePast also shows schedules whose time has passed but that have not run yet. Change one with update_auto_publish, remove_classes_from_auto_publish or delete_auto_publish.

Lists one member's custom rates: for each, the club rate it applies to (rateId, rateName, standardAmount) and the customAmount this member is charged instead, with the overrideId remove_member_rate takes. membershipId comes from find_club_member - when several people match, ask the user which one they mean. Change or add one with set_member_rate. For full club admins only; clubId comes from list_my_clubs.

Lists one club member's dogs, for the club's trainers and admins writing training notes. clubId comes from list_my_clubs (a club where you are an admin or trainer), userId from find_club_member; refused for someone who is not a member of that club. Each dog carries dogId, name, canWriteNotes (whether you may write about it) and shareCandidates - the club team members (userId, name, club) a note about that dog can be shared with, the only source of add_training_note's shareWithUserIds; ask the user whom to share with, never pick. Read the notes already written with list_training_notes and write one with add_training_note.

Lists one member's dues payments at the club, newest expiry first: entryId, price, the days the period starts and ends (club calendar), source (manual = recorded by an admin, online = paid once in Agilix, autoRenew = an auto-renewal) and the refunded amount. userId comes from get_club_dues or find_club_member - when several people match, ask the user which one they mean. Read it before add_dues_entry so a payment is not recorded twice. For full club admins only; clubId comes from list_my_clubs.

Lists the training notes about one club member's dogs that you wrote or that a colleague shared with you, newest first, for the club's trainers and admins. clubId comes from list_my_clubs, userId from find_club_member; refused for someone who is not a member of that club. Each row: noteId, dog, content, when it was written, visibleToOwner (whether the owner reads it), the author, isMine and whom it is shared with. noteId of a row with isMine true is what update_training_note and delete_training_note take; write a new note with add_training_note (dogs and share candidates from list_member_dogs).

Lists the agenda notes of the club's trainers and admins between two local dates (at most 62 days): your own notes, plus notes colleagues shared with the clubs you pass in clubIds (clubs from list_my_clubs where you are an admin or trainer; [] shows only your own). Each row: noteId, title, note, start and end on the clock of the club it was written on, isAllDay, isMine, the author's name and - on your own notes only - clubId (the club it was written on) and the clubs it is shared with. noteId is what update_agenda_note and delete_agenda_note take; add one with add_agenda_note.

Call this first whenever the user wants to create, change or manage club classes or templates, or list a club's classes. Without clubId it asks which club; the club is then kept for the conversation. Never assume venue, space, date or start time - ask, offering these options. clubId comes from this tool itself when it returns needs_input. A service the class needs but the club lacks is added by a full admin with create_club_service, and a rate missing from the price list with create_club_rate (list_club_rates shows the price list).

Lists your own class templates for a club. Templates are per user AND club. Returns templateId, templateName, and className for each template. Pass templateId to prepare_classes or create_classes to use a template. Settle the club first with list_class_form_options if not yet settled in this conversation.

Lists a club's classes between two local dates (the club's local time, at most 62 days), with classId, start, length and whether you may manage each. Only club admins and trainers get results. Settle the club with list_class_form_options first if not yet settled in this conversation. clubId comes from list_class_form_options; use get_class for participants and free slots.

Lists the participant groups a club admin saved (e.g. "Tuesdays 18:00") with their members. Group names are private to club admins: never repeat a group name to anyone else or put it in an invitation. chatTitle is the name members see on the group chat (null until a chat title is set). Full club admins rename a group with rename_club_group, set its chat title with set_group_chat_title and delete it with delete_club_group. clubId comes from list_my_clubs.

Lists people waiting for a club admin to accept them into the club, each with membershipId, name and username. A full club admin accepts or rejects them with respond_to_join_request, which takes the membershipId from here. A person search_user found is looked up here by username: when they are listed they have already asked to join, so the next step is answering their request with respond_to_join_request, not asking again. For full club admins only; clubId comes from list_my_clubs.

Lists every member of a club with userId, membershipId, name, username, dog names, skillLevel and membershipPaused. A full club admin changes a member with set_member_paused, set_member_skill_level or ask_members_to_accept_terms (membershipId from here), and the level new members get with set_default_skill_level. For club admins and trainers. Call list_my_clubs first for clubId; to look for one person use find_club_member instead.

Lists the punch cards (karnety) the club's members hold, bought online or issued by an admin: punchCardId, the holder (name, or null when they have since left the club) and their membershipId, the card name, entriesLeft, punches (the moments each entry was used), expiresOn (the last valid day on the club calendar, null when it never expires) and isRevoked (refunded in full, no longer usable). Read it before issue_punch_card so a member does not get a second card by mistake, and for the punchCardId of renew_punch_card, extend_punch_card, expire_punch_card, set_punch_card_expiry, add_punch and remove_punch (which takes one of the punches back verbatim). When a member has several cards, ask the user which one they mean. Online purchases' history and their refunds are on the web only: punchCardsPage is the link to give the user. For full club admins only; clubId comes from list_my_clubs.

Lists the club's price list - the rates a class is charged at in the class form (list_class_form_options) - each with rateId, name, amount and currency. Read it before create_club_rate, update_club_rate or delete_club_rate, for the rateId set_member_rate gives one member a custom amount on, and for the rateIds save_punch_card_type lets a punch card pay for. For full club admins only; clubId comes from list_my_clubs.

Lists the reviews members wrote about a club, newest first, with the club's public reply under each. reviewer is the signature the author chose (what every reader sees) and className the class they attended. canReply says whether the caller may answer it with reply_to_club_review: a full admin answers every review, a trainer only reviews of classes they ran. canReport says whether the caller may report it to Agilix with report_club_review (full admins only); report shows a report already sent and whether Agilix has settled it. isHidden marks a review Agilix took down - only full admins see those. For full admins and the trainers of the club; clubId comes from list_my_clubs.

Lists the club's services - what its trainers offer and what a class picks from in the class form (list_class_form_options) - each with serviceId, name and placeLimit: how many people may book that service across the club at the same time, null when unlimited. Read it before create_club_service, update_club_service or delete_club_service, and for the serviceIds update_club_admin sets on a trainer. For full club admins only; clubId comes from list_my_clubs.

Shows every tag Agilix offers clubs (what the club does: sports, training, grooming, health), grouped, each with isOnClub telling whether this club carries it. People find clubs by these tags. Read it before set_club_tags so you use the exact labels. For full club admins only; clubId comes from list_my_clubs.

Lists a club's venues (addresses) with their venueId, their rental settings (how many days ahead renters may book, whether and until how many hours before renters may cancel, the minutes kept free between rentals and around them) and their training spaces (halls, rings) with trainingSpaceId. Call it before any tool that needs a venueId or trainingSpaceIds. A full club admin adds a venue with add_venue, changes one with update_venue, deletes one with delete_venue, and manages who may book it with list_venue_access, grant_venue_access, remove_venue_access and copy_venue_access, and runs its rental price list, discount codes and monthly-billed renters from list_venue_price_book. clubId comes from list_my_clubs.

Lists ALL classes of EVERY club you administer between two local dates (each club's local time, at most 62 days), grouped by club, with free slots and pending invitation counts for each class. For a single club's calendar use list_club_classes instead. For participants of a class use get_class; to run it - attendance, invitation reminders, participant prices, the waiting list - use list_class_roster and list_class_waitlist; messages scheduled to its participants are in list_class_messages.

Lists the punch cards (karnety) the club sells online: punchCardTypeId, name, number of entries, how many days a card stays valid after purchase, price in the club currency and the club rates whose classes it pays for (rateIds and rateNames, from list_club_rates). Read it before save_punch_card_type or archive_punch_card_type. A card given to one member by hand is issue_punch_card instead. For full club admins only; clubId comes from list_my_clubs.

Lists the messages scheduled to go to one class's participants in the class chat, for the club's trainers and admins: messageId, the text, how many minutes before the start it goes out, the send time (the club's local time) and its status - waiting, delivered, failed, or noParticipants (it went out when nobody was booked). classId comes from list_managed_classes, list_club_classes or get_class. messageId is what cancel_class_message takes; schedule a new one with schedule_class_message.

Lists the club's team - its founder, full admins and trainers - each with adminId, userId, name, username, isFounder, hasFullAccess (true = full admin who manages the club settings, false = trainer), showOnTrainersList (shown to members among the club trainers), the services they provide and hasTrainerProSeat (their Trainer Pro plan covers this club). Read it before add_club_admin, update_club_admin or remove_club_admin; adminId for those comes from here. Its userId is the trainerId get_trainer_stats takes for a trainer's classes and hours. For full club admins only; clubId comes from list_my_clubs.

Lists every change made to the club's class fees, as the app's club payment history does: which fee (class and dog), whose fee (the member's userId and name), when it was recorded (the club's local time), the amount, the status before and after (unpaid, paid by cash, by card, by punch card) or that it was forgiven, and which admin did it. showAll: false covers the last six months, true the last two years. Read it when a member disputes a fee or the user asks who marked something paid; what is still owed is in get_club_finances. For full club admins only; clubId comes from list_my_clubs.

For the seminar's organizer and its co-admins: reads one day's groups of a seminar - groupId, name, start and end time, trainer, location, the target size and members (memberId, submissionId, dog, the entrant's first name, position) - plus the day's participant pool: every seated sign-up of that day (submissionId, dog, first name) with the groupIds it already sits in, placed or not (one dog may be in several groups of a day), and isPublished - whether the day's groups show on the seminar page and in each participant's schedule. seminarId comes from list_my_organized_seminars, day from its days. A groupId from here is what set_seminar_submission_approval and set_seminar_submission_waitlist take to seat a dog in a chosen group of that sign-up's day. The day's groups are built from here: save_seminar_group creates or edits a group and delete_seminar_group deletes one (groupId); assign_to_seminar_group places a pool participant (submissionId) in a group; move_seminar_group_member and remove_seminar_group_member take a memberId; copy_seminar_groups_from_day copies one day's groups onto an empty day; publish_seminar_groups_day shows or hides the day's groups for the participants.

For the seminar's organizer and its co-admins: lists the seminars the signed-in user runs in Agilix, as the organizer or a co-admin - seminarId (for list_seminar_submissions and list_seminar_groups), seminarSlug, name, days, the sign-up mode (byDay: entrants pick days; byGroup: entrants pick time slots), whether the organizer accepts each sign-up, visibility (open, inviteOnly, unpublished) and manageUrl, the seminar's management page in Agilix. When the seminar the user names matches more than one row, ask which one - never pick. Creating or editing a seminar, its photos, fees, refunds, free access and co-admins stay on manageUrl. Empty when the user runs no seminar.

For the seminar's organizer and its co-admins: lists every sign-up of one seminar, one row per dog and day - submissionId (for set_seminar_submission_approval, set_seminar_submission_waitlist, set_seminar_payment_status and remove_seminar_submission), day, dog, the entrant's first and last name and username, state (seated; acceptedWaiting - accepted, no place free yet; waitlisted; awaitingApproval; rejected), payment status (unpaid, paid, refunded), paidOnline (paid through Agilix: a refund is made on the seminar's payments page in Agilix), the sign-up time in Polish time and, on a by-group seminar, the slots the entrant picked (groupId, name, times, capacity, taken, whether the dog sits there) plus pickedGroupIds - every slot the sign-up still picked, kept even after it is seated or moved elsewhere. seminarId comes from list_my_organized_seminars; any other seminar is refused. Rows run by day, seated first, then in sign-up order - the order of the waiting list. When the person or dog the user names has several rows, ask which day.

Lists the people waiting for a place on one full class, in their order, for the club's trainers and admins: waitlistEntryId, the person, the dogs they asked to bring and since when they wait (the club's local time). A waiting person holds no place and is not on list_class_roster. classId comes from list_managed_classes or list_club_classes. The waitlistEntryId is what promote_from_waitlist and remove_from_waitlist take.

Lists the people given access to a club venue - they may rent its training spaces and are in its venue chat - each with accessId, userId, name and username. Read it before grant_venue_access (someone already listed is refused) and for the accessIds remove_venue_access takes. venueId comes from list_venues. For full club admins only; clubId comes from list_my_clubs.

Records that a member paid a class fee in cash outside Agilix; it leaves get_club_finances' classFees and goes into the club's payment history. No money is taken and the member is not notified. participationId comes from get_club_finances' classFees - when the user names a person with several unpaid classes, ask which one. method is paidByCash: paidByCard is refused, since card payments are recorded by Agilix when the member pays online. Refused when the club neither settles payments (set_payment_settlement) nor takes class payments through Stripe. Confirm the person, class and amount with the user first; for several fees call it once per fee. For full club admins only; clubId comes from list_my_clubs.

Records that someone paid a debt the club kept when they were removed from a class, in cash (paidByCash) or by card (paidByCard) - ask the user which. No money is taken and the person is not notified. outstandingPaymentId comes from get_club_finances' retainedDebts; confirm the person and amount with the user first. To write a debt off without collecting it use forgive_debt instead. For full club admins only; clubId comes from list_my_clubs.

Marks whether one booked participant came to a class, for the club's trainers and admins, exactly as the app's attendance switch: attended true keeps the place as attended, false marks the person absent (the place stays taken). It changes one row - one dog; for a person with two dogs, or for the whole class, call it once per row. classId comes from list_managed_classes or list_club_classes, participationId from list_class_roster. Refused for an invited, rejected or forfeited row: only a booked participant has attendance. Nobody is notified.

For the seminar's organizer and its co-admins: moves one group membership to another group of the same day, or to another position in its own group. seminarId comes from list_my_organized_seminars, day from its days; read list_seminar_groups for that day first. memberId comes from a group's members, targetGroupId from its groups (the same group to reorder), position counts from 0 at the top of the target group (past the end = last). A dog already in the target group is refused. The dog leaves the old group and its chat and gets the new group's; on a seminar where entrants pick time slots the new slot becomes its pick. Nobody else moves: a place freed in a group stays free until the organizer fills it. On a seminar priced by group, what the entrant owes is recalculated. Nobody is notified. Show the user the dog, both groups and the day and call only after their yes. Answers the day's groups afterwards.

For the seminar's organizer and its co-admins: puts one sign-up (one dog, one day) on the waiting list (onWaitlist true) or takes it off (false). Call list_seminar_submissions first: seminarId comes from list_my_organized_seminars, submissionId from its rows. Taking a dog off the list seats it even when the day or slot is full - the organizer decides the seminar takes one more - and also accepts a sign-up still awaiting approval; on a by-group seminar it lands in the emptiest slot it picked, or in groupId (from list_seminar_groups for that sign-up's day, or null) when given, even past that group's limit. Putting a seated dog on the list frees its place, and it stays free until the organizer hands it out - the next one waiting is not moved up; onWaitlist true takes no groupId. A seated dog's owner joins the seminar chat and gets the calendar entry; losing the place takes both away. Nobody is notified. Show the user the dog, the day and the move and call only after their yes. Answers the sign-up's real state afterwards. For several days or dogs call it once per submissionId.

Sets the name of a club group's chat - the name every member of the group sees on the chat (at most 80 characters). Ask the user for it: never reuse the group name, which stays private to club admins. An open chat is renamed for its members at once; a group without a chat gets the title ready for when an admin opens the chat in the Agilix app. groupId comes from list_club_groups, whose chatTitle shows the current one. Nobody is notified. For full club admins only; clubId comes from list_my_clubs.

Pauses a club membership or resumes it. A paused member stays in the club but leaves the club members chat until resumed; resuming puts them back. membershipId comes from find_club_member, whose membershipPaused shows the current state; with several matches ask the user which person is meant, and confirm before calling. Nobody is notified. For several people call it once per person. For full club admins only; clubId comes from list_my_clubs.

Dry run of creating one or more club classes. Call it before creating to validate the class details. It returns either open questions with real options (needs_input) or a summary plus availability for every date (checking against the calendar or with each other). Answer every returned question with the user, never pick an option yourself. Nothing is saved.

For the seminar's organizer and its co-admins: shows one day's groups to the participants (published true) or hides them again (false). A published day shows its groups on the seminar page and in each participant's own schedule (their get_my_seminar_schedule); a hidden one shows nothing. seminarId comes from list_my_organized_seminars, day from its days; read list_seminar_groups for that day first. Its isPublished says the current state. Nobody is notified. Show the user the day and the change and call only after their yes. Answers the day's groups afterwards. For several days call it once per day.

For the seminar's organizer and its co-admins: places one participant of a seminar day in a group of that day. seminarId comes from list_my_organized_seminars, day from its days; read list_seminar_groups for that day first. groupId comes from its groups, submissionId from its participants - every seated sign-up of the day, placed or not. One dog may sit in several groups of a day (a morning and an afternoon group), so a dog already in other groups can be added; one already in this group is refused. A sign-up still waiting or awaiting approval is not in the participants: give it a place first with set_seminar_submission_waitlist or set_seminar_submission_approval. The dog joins the end of the group, even past its target size; the entrant gets the group's chat and its calendar entry. On a seminar priced by group, what the entrant owes is recalculated. Nobody is notified. Show the user the dog, the group and the day and call only after their yes. Answers the day's groups afterwards. For several dogs call it once per submissionId.

Records dues a member already paid the club outside Agilix (cash, transfer): no money is taken and the member is not notified. price is digits with at most two decimals, above 0 and up to 9999.99, in the club currency; expiresOn (YYYY-MM-DD, club calendar) is the last day the payment covers - ask the user for both, never assume. userId comes from get_club_dues or find_club_member. Entries cannot be edited or deleted, so read list_member_dues first, confirm the person, amount and day with the user, and never call it again after a timeout or an error - read list_member_dues to see whether it was recorded. Returns the new entryId. For several members call it once per member. For full club admins only; clubId comes from list_my_clubs.

Sends an invited person a reminder notification about their pending invitation to a class, for the club's trainers and admins; the invitation itself is unchanged and still holds no place. classId comes from list_managed_classes or list_club_classes, participationId from list_class_roster (a row with status invited). Refused for any row that is not invited. Confirm with the user before sending; for several invitees call it once per row.

Removes a person from a club. Their punch cards and custom rates in this club are deleted; their class bookings, group memberships and venue access stay. They are not notified. Needs full club admin access. Find the userId with find_club_member and always confirm the exact person with the user before calling. When find_club_member finds nobody the person is not a member, so there is nothing to remove: search_user can confirm they only have an Agilix account. To keep someone in the club but out of its members chat, pause them with set_member_paused instead; to change their level or have them accept the terms again use set_member_skill_level or ask_members_to_accept_terms (the level new members get: set_default_skill_level).

Removes one member's custom amount on a rate, so classes at that rate charge them the standard amount again. membershipId comes from find_club_member, overrideId from list_member_rates for that member. The member is not notified. Always confirm with the user before calling. For full club admins only; clubId comes from list_my_clubs.

Removes a person from a class: all their places (every dog) and any invitation. Settle the club with list_class_form_options first if not yet settled in this conversation. keepAsOutstanding: when true, an unpaid place on a paid class is kept as a debt the person still owes; when false it is simply dropped. notifyAboutSlotAvailable: when true and the class was full, members who asked to hear about free places are told one opened. A person who held a place is notified that they were removed; a person who was only invited is not. Get classId from list_club_classes and the person from get_class, and always confirm with the user before calling.

Takes one person off a class's waiting list, for the club's trainers and admins; the people behind them move up and the removed person is notified. classId comes from list_managed_classes or list_club_classes, waitlistEntryId from list_class_waitlist. Always confirm the person with the user before calling.

Removes a person from a club group and its group chat. groupId comes from list_club_groups. Confirm with the user before calling.

Takes a person off the club team: they stay a club member but lose their admin or trainer access and leave the club's team chats. adminId comes from list_club_team. Refused for the founder. Removing yourself ends your access to this club as an admin - say so and get an explicit yes; always confirm with the user first. Nobody is notified. For full club admins only; clubId comes from list_my_clubs.

For the seminar's organizer and its co-admins: removes one sign-up (one dog, one day) from a seminar, as the participants panel's remove button. Call list_seminar_submissions first: seminarId comes from list_my_organized_seminars, submissionId from its rows. A seated dog's place frees and stays free until the organizer hands it out - nobody waiting is moved up; the owner loses the seminar chat and calendar entry for that day. Money paid online is refunded only on the seminar's payments page in Agilix. Nobody is notified. It cannot be undone - the entrant would have to sign up again: show the user the dog and the day and remove only after their yes. For several days call it once per submissionId.

Takes venue access away from one or more people: they can no longer rent the venue and leave its venue chat. accessIds come from list_venue_access for the same venue - one entry per person; an accessId not on that venue is refused and nothing is removed. venueId comes from list_venues. Always confirm with the user before calling. For full club admins only; clubId comes from list_my_clubs.

Closes the named training spaces on the named days: their opening windows on those days are removed, so nobody can book them then. Other spaces sharing a window keep it. Needs full club admin access. Read get_opening_hours first and always confirm with the user. Returns the week as it now stands.

Renames a club group. The name stays private to club admins (at most 80 characters); it does not change the group chat, whose name members see - that is set_group_chat_title. groupId comes from list_club_groups; with several similar groups ask the user which one is meant. Nobody is notified. For full club admins only; clubId comes from list_my_clubs.

Renames a training space of a club venue. Needs full club admin access. trainingSpaceId comes from list_venues.

Gives the holder a NEW punch card like an existing one: the same name and number of entries, no entries used, valid for as many days from today as the old card was (a card that never expired renews without an end day). The old card stays as it is. No money is taken, and the member is notified about the new card. punchCardId comes from list_club_punch_cards - when the member has several cards, ask the user which one. Refused for a refunded card. Confirm with the user first, and never call it again after a timeout or an error - read list_club_punch_cards to see whether the new card is there. Returns the new card, or null for it when it cannot be told apart from an identical one made at the same moment. For full club admins only; clubId comes from list_my_clubs.

Sets the club's public reply under one review (at most 2000 characters), replacing an earlier reply; an empty reply deletes it. reviewId comes from list_club_reviews; refused when its canReply is false - only a full admin or the trainer who ran that class can answer it. Show the user the reply and confirm before calling. A new or changed reply to a review readers can see notifies its author (a push, or an e-mail without the app). For several reviews call it once per review. For full admins and the trainer who ran the class; clubId comes from list_my_clubs.

Asks Agilix's team to look at one review, with the club's reason (at most 2000 characters). The report goes to Agilix's team as a push and an e-mail; the review stays public until Agilix decides, and only Agilix can hide it. Reporting a review again overwrites the earlier reason and reopens a report Agilix already settled. reviewId comes from list_club_reviews; refused when its canReport is false. Ask the user for the reason and confirm before calling. For full club admins only; clubId comes from list_my_clubs.

Turns on or off, for one member, the rule that they must pay online for a class before their booking holds a place. Only for a club that takes class payments online; otherwise refused with the web page where the club founder sets that up. membershipId comes from find_club_member - with several matches ask the user which person is meant. Answers whether it changed, or that it already was so. The member is not notified; confirm with the user first. For full club admins only; clubId comes from list_my_clubs.

Stops a discount code at a venue: renters can no longer use it, rentals already booked with it keep their price, and it stays listed as retired, so save_rental_voucher can bring it back. voucherId comes from list_venue_price_book; a code already retired is refused. Always confirm with the user before calling. For full club admins only; clubId comes from list_my_clubs, venueId from list_venues.

Takes an item off a venue's rental price list: renters can no longer book it, while rentals already booked keep it and it stays listed as retired, so save_rental_service can put it back. While a venue has at least one active item, every rental of it by someone other than a club admin is paid for through that price list; with none left active, people with access book it for free again. rentalServiceId comes from list_venue_price_book; an item already retired is refused. Always confirm with the user before calling. For full club admins only; clubId comes from list_my_clubs, venueId from list_venues.

Saves a class template for a club. Templates are per user AND club. Provide either fromClassId (to save from an existing class) or explicit fields, or both (explicit fields override). With templateId: updates that specific template (must be yours in this club); omitted fields keep their stored values. Without templateId: creates a new template. The template can then be used with prepare_classes or create_classes via templateId. Always confirm the template name and contents with the user before calling. Settle the club first with list_class_form_options if not yet settled in this conversation.

Saves a message text to the club's template library for scheduled class messages, for the club's trainers and admins: templateId null creates a new template, a templateId from list_message_templates replaces that template's text. clubId comes from list_my_clubs. Messages already scheduled keep their own text. Nobody is notified; confirm the text with the user first, and before replacing an existing one.

Schedules a message for the club's trainers and admins: at the chosen time before the class starts it goes to the class's booked participants in the class chat, with a push notification, exactly as the app sends it. minutesBefore is 5 to 10080 (a week); a send time already past goes out within a few minutes. classId comes from list_managed_classes, list_club_classes or get_class; templateId is null or a template of the class's club from list_message_templates (its text is still sent as text). Before calling, show the user the summary - the text, which class, when it goes out - and schedule only once they confirm. Refused once the class has started and when the class already has 5 messages waiting. See them with list_class_messages.

Schedules not-yet-public classes to go public: at publishAt (YYYY-MM-DDTHH:mm, the club's local time, in the future) Agilix makes those classes public with the chosen skill level and tells the club's members about the new classes, exactly as the app does. For full club admins only; clubId comes from list_my_clubs, classIds from publishableClasses in list_auto_publishes (run it first). skillLevel (novice, beginner, medium or advanced) is required - ask the user, never pick one. Before calling, show the user the summary - which classes, which level, when - and schedule only once they confirm. Refused for a time already past, a class that is not in publishableClasses, and a class starting before the publish time. Returns the new autoPublishId.

Gives one member their own amount on a club rate: classes at that rate charge them customAmount instead of the standard amount. Replaces the custom amount they already have on that rate, otherwise adds one. membershipId comes from find_club_member (ask which person when several match), rateId from list_club_rates; customAmount is digits with at most two decimals, up to 9999.99 - ask the user, never assume. The member is not notified. Confirm the person, rate and amount with the user first. For several members call it once per member. For full club admins only; clubId comes from list_my_clubs.

Sets, moves or clears the last valid day of a punch card: expiresOn is YYYY-MM-DD on the club calendar, or null for a card that never expires - ask the user for it, never assume. A day from today on brings an ended card back; a past day ends it. The member is not notified. punchCardId comes from list_club_punch_cards - when the member has several cards, ask the user which one. Refused for a refunded card. Confirm the card and the day with the user first. For full club admins only; clubId comes from list_my_clubs.

Sets the rental lengths renters may book at a venue (each 5 to 1440 minutes), replacing the current list: send the whole list as it should end up - list_venues shows the current one. Opening windows with their own lengths keep them (set_opening_hours_access); the others offer these. Bookings already made are not changed and nobody is notified; confirm the list with the user first. Returns the venue as it now stands. For full club admins only; clubId comes from list_my_clubs, venueId from list_venues.

Adds and removes tags on the club; the club's other tags stay. add and remove are labels from list_club_tags (capital letters and accents do not matter). Refused when a label is not a tag Agilix offers (the refusal lists them), when a label matches several tags (ask the user which one), and when the club would be left with no tag - a club keeps at least one. Confirm the change with the user first. Returns the club's tags after the change. For full club admins only; clubId comes from list_my_clubs.

Sets what one participant pays for this class, replacing the class price and the club rate for that row only (0 makes it free). For club admins only - a trainer without admin rights in the club is refused. price is an amount in the club currency with at most two decimals, up to 9999.99. classId comes from list_managed_classes or list_club_classes, participationId from list_class_roster. Refused when the club takes no class payments, and for a forfeited row. Nobody is notified; confirm the person and the amount with the user first.

Moves the club's pin on the map (where the club shows in search and on its page) to a street address. Ask the user for the street with its number and the city; the address is looked up in the club's country. When Agilix cannot find it, nothing changes and the answer carries the Agilix page where the pin is set on the map. It does not change the address text shown on the club page - that is update_club_details. Confirm the address with the user first. For full club admins only; clubId comes from list_my_clubs.

Changes how members take part in the club classes: whether they may resign (allowResign) and up to how many hours before the start (hoursBeforeResign), whether private classes show on the class list, whether members see who took part before and how many places are free, whether full classes are hidden from people not on them, the waiting list (waitlistEnabled) and whether it moves the first waiting person up automatically when a member resigns, until how many hours before the start (autoPromotionStopsHoursBefore, 0 = until it starts), and the notice a member reads when resigning late (cancellationPenaltyMessage shown from cancellationPenaltyHours before the start). Send only the fields the user asked to change - the rest stays; a call with none is refused. Refused when resigning is allowed without hours, or when the notice has a message without hours or hours without a message - set both together, or clear both with "" and 0. Read get_club_settings first and confirm the new rules with the user. For full club admins only; clubId comes from list_my_clubs.

Changes the club's terms that members accept in Agilix (termsText, an empty text removes them), the link to the full terms (termsUrl, empty removes it) and the welcomeMessage a newly accepted member reads. Send only the fields the user asked to change; a call with none is refused. Read get_club_settings first and confirm the new text with the user. Changing the terms does not ask members to accept them again - offer ask_members_to_accept_terms afterwards. For full club admins only; clubId comes from list_my_clubs.

Sets the skill level (novice, beginner, medium or advanced) a newly accepted member of the club gets unless the admin picks another one when accepting them; members already in the club keep theirs. Confirm the level with the user first. For full club admins only; clubId comes from list_my_clubs.

Sets how Agilix tidies the club's classes nobody signed up for. Every day at time (HH:MM on the club's clock) it deletes tomorrow's classes with no participants (deleteEmptyClasses) and shrinks tomorrow's classes to the places already taken (deleteEmptySlots); deleteEmptyClassesBeforeStart and deleteEmptySlotsBeforeStart do the same minutesBeforeStart before each class starts (30 to 360, in steps of 10). A deleted class also leaves members' calendars, and trainers' reminders about tomorrow's classes are sent after the cleanup. time null turns the whole cleanup off. Send the whole setting every time - all four switches, minutesBeforeStart and time - taking the values the user did not mention from get_club_settings (emptyClassCleanup; when it is null the cleanup is off). Turning deletion on removes classes for good: confirm with the user first. For full club admins only; clubId comes from list_my_clubs.

For the seminar's organizer and its co-admins: records whether one sign-up (one dog, one day) is unpaid, paid or refunded - the organizer's own record, as on the participants panel. Call list_seminar_submissions first: seminarId comes from list_my_organized_seminars, submissionId from its rows (its paymentStatus and paidOnline show the current state). No money moves and nobody is notified. A sign-up paid online through Agilix (paidOnline) cannot be marked refunded here: the refund is made on the seminar's payments page in Agilix (manageUrl), which then marks it. Show the user the dog, the day and the new status and call only after their yes. For several sign-ups call it once per submissionId.

Sets the opening hours of the named training spaces on the named days to one window (start-end, HH:mm, the venue's local time). Only those days and spaces change: other days and spaces keep their hours, and who may book keeps as it was. A space that had several windows that day ends up with this one. Needs full club admin access. Read get_opening_hours first and confirm the change with the user. Returns the week as it now stands. A venue just made with add_venue has no hours yet; how far ahead and until when renters may book or cancel is update_venue; who may book one window and its rental lengths is set_opening_hours_access.

Sets who may book one opening window of a venue and which rental lengths it offers; its day, times and training spaces stay as they are. allowedUserIds lists the only people who may book it (each a userId from find_club_member), or null opens it to everyone with access to the venue. rentLengthsMinutes lists the rental lengths offered in it (5 to 1440 minutes each), or null offers the venue's own lengths (list_venues; change them with set_venue_rent_lengths). Send both as they should end up - read get_opening_hours first for the current values. Nobody is notified; confirm the change with the user first. Refused when even the shortest length is longer than the window, and for anyone who is not a member. Returns the week as it now stands. For full club admins only; clubId comes from list_my_clubs, venueId from list_venues, openingHoursId from get_opening_hours.

Publishes a copy of one class in other clubs, as the app's linked classes: each copy has the same time, name, trainers and price, its own venue and training spaces in that club, and its own participants; the club's rate and activities do not travel. For trainers and admins of the class who are also an admin of every target club. classId comes from list_managed_classes or list_club_classes; each clubId from list_my_clubs, each venueId and trainingSpaceIds from list_venues for that club. Refused for a club the class is already in, and when a copy would go past the trainer's free classes. Nobody is notified. Confirm the clubs and venues with the user first. The result lists every copy with its classId.

Shows what a club venue rents out and on what terms, as the club's admins manage it: the price list items (rentalServiceId, name, length in minutes, price in PLN, VAT rate, training spaces, isActive - retired items included), the discount codes renters can type when booking (voucherId, code, percentOff or amountOff, how many uses it allows and has had, the last day it works, isActive), and the renters billed monthly instead of paying for each rental (postPaidRenters with userId). While a venue has at least one active item, every rental of it by someone other than a club admin is paid for through that price list; with none left active, people with access book it for free again. Read it before save_rental_service, retire_rental_service, save_rental_voucher, retire_rental_voucher and revoke_post_paid, which take their ids from here. venueId comes from list_venues. For full club admins only; clubId comes from list_my_clubs.

Stops monthly billing for one renter at a venue: from now on they pay for each rental when they book it. userId comes from the postPaidRenters of list_venue_price_book for the same venue (it also lists renters who have since left the club); someone not listed there is refused. Always confirm with the user before calling. For full club admins only; clubId comes from list_my_clubs, venueId from list_venues.

For the seminar's organizer and its co-admins: takes one dog out of one group of a seminar day. seminarId comes from list_my_organized_seminars, day from its days; read list_seminar_groups for that day first. memberId comes from a group's members. On a seminar where entrants sign up by day the dog keeps its place on the day and its other groups - only this group and its chat go. On a seminar where entrants pick time slots the group is the place: when it was the last group the dog sat in that day, the sign-up goes back to the waiting list and leaves the entrant's fee; nothing paid is refunded (that is on the seminar's payments page in Agilix). Nobody else moves: a place freed in a group stays free until the organizer fills it. On a seminar priced by group, what the entrant owes is recalculated. Nobody is notified. To remove the sign-up itself use remove_seminar_submission. Show the user the dog, the group and the day and call only after their yes. Answers the day's groups afterwards.

Takes some classes off one publishing schedule: they stay private, the rest of the schedule is unchanged, and nobody is notified. Removing the last class deletes the whole schedule. For full club admins only; clubId comes from list_my_clubs, autoPublishId and classIds from that schedule's classes in list_auto_publishes. Confirm the classes with the user first.

Turns the club's membership dues tracking on or off. With it on, the club records who paid their dues and until when (add_dues_entry) and can sell dues online (set_dues_online); with it off, online dues sales and the expiry reminders stop, while the recorded entries and any running auto-renewals stay. Check the current state in get_club_dues and confirm with the user first. For full club admins only; clubId comes from list_my_clubs.

Turns online dues sales on or off: with it on, members pay a dues plan (save_dues_plan) themselves in Agilix, once or as an auto-renewal, and the payment is recorded for them. Turning it on is refused unless dues tracking is on (set_dues_tracking), the club charges in PLN and its payout account is ready - onlineReady in get_club_dues; the refusal carries the web page where the founder sets the account up. Turning it off stops new sales only: auto-renewals already running keep renewing until the member or an admin cancels them (cancel_dues_auto_renew). Confirm with the user first. For full club admins only; clubId comes from list_my_clubs.

Turns the club's payment settlement on or off. With it on, classes carry prices, the club keeps the list of unpaid class fees (get_club_finances, settle_class_fee) and the payment history. Turning it off also stops taking BLIK payments for classes in the app, and turning it back on does not restore that; the club's recorded payments stay. It is not needed for Stripe class payments: the payout account and Stripe class payments are set up by the club founder on the web, at settingsPage. Check paymentSettlement in get_club_finances and always confirm with the user first. For full club admins only; clubId comes from list_my_clubs.

Changes one class. Only the fields you specify are changed; the rest stay as they are. Returns open questions instead of guessing, and refuses a clash instead of writing it. The class club cannot change.

Renames a rate on the club price list or changes its amount (digits with at most two decimals, up to 9999.99). Send both name and amount every time, taking the one the user did not mention from list_club_rates; rateId comes from there too. Members with a custom amount on this rate keep their own amount (list_member_rates). Confirm the change with the user first. For full club admins only; clubId comes from list_my_clubs.

Renames a club service or changes its placeLimit (1 to 1000 people booking it across the club at the same time, null for unlimited). Send both fields every time, taking the one the user did not mention from list_club_services; serviceId comes from there too. Confirm the change with the user first. For full club admins only; clubId comes from list_my_clubs.

Changes a club venue: its name, street, city or postalCode; isEnabled (an inactive venue cannot be booked); bookingDaysAhead (how many days ahead renters may book, 0 to 365); rentersMayCancel and rentersCancelHoursBefore (until how many hours before a rental its renter may cancel it, 0 to 720, 0 meaning until it starts; only while renters may cancel); minMinutesBetweenRentals and breakMinutesAroundRentals (0 to 240 minutes kept free between rentals and around them, 0 turning the rule off; club admins are exempt). Send only the fields the user asked to change - the rest stays as it is; a call with none is refused. A changed street, city or postal code moves the map pin to the new address, or removes the pin when the new address cannot be found. venueId comes from list_venues, which also shows the current values; confirm the change with the user first. Returns the venue as it now stands. The rental lengths renters may book are set_venue_rent_lengths. For full club admins only; clubId comes from list_my_clubs.

Changes one of your own training notes: send only the fields to change - the rest stays as stored, photos included. noteId comes from list_training_notes (a row with isMine true). visibleToOwner turned on notifies the owner; shareWithUserIds replaces the sharing ([] = nobody), from that dog's shareCandidates in list_member_dogs, and each person newly added is notified. Refused for a note you did not write. Show the user the change and confirm before calling.

Changes one of your own agenda notes, for trainers and admins: send only the fields to change - the rest stays as stored. noteId comes from list_agenda_notes (a row with isMine true); the note stays on the club it was written on, and new times are local on that club's clock, the same rules as add_agenda_note; sharedWithClubIds replaces the sharing ([] = only you). Only the chosen clubs' trainers and admins see the note, or only you; nobody is notified. Refused for a note you did not write.

Changes a club's details: name, addressText (the address shown on the club page), country, timeZone, agendaColour, description, phone and facebookUrl. Send only the fields the user asked to change - every field left out stays as it is; a call with none is refused. Read get_club_settings first and confirm the new values with the user. A new name also updates the club name in members' calendar entries. A new country without a timeZone moves the club's clock to that country's usual zone; a timeZone Agilix does not offer is refused with the suggested zone and the list to pick from - ask the user which one. agendaColour is the colour of the club's classes in members' agendas; once set here a new logo no longer changes it. facebookUrl cannot be cleared. The map pin is set with set_club_pin, the terms with set_club_terms; the logo and contact e-mail only on the web (logoPage from get_club_settings). For full club admins only; clubId comes from list_my_clubs.

Applies one change to many classes sequentially. Each class goes through the same path as the single-class update. Reports what happened to each class: changed, clash, not allowed, not found, needs input, or error. One failing class never stops the others.

Marks one entry of a member's punch card as used, for a class they came to: date is the day of that class (YYYY-MM-DD on the club calendar, today or a day that has passed), null for today; time is the time of that class (HH:mm, the club's local time) when the user gives one, null otherwise - a past day without a time is marked at noon, today without a time at the moment of the call. The member is notified with the entries they have left. punchCardId comes from list_club_punch_cards - when the member has several cards, ask the user which one. Refused for a refunded card, one that has ended and one with no entries left. Confirm with the user first, and never call it again after a timeout or an error - read list_club_punch_cards to see whether the entry was marked. For several entries call it once per entry. For full club admins only; clubId comes from list_my_clubs.

Replaces the club's private note about one member - the note the club team keeps on the member's profile in the app. It is visible to the club's admins and trainers only, never to the member, and nobody is notified. userId comes from find_club_member, whose note shows the current text: to add a line, send the current note with the new line, since the whole note is replaced; note "" deletes it. With several matches ask the user which person is meant, and confirm the text before calling. For club admins and trainers; clubId comes from list_my_clubs.

Records that the signed-in user accepts the terms of a club they are a member of, or have asked to join - for when the club asks its members to accept its terms (again). Show the user the terms word for word (terms from find_club) and call it only once they say yes; never on your own. clubId comes from list_my_clubs, or find_club for a request still waiting. Refused for a club the user does not belong to: joining accepts the terms, so use join_club with hasAcceptedClubTerms true. Refused for a club with no terms. Notifies nobody.

Sends the user's request to join a club. It is a REQUEST: the club's admins are notified and decide, and classes for members only open to the user once the club accepts - say so, never that they are now a member. clubId comes from find_club; run it first and confirm the club with the user. When that club has terms, show them to the user word for word and pass hasAcceptedClubTerms true only after they agree; pass false for a club without terms or when they have not agreed. Refused, with the reason, when a request is already waiting, when the user is already a member and when the terms were not accepted - that refusal carries the terms to show. A user the club declined before may ask again. For several clubs call it once per club.

Cancels all of the user's places on a class (every dog) and any invitation. Clubs can forbid cancelling close to the start, and a paid place is not refunded. Read the class with get_class first, tell the user about late cancellation and payment, and confirm before calling.

Cancels one of the user's own training space rentals. rentalId comes from list_my_upcoming_rentals; run it first and, when the user has several rentals, ask which one they mean - never pick one yourself. The venue decides whether and until when a renter may cancel (cancellableUntil); later, or at a venue that does not allow it, it is refused. A rental paid online in advance is NOT refunded by cancelling - say so; a rental billed later is taken off the user's bill. The venue's admins are notified. Confirm the rental with the user before calling. For several rentals call it once per rental.

Turns down an invitation to a class: the invitation is removed and the user leaves the class chat. Only the club can send the invitation again. classId comes from list_my_class_invitations; run it first, and when the user has several invitations ask which one they mean - never pick one yourself. Confirm the class with the user before calling. Refused when the class is not among their waiting invitations; a place they already hold is cancelled with resign_from_class instead. For several invitations call it once per class.

Puts the user on a full class's waitlist with the given dogs. It is NOT a booking and holds no place: when a place frees up the user is told, or the club moves them onto the class. Only for a class that is full and whose club keeps a waitlist (get_class: hasWaitlist) - a class with a free place is booked with join_class. classId comes from get_class, list_my_class_invitations or a join_class refusal, dogIds from list_my_dogs, serviceIds from the class services get_class lists (empty when it lists none or the user wants none; ask when it lists some). Confirm the class and dogs with the user first. Refused when the user is already on the list, holds a place, does not meet the class's membership or level rule, or the class has started. Nobody is notified. For several classes call it once per class.

Takes the user off a class's waitlist; they stop hearing about freed places on it. Leaving costs nothing and has no deadline. classId comes from list_my_waitlists; run it first and, when the user waits on several classes, ask which one they mean - never pick one yourself. Confirm before calling. Refused when the user is not on that list; a booked place is cancelled with resign_from_class instead. Nobody is notified.

Ends the signed-in user's membership in a club, or withdraws a request to join that is still waiting. The club's full admins are notified. It does not take the user off the club's future classes - list them with list_my_classes and resign from each with resign_from_class first if the user wants that. Members-only classes of the club close to the user, and joining again is a new request. Confirm with the user, naming the club, before calling it. clubId comes from list_my_clubs. Refused for a club the user does not belong to.

Lists what a venue rents out to the signed-in user: each item's rentalServiceId, name, length in minutes, price and the training spaces it covers. An item fixes the length and the spaces, so the user only picks the item and a start time. venueId comes from list_rentable_venues. Ask the user which item they want - never pick, even when there is one. canPayHere false means the assistant cannot book at this venue (the user is billed monthly there, or the venue has no price list for them): give the user rentalPage and stop. hasOverdueBill true means an unpaid monthly bill suspended the monthly billing, so this rental is paid upfront - say so. Next: list_rental_free_times with the chosen rentalServiceId. A full admin of the club that owns the venue changes this list with list_venue_price_book, not with this tool.

Lists the start times still free on one day for one rental item, as YYYY-MM-DDTHH:mm on the venue's local clock. venueId comes from list_rentable_venues, rentalServiceId from list_rental_services for that venue; ask the user for the day. Only free starts are returned: a time that is not listed is taken or outside the venue's hours, so offer the listed ones and never invent a time. An empty list means nothing is free that day - ask for another day. Next: book_training_space with one of these starts.

Lists upcoming classes the signed-in user was invited to and has not joined yet, with free slots and whether the class must be paid in advance. Accept one with join_class; turn one down with decline_class_invitation.

Lists the upcoming classes the signed-in user is waiting for a place on (in each club, the club local time). A waitlist entry is not a booking: the user is told when a place frees up, or the club moves them onto the class. Queue for a full class with join_class_waitlist; leave a list with leave_class_waitlist.

Lists the classes the signed-in user has a confirmed place on between two local dates (each club's local time, at most 366 days; past classes included), with the dogs they are signed up with. What each class costs and whether it is paid: list_my_class_payments. Classes they are only waiting for: list_my_waitlists.

Lists the signed-in user's class punch cards (karnety) in every club: entries used, entries left and expiry date (the club's local time). The payments for cards bought online are in list_my_online_payments.

Lists the signed-in user's paid training space rentals: service, start (the venue's local time), length, amount and payment status. Use it after book_training_space to check whether the payment went through: a rental is listed only once it is paid, so one that is missing is not booked yet. Rentals at a venue that bills the user monthly are not here: their bills are in list_my_rental_invoices. To rent a space start with list_rentable_venues. Every upcoming rental, paid ahead or billed later, with the rentalId to cancel it: list_my_upcoming_rentals, then cancel_my_rental.

Lists the signed-in user's upcoming training space rentals in every venue (and one that started in the last two hours): rentalId, venue, spaces, start (the venue's local time), length and cancellableUntil - the last moment the venue lets the user cancel it, null when the venue does not let renters cancel. What a rental paid online cost: list_my_space_bookings; monthly bills: list_my_rental_invoices. Cancel one with cancel_my_rental.

Lists the venues where the signed-in user may rent a training space for their own training: venueId, name, the club that runs it and its training spaces. First step of renting a space: venue here, then list_rental_services, list_rental_free_times and book_training_space. When there are several venues ask the user which one - never pick. hasPriceList false means the venue has no price list for this user: the assistant cannot book it, so give the user rentalPage instead. An empty list (canRent false) means no club has opened a venue to this user yet - say so.

Starts the signed-in user's rental of a training space and answers checkoutUrl, the page where they pay. NOTHING is booked until the user pays there: the slot is only kept for them for holdMinutes, so hand over the link and say that - never that the space is booked. Chain: venueId from list_rentable_venues, rentalServiceId from list_rental_services, startsAt from list_rental_free_times (YYYY-MM-DDTHH:mm, the venue's local time). Before calling, confirm the item, the start time and the price with the user. voucherCode is a discount code the user gave, otherwise null - never invent one. Refused, with the reason, when the code is not valid (nothing is booked; ask for another or for the full price) and when the time is no longer free (list the free times again). Refused with the Agilix rental page link when there is nothing to pay through the assistant: the venue bills this user monthly, has no price list for them, or the code makes the rental free - give the user that link. Afterwards list_my_space_bookings lists the rental once it is paid. For several rentals call it once per rental.

Finds upcoming classes with a free slot that the signed-in user can join (not ones they already booked). clubs: MY_CLUBS (clubs they belong to), ALL_CLUBS, or NO_MEMBERSHIP (clubs they do not belong to). days: local dates to look at (empty = any day). near: optional coordinates, classes within 40 km. There is no text or club filter. Pass the returned nextCursor to get the next page. A full class is not listed: when the user wants one they know of (an invitation, a class shown by get_class) and get_class says hasWaitlist, they can queue for it with join_class_waitlist.

Signs the user up for a class with the given dogs (or accepts an invitation). Adds dogs: dogs already signed up stay signed up; to cancel use resign_from_class. When the class must be paid in advance nothing is booked and the answer carries the Agilix page to finish the sign-up and payment there - unless the club takes no online payments (it then books an unpaid place the club settles with the user) or a punch card of the user covers the class: then one entry per new dog is used instead of a payment and the answer names the card in paidWithPunchCard; refused, with nothing booked, when that card runs out or ends before the booking lands. dogIds come from list_my_dogs, classId from search_classes or list_my_class_invitations. Confirm the class and dogs with the user first. An invitation the user does not want is turned down with decline_class_invitation, not left unanswered. A full class is refused; when its club keeps a waitlist the refusal says so - offer join_class_waitlist.

Starts a new club in Agilix with the signed-in user as its founder and full admin, as in the app; the club joins the user's own country (get_my_profile shows it; update_my_profile changes it). Check with find_club first that the club is not in Agilix already - an existing name is refused. Ask the user for the name, the street with number, the city and the Facebook page of the club (both apps require it), then show them that summary and create only once they confirm it. Refused when Agilix cannot find the address. The Agilix team is told about the new club. The answer carries the new clubId and logoPage, where the user adds the logo - the club then appears in list_my_clubs and its settings tools take that clubId.

Adds a dog to the signed-in user's Agilix profile, as the app's dog form does. Only name is required; give only what the user told you and ask for anything a sport needs that they did not say. breed is the breed in words: refused when several breeds match or none does, with the closest names - ask the user which one. When the user is not the legal owner, set isOwner false and give both owner names. With hasNoPedigree true leave the pedigree and registration numbers out. Dates are YYYY-MM-DD, never in the future, death not before birth. Agilix gives the dog a generated picture; the answer links the page where the user adds a real photo and the rabies vaccination, which the assistant cannot. Confirm the details with the user first. Notifies nobody. Returns the new dogId for get_my_dog, update_dog and the class tools.

Deletes one of the signed-in user's dogs from Agilix. The user must say the dog's name to confirm: confirmDogName is that name as they said it (capital letters and accents do not matter) and the call is refused when it is not the dog's name - never fill it in yourself. The dog leaves all its future classes; a class already paid for keeps the place under the user's name. Notifies nobody. dogId comes from list_my_dogs. Refused for a dog that is not theirs.

Finds Agilix clubs by name or city (accents and case ignored; every word must match), so the user can ask to join one. Each match carries clubId, name, city, country, the number of members, myMembership (null = not a member, pending = a request is waiting for the club, accepted = already a member) and terms, the text a new member must accept (null when the club has none). Returns at most 10 matches: when there is more than one, ask the user which club they mean - never pick one yourself; when isTruncated is true ask for a more exact name or the city. When nothing matches say so and ask for another spelling or the city; when the club is truly not in Agilix and the user wants to start it themselves, use create_club. The clubs the user already belongs to come from list_my_clubs. To ask to join a match call join_club with its clubId; browse_club_reviews shows what members wrote about it and lets the user write their own.

Finds upcoming AGILITY competitions (Agilix and external calendars; other sports are find_sport_competitions) with dates, place, registration status, spots and a page link where the user can enter. searchText matches name, city or judge. Entering, withdrawing and paying are done on that page. Each competition carries competitionId and isOnAgilix, which follow_competition takes to follow or unfollow it; get_my_start_times takes competitionId to say when the user's dogs run (agility has no news board - list_competition_news is for the other sports). Page with offset/limit. When the competition the user means is not found, offer suggest_competition.

Finds upcoming dog sport seminars, camps and workshops by text (name, city, organizer or instructor), country, Polish voivodeship, topic and date range - every filter optional (null or an empty list). Topics are matched against the seminar topic list in any language; an unknown topic is refused with the list. Returns at most 20, soonest first, with totalMatches. searchComplete false means the scan stopped before reading every seminar: narrow by text, country or region and search again - never tell the user nothing exists. Each row carries seminarSlug and ownerUsername: pass both to get_seminar for the details and the seminarId. isOnAgilix true means sign-up runs in Agilix (get_seminar, then sign_up_dog_for_seminar) and the seminar can be followed for news of its sign-ups opening (follow_seminar); isOnAgilix false is a seminar Agilix only lists - the user signs up on the organizer's page, the url.

Lists the current and upcoming Agilix competitions of one sport - hoopers, nosework, obedience, FCI Rally Obedience, dog dancing or PT, Pies Towarzyszący (agility is find_agility_competitions) - with days, place, the day entries open, which of the user's dogs hold a place, the user's entry status (participating, waitlist, awaitingApproval or noParticipation; list_my_sport_entries gives it per dog) and a page link where the user enters, withdraws and pays. When the user does not follow the sport only the competitions they entered are listed, and the answer says how to follow it. Every competition listed runs on Agilix (isOnAgilix true); an FCI Rally Obedience one can be followed with follow_competition. With the same sport and competitionId, get_my_start_times says when the user's dogs run and list_competition_news reads the organizer's news (neither exists for PT). Ask which sport when the user does not say.

Finds courses that designers shared publicly in the Agilix course designer, newest change first, at most 20: text matches part of the course title (null lists the newest). Each row has its courseSlug, title, description, when it last changed and a link to the public course page, where anyone can view it and copy it into their own designer. totalCount above the rows returned means more matched: ask the user for a more specific title. For the details of one course, call get_public_course with its courseSlug. The user's own private courses are listed by list_my_courses, never here.

Follows (follow true) or unfollows (follow false) an agility or FCI Rally Obedience competition for the signed-in user, the app's heart button; for agility a connected calendar gets or loses the competition. competitionId and isOnAgilix come from find_agility_competitions (agility) or find_sport_competitions (FCI Rally Obedience, where isOnAgilix is always true). Free accounts follow up to three agility competitions - a fourth is refused, and unfollowing does not give a follow back; Agility Premium follows any number, and nothing is bought here. Hoopers, nosework, obedience and dog dancing competitions cannot be followed. Notifies nobody.

Follows (follow true) or unfollows (follow false) a seminar run in Agilix, the seminar page's follow button: a follower is told when its sign-ups open. seminarId comes from get_seminar (isFollowed there says whether the user already follows it); a seminar Agilix only lists cannot be followed. Following twice or unfollowing a seminar not followed changes nothing. Notifies nobody else.

Reads one seminar: days, instructors, place, topics and description. seminarSlug and ownerUsername come from find_seminars or list_my_seminar_entries (ownerUsername null for a seminar Agilix only lists). For a seminar run in Agilix it also returns seminarId (for sign_up_dog_for_seminar and follow_seminar), places per day, the sign-up mode (byDay: the user picks days; byGroup: the user picks time slots from signupGroups, each with its groupId), whether the organizer approves each sign-up, the minimum number of days, when sign-ups open (Polish time), the organizer's payment notes, whether the user follows it, and myDogs - the user's dogs (dogId) with the days each is already entered for and its state there (seated, waitlisted, awaitingApproval, rejected). For a listed seminar it returns the organizer, their links and no sign-up.

Shows one class: time (the club's local time), venue, training spaces, trainers, slots, your standard price (an individual rate on your invitation shows in list_my_class_invitations), and every participant with their dog and status (approved, invited, rejected, didNotParticipate, forfeited), the services a participant may pick (serviceId, for join_class_waitlist) and hasWaitlist (the club keeps a waitlist for full classes). classId comes from list_club_classes, list_my_classes, search_classes, list_my_class_invitations or list_my_waitlists. The club's trainers and admins run the class with list_class_roster (each row's participationId, for attendance, invitation reminders and a participant price), list_class_waitlist and list_class_messages (messages scheduled to the participants).

Shows dogs' recent agility competition runs (faults, refusals, time, place) and their yearly agility statistics. dogIds come from list_my_dogs; at most 20 per call.

Shows who is signed in to Agilix through this assistant: name, username, language, country, the about-me text, the kennel club membership number, the Garmin Connect profile, and the clubs they are an accepted member of. It never shows the e-mail address or the phone number. update_my_profile changes the profile, get_my_settings and update_my_settings the app settings, and get_my_club_preferences the notifications and agenda colour for one club.

Shows the signed-in user's Agilix app settings as on/off switches: which notifications and reminders they get, what goes to their connected calendar, which sports they follow, the live stream banner and the what is new card, notification e-mails, the lock-screen live start on competition day and the start alert (how many dogs before theirs). Read it before update_my_settings to show the user what changes. Connecting or disconnecting a calendar is done only in the app.

Shows the signed-in user's record in one club over the last 1 to 24 months (months), as the app's attendance screen does: every class they were booked on, newest first, with its start (the club's local time), length, the dogs they brought, the training spaces, whether it is still upcoming and whether the trainer marked them absent; a summary of classes attended, missed and upcoming (a class booked with two dogs counts once, and as attended when either dog was there); and the training spaces they rented themselves in that club. clubId comes from list_my_clubs. Invitations not accepted and classes the user resigned from are not listed. Totals across every club are in get_my_stats.

Shows the signed-in user's membership dues in one club: whether the club tracks dues at all, the state (paid until a date, expired, never paid, or notTracked), the date the paid membership runs to (the club's local date), a running auto-renewal with its plan and the date it is paid through, and the plans the club sells online with their length in months and price. clubId comes from list_my_clubs. Refused for a club the user is not a member of (join it with join_club) or whose admins have not accepted the request to join yet. Dues are paid in Agilix, never through the assistant: give the user the duesPage link (the club's page). An admin reads every member's dues with list_member_dues.

Shows everything on one of the signed-in user's dogs as the app's dog form holds it: names, breed, gender, birth and death dates, the legal owner when it is someone else, booklet and registration numbers, chip, height, the class per sport and the flyball title. Read it before update_dog to show the user what changes. dogId comes from list_my_dogs. Refused for a dog that is not theirs.

Shows the signed-in user's own preferences for one of their clubs: whether they are notified when a place frees up in a full class and when the club publishes a new class, and the colour of the club's classes in their agenda (agendaColour, the club's own colour, whether they picked their own, and the colours to choose from). clubId comes from list_my_clubs. For a club the user only administers without being a member, the notification switches are null. Refused for a club the user does not belong to. Read it before set_my_club_preferences.

Reads which group each of the user's dogs is in at one seminar run in Agilix, per day: group, start and end time, trainer, location and dog, plus publishedDays - the days whose groups the organizer published. seminarSlug comes from list_my_seminar_entries or find_seminars. A day shows only once its groups are published, so no row for a dog on a day means no published group assignment for it there: when the day is not in publishedDays the groups are not out yet; when it is, the dog got no group that day - read its entry state (seated, waitlisted, awaitingApproval, rejected) with list_my_seminar_entries or get_seminar before telling the user why.

Shows the signed-in user's training stats, as the app's statistics screen does: how many classes they were booked on in each of the last twelve months (month as YYYY-MM, the current month last, months without a class as 0), and how many classes they have been booked on in each club over all time, most first. Both count each class once, whatever the number of dogs. For the classes themselves in one club, each with its date and whether the user was marked absent, use get_my_club_attendance.

Lists the Agilix help documents - how the Agilix apps work (accounts, dogs, clubs, classes, the shop, the competition apps for agility, hoopers, nosework, obedience, FCI Rally Obedience and dog dancing, seminars, the course designer, photos) and Agilix training tips - by title. Call it first when the user asks how to do something in Agilix, then open the matching document with read_agilix_help, which lists its sections. The documents are in Polish. For sport rulebooks and regulations, use search_rulebooks.

Lists the signed-in user's entries in Agilix agility competitions (past included): dog, entry status (accepted, awaitingApproval, waitlisted, unlisted), waiting-list place, class, chosen days, whether the entry fee is paid, and the competition page link. Entries in other sports are list_my_sport_entries. On the day, get_my_start_times takes the entry's competitionId to say when the dog runs.

Lists the invoices and receipts Agilix issued to the signed-in user for what they bought from Agilix itself (Agility Premium, Trainer Pro, competition hosting fees, commission statements, stream clips): number, issue date, amount, what it was for (kind), status and whether a PDF can be downloaded. The PDF opens only in Agilix: give the user the invoicesPage link. Fees paid to clubs are not here - see list_my_class_payments, list_my_online_payments and list_my_rental_invoices.

Lists the signed-in user's class fees, as the app's My payments screen does: each class they attended or booked with its club, start (the club's local time), dog, price and payment status, plus the fees a club kept on record as owed after the user left a class or the class was removed (keptDebts). paid: false lists what is still unpaid, paid: true what was paid; showAll: false covers the last six months, true every month. clubId narrows it to one club - take it from the clubs list this tool returns (every club the user ever had a class in) or from list_my_clubs; null covers every club. A class with price null has no price set by its club. Payments are made in Agilix, never through the assistant: give the user the payPage link to pay or to see the receipt. Card payments for classes and punch cards paid online are in list_my_online_payments, the record of who marked a fee paid in list_my_transaction_history, a club's membership dues in get_my_dues.

Lists the Agilix clubs the user administers or belongs to, with their clubId. Call this first whenever another tool needs a clubId. adminAccess is "full" (founder or full admin: changes the club settings, members, money and venues, starting from get_club_settings), "trainer" (runs classes and answers reviews of them with list_club_reviews and reply_to_club_review, but cannot change club settings) or null (plain member). For a club they belong to, get_my_club_preferences and set_my_club_preferences show and change their own notifications and agenda colour, accept_club_terms accepts its terms and leave_club ends the membership. A club the user does not belong to yet is found with find_club.

Lists the courses the user drew in the Agilix course designer, newest change first, 50 at a time: each with its courseSlug, title, description, whether it is private or public, when it last changed and a link that opens it in the designer. When nextOffset is not null, call again with that offset for older courses. The course itself is opened, drawn and edited only in the designer through the link - the assistant cannot show or change the drawing. For courses other people shared publicly, use find_public_courses.

Lists the training notes about one of the signed-in user's dogs: the ones trainers made visible to them and their own, newest first, with the author, when it was written and the text. dogId comes from list_my_dogs. Notes a trainer kept hidden are not shown. Photos on a note are seen in the Agilix app.

Lists the signed-in user's dogs with dogId, name, breed, birth date and skill level per sport. Call it before any tool that needs a dogId. get_my_dog shows everything on one dog, update_dog changes it, add_dog adds a new dog and delete_dog deletes one once the user confirms it by the dog's name; list_my_dog_notes shows the training notes trainers shared about a dog.

Lists the signed-in user's entries in one sport's Agilix competitions - hoopers, nosework, obedience, FCI Rally Obedience, dog dancing or PT, Pies Towarzyszący (agility is list_my_agility_entries): competition, days, dog, entry status (accepted, waitlisted, awaitingApproval, trainingStart), class, whether the entry fee is paid where the sport says, and the competition page link where the user withdraws or pays. With the same sport and competitionId, get_my_start_times says when the user's dogs run and list_competition_news reads the organizer's news (neither exists for PT). Ask which sport when the user does not say; for every sport call it once per sport.

Lists what the signed-in user paid online in Agilix, newest first: classes paid by card when booking (kind "class", with the classId) and punch cards bought online (kind "punchCard", with the club). Each line has the amount, the payment status and any refunded amount. Bookings that were never paid are not listed. Class fees settled with the club are in list_my_class_payments, the cards themselves and their entries in list_my_punch_cards, training space rentals in list_my_space_bookings and list_my_rental_invoices.

Lists every change a club made to the signed-in user's own class fees: which fee (class and dog), the club, when it was recorded (the club's local time), the amount, the status before and after (unpaid, paid by cash, by card, by punch card) or that the club forgave it, and which admin did it. It is the record to point at when the user disputes a fee with the club. showAll: false covers the last six months, true the last two years. clubId (from list_my_clubs or the clubs list of list_my_class_payments) keeps one club; null every club. It always lists only the user's own fees, also in a club they administer; a full admin reads the whole club's history with list_club_transactions.

Lists the signed-in user's entries in seminars run in Agilix, with a dog or as an observer (dog null): seminar, city, days, waitlisted (also true while the organizer has not accepted the entry), the payment status the organizer set, and onlineFee - the user's fee for the whole seminar when its organizer takes fees online (owed, paid, refunded, currency, whether it can be paid now), shown on each entry of that seminar; null when the organizer takes payment another way (get_seminar's paymentInfo says how). The fee is paid in Agilix on payPage, the seminar page - never in chat. seminarSlug and ownerUsername feed get_seminar and get_my_seminar_schedule. Only the organizer can withdraw an entry: a user who wants out is told to contact them.

Lists the signed-in user's monthly bills for training space rentals at venues that let them rent now and pay later: each bill with the venue, the month (MM/yyyy), the amount, its status (issued = to pay, paying, paid, void), when it is due and when it was paid, and the rentals it is made of; plus what the current month is running to at each such venue before the bill is issued (runningTotals). Dates are on Agilix's default clock (Europe/Warsaw). Payments are made in Agilix, never through the assistant: give the user the payPage link to pay or to see the receipt. Rentals paid when booking are in list_my_space_bookings.

Sets the signed-in user's helpful mark on one club review (helpful true) or takes it back (false); the review's helpful count changes, nobody is notified. clubId and reviewId come from browse_club_reviews (markedHelpfulByMe shows the current mark). Refused for your own review.

Lists the ZKwP ranking points of the dogs the signed-in user submitted results for, per season and per list they stand on: group (with its FCI group), topPuppy, topJunior, topVeteran, topDog, sport (with its class and height category) or unrecognised. Points count accepted submissions only; a pending one is not in them yet. Places are not given here: a closed season publishes them on its classification page (url, isSeasonClosed true); while a season is open the link goes to the user's submissions in the ranking app. Submitting a result is done in the ranking app. Empty = no accepted submission yet.

Shows a club's public reviews, newest first: rating 1-5, comment, the reviewer's chosen signature, the class they attended, how many readers found it helpful and the club's reply - plus, for the signed-in user, isMine, markedHelpfulByMe and reportedByMe on each row, and whether they may write a review (canWrite; club admins and trainers never review their own club, others need a class attended there in the last 30 days or an earlier review of their own), their own review and suggestedSignature, the name to offer when they write one. clubId comes from find_club or list_my_clubs. reviewId is what mark_review_helpful and flag_club_review take; write or change the own review with write_club_review.

Reads the organizer's news posts of one hoopers, nosework, obedience, FCI Rally Obedience or dog dancing competition: title, text, whether it is pinned, when it was posted and edited, and its attachments by name and link. Agility competitions have no news board in Agilix - their announcements are on the competition page. competitionId comes from list_my_sport_entries or find_sport_competitions; the posts also show on the competition page those tools link. Anyone may read them; nothing is marked as read.

Reads one Agilix help document, a section at a time: without `section` it returns the list of sections (number and heading); with `section` it returns that section's text. slug comes from list_agilix_help_topics. Answer from the text and name the document you used; the text is in Polish. A question about a sport rule goes to search_rulebooks.

Reads one publicly shared course from the Agilix course designer: its title, description, when it last changed and the link to its public page, where it is viewed and copied into the designer. courseSlug comes from find_public_courses, or from list_my_courses for one of the user's own public courses. Refused when no public course has that courseSlug - the course was made private or removed, or the slug is wrong.

Asks Agilix's team to look at one club review that breaks the rules; the review stays public until Agilix decides, and only Agilix can hide it. reason is one of spam, offensive, falseInfo, personalData or other; details (at most 2000 characters, null when the user adds nothing) say what is wrong - ask the user for both. clubId and reviewId come from browse_club_reviews. Agilix's team is told unless a report on that review is already waiting; reporting the same review again (reportedByMe true) replaces your earlier reason and reopens it. Refused for your own review. Confirm before calling.

Searches the rules and regulations of every dog sport in the Agilix rulebook library (FCI and ZKwP rulebooks) and returns up to six passages, each with its rulebook, heading and a link to the PDF. Write the query in Polish, the rulebooks' language, with the rule's key words (for example "strefa kontaktowa dyskwalifikacja"), and search again with other words when no passage fits. Answer a rules question only from these passages: quote the passage with its rulebook, heading and link, and never answer a rule from memory. Rulebooks listed as unsearchable have no readable text: when nothing fits and one of them is of that sport, say the rule may be in that document and give its link, never that no such rule exists. Nothing is saved, and searches are limited per hour. For how the Agilix apps work, use list_agilix_help_topics instead.

Sends a feature request to the Agilix team by e-mail, for something the user wants that no Agilix tool can do. Use it ONLY when no tool covers the request: first tell the user plainly that this does not exist in Agilix yet and ask whether to send it as a request to the Agilix team; call this only after an explicit yes, then tell the user it was sent. summary is one line, request is the user's own words, goal is what they were trying to do. Pass clubId when a club is settled in the conversation. At most 5 requests per user per 24 hours.

Changes the signed-in user's own preferences for one club: the notification when a place frees up in a full class, the notification about the club's new classes, and the colour of the club's classes in their own agenda (one of colourChoices from get_my_club_preferences; null goes back to the club's colour). Only the user sees the colour. Send only what the user asked to change; a call with none is refused. clubId comes from list_my_clubs; read get_my_club_preferences first and confirm the change. The notification switches need an accepted membership. Refused for a club the user does not belong to - to join one use find_club and join_club. Notifies nobody.

Signs one of the user's dogs up for a seminar run in Agilix. Call get_seminar first: seminarSlug and seminarId come from it, dogId from its myDogs. A byDay seminar takes days (from its days, ones the dog is not entered for yet); a byGroup seminar takes groupIds from its signupGroups - every slot that suits the user, the dog lands in one per day (picking more slots on a day the dog is already entered for adds them as alternatives). Show the user the seminar, the dog and the days or groups and sign up only after their yes; never pick days, groups or a dog yourself. Each day answers seated (with its group), waitlisted (the day is full or others already wait for it, or the organizer accepted the entry and has no place for it yet), awaitingApproval (the organizer accepts each sign-up; no place is held until then) or rejected (the organizer turned this entry down - adding slots to it does not reopen it). Nobody is moved off the waiting list automatically - the organizer hands out freed places. Refused before sign-ups open, after the seminar ended, below its minimum number of days, and for a seminar Agilix only lists (sign up on the organizer's page). The user gets a confirmation e-mail on their first sign-up to the seminar and joins its chat once seated; the organizer is not notified. Any fee is paid on the seminar page (list_my_seminar_entries shows it). For several dogs call it once per dog. Only the organizer can withdraw an entry.

Suggests an agility competition missing from Agilix's calendar. Search find_agility_competitions first (by name or city) and suggest only when it is not there. Ask the user for the name, the days (YYYY-MM-DD), the organizer, the city, the country (two-letter code) and whether it is an official FCI / ZKwP competition; the description, judges, event link and organizer link only when the user has them - never invent one. A link must be a full web address (https://...). Show the user the whole summary and send only after their yes. Agilix's competition editors are e-mailed and review it; nothing is published until they accept it. At most 20 suggestions a day.

Turns the signed-in user's Agilix app settings on or off, the same switches get_my_settings shows, and sets the start alert. Send only what the user asked to change - every setting left out stays as it is; a call with none is refused. Read get_my_settings first and confirm the change with the user. Following or unfollowing hoopers, nosework or obedience also adds or removes that sport's competitions in a connected calendar; the two calendar switches resync it. Turning the lock-screen live start off ends it at once, turning it on brings it back. Notifies nobody.

Changes the fields given on one of the signed-in user's dogs; every field left out stays as it is. null clears a field (for example dateOfDeath, a booklet number or a class); gender, namePronunciation, hasNoPedigree, kennelClubRegistrationNumber and isActive take a value, not null. breed is matched like in add_dog (several or no match is refused - ask the user which one; null clears it). isOwner false needs both owner names unless they are on file; isOwner true removes them. Dates are YYYY-MM-DD, never in the future, death not before birth. The photo stays; a new photo and the rabies vaccination are changed in Agilix (get_my_dog links the page). dogId comes from list_my_dogs; read get_my_dog first and confirm the change with the user. Refused for a dog that is not theirs and for a call that changes nothing. Notifies nobody.

Changes the signed-in user's Agilix profile: first and last name, phone number, the about-me text, the kennel club membership number, country, the Garmin Connect profile and whether other handlers may find it, and the app language. Send only what the user asked to change - every field left out stays as it is; a call with none is refused. "" clears the phone, the about-me text and the membership number; null removes the Garmin profile. Read get_my_profile first and confirm the new values with the user. A new name shows in their clubs and on the venue bookings they made; a new membership number reaches their upcoming competition entries. A Garmin value that is not a profile name or link (an e-mail, for example) is refused. The phone number is saved but never read back here. The e-mail address and the password are changed only in Agilix. Notifies nobody.

Answers when the signed-in user's dogs run at one competition: for every run of theirs still to go, the run, the dog, how many dogs start before it, whether the run is already underway, and the approximate start and course walk in Polish local time (YYYY-MM-DDTHH:mm). The times are estimates from the published start list and move as the day runs - say so. sport is agility, hoopers, nosework, obedience, FCI Rally Obedience or dog dancing; competitionId comes from list_my_agility_entries or find_agility_competitions (agility) and from list_my_sport_entries or find_sport_competitions (the other sports) - ask which competition when the user has several. An empty answer means no published start list holds their dogs yet, or they all ran. Only the user's own dogs are ever shown.

Publishes the signed-in user's review of a club, or replaces their existing one (one review per club). clubId comes from find_club or list_my_clubs; run browse_club_reviews first to see canWrite and the review already there. rating is a whole 1 to 5, comment at most 2000 characters, displayName the signature every reader sees (1 to 50 characters): ask the user which name to sign with and offer suggestedSignature from browse_club_reviews. Refused for the club's own admins and trainers, and for a new review without a class attended there in the last 30 days. The club's admins are notified of a new review and of a changed rating or text. Show the user the review and confirm before calling.