import type { SchedulingEventType, SchedulingEvent, SchedulingParticipant, SchedulingBooking, SchedulingCalendarSync, SchedulingLocation, SchedulingAvailabilityRule, SchedulingReminder } from "../_internal/types.gen";
import type { RequestOptions } from "../base-client";
import { RequestBuilder } from "../request-builder";
type ListPaginationOptions = {
    page?: number;
    pageSize?: number;
} & RequestOptions;
/** Attributes accepted when creating a Location. */
export type CreateAdminSchedulingLocationAttributes = {
    workspace_id: string;
    name: string;
    type: "venue" | "room" | "virtual" | "resource";
    address?: string;
    city?: string;
    state?: string;
    country?: string;
    postal_code?: string;
    latitude?: number;
    longitude?: number;
    url?: string;
    capacity?: number;
    instructions?: string;
    is_active?: boolean;
    metadata?: Record<string, unknown>;
};
/** Attributes accepted when updating a Location (PATCH semantics). */
export type UpdateAdminSchedulingLocationAttributes = Partial<Omit<CreateAdminSchedulingLocationAttributes, "workspace_id">>;
/** Attributes accepted when creating an EventType. */
export type CreateAdminSchedulingEventTypeAttributes = {
    name: string;
    duration_minutes: number;
    slug?: string;
    description?: string;
    buffer_before_minutes?: number;
    buffer_after_minutes?: number;
    min_notice_minutes?: number;
    max_advance_days?: number;
    location_type?: "video" | "phone" | "in_person";
    location_id?: string;
    location?: Record<string, unknown>;
    default_reminder_offsets?: number[];
    booking_enabled?: boolean;
    capacity?: number;
    requires_approval?: boolean;
    booking_cooldown_minutes?: number;
    intake_form_schema?: Record<string, unknown>;
    billing_operation?: string;
    color?: string;
    metadata?: Record<string, unknown>;
    status?: "active" | "archived";
    workspace_id?: string;
    /**
     * F-A26 — when set, anonymous bookings against this event type use this
     * user as the linked Event's `organizer_user_id`, enabling the exclusion
     * constraint to block double-booking.
     */
    owner_user_id?: string;
};
/** Attributes accepted when updating an EventType (PATCH semantics). */
export type UpdateAdminSchedulingEventTypeAttributes = Partial<Omit<CreateAdminSchedulingEventTypeAttributes, "workspace_id">>;
/** Attributes accepted when creating an Event. */
export type CreateAdminSchedulingEventAttributes = {
    start_time: string;
    end_time: string;
    title?: string;
    description?: string;
    timezone?: string;
    status?: "draft" | "confirmed" | "cancelled" | "completed";
    location_type?: "video" | "phone" | "in_person";
    location_id?: string;
    location?: Record<string, unknown>;
    recurrence_rule?: Record<string, unknown>;
    recurrence_parent_id?: string;
    source?: "platform" | "external" | "booking" | "agent" | "automation";
    external_calendar_id?: string;
    notes?: string;
    metadata?: Record<string, unknown>;
    event_type_id?: string;
    workspace_id?: string;
    organizer_user_id?: string;
};
/** Attributes accepted when updating an Event (PATCH semantics). */
export type UpdateAdminSchedulingEventAttributes = {
    title?: string;
    description?: string;
    timezone?: string;
    location_type?: "video" | "phone" | "in_person";
    location_id?: string;
    location?: Record<string, unknown>;
    notes?: string;
    metadata?: Record<string, unknown>;
};
/** Attributes for cancelling an Event. */
export type CancelAdminSchedulingEventAttributes = {
    cancellation_reason?: string;
};
/** Attributes accepted when creating a Participant. `email` is required server-side. */
export type CreateAdminSchedulingParticipantAttributes = {
    event_id: string;
    email: string;
    name?: string;
    phone?: string;
    role?: string;
    status?: string;
    contact_id?: string;
    user_id?: string;
    metadata?: Record<string, unknown>;
    workspace_id?: string;
};
/** Attributes accepted when updating a Participant. */
export type UpdateAdminSchedulingParticipantAttributes = {
    name?: string;
    phone?: string;
    role?: string;
    metadata?: Record<string, unknown>;
};
/** Attributes accepted when creating an AvailabilityRule. */
export type CreateAdminSchedulingAvailabilityRuleAttributes = {
    workspace_id: string;
    type: "recurring" | "override";
    event_type_id?: string;
    user_id?: string;
    location_id?: string;
    name?: string;
    priority?: number;
    weekly_schedule?: Record<string, unknown>;
    date_overrides?: Record<string, unknown>[];
    timezone?: string;
    effective_from?: string;
    effective_until?: string;
    is_active?: boolean;
    metadata?: Record<string, unknown>;
};
/** Attributes accepted when updating an AvailabilityRule. */
export type UpdateAdminSchedulingAvailabilityRuleAttributes = Partial<Omit<CreateAdminSchedulingAvailabilityRuleAttributes, "workspace_id">>;
/** Attributes accepted when creating a Booking. `booker_email`/`booker_name` required. */
export type CreateAdminSchedulingBookingAttributes = {
    event_type_id: string;
    start_time: string;
    end_time: string;
    booker_name: string;
    booker_email: string;
    booker_phone?: string;
    booker_timezone?: string;
    booker_contact_id?: string;
    booked_by_user_id?: string;
    intake_responses?: Record<string, unknown>;
    party_size?: number;
    metadata?: Record<string, unknown>;
    workspace_id?: string;
};
/** Attributes for cancelling a Booking. */
export type CancelAdminSchedulingBookingAttributes = {
    cancellation_reason?: string;
    cancelled_by?: "booker" | "organizer" | "system";
};
/** Attributes for rescheduling a Booking. */
export type RescheduleAdminSchedulingBookingAttributes = {
    new_start_time: string;
    new_end_time: string;
};
/** Attributes accepted when creating a Reminder. */
export type CreateAdminSchedulingReminderAttributes = {
    event_id: string;
    minutes_before: number;
    scheduled_at: string;
    channel: "email" | "sms" | "whatsapp" | "slack" | "webhook";
    workspace_id: string;
    status?: "pending" | "sent" | "failed" | "cancelled";
    recipient_participant_id?: string;
    metadata?: Record<string, unknown>;
};
/** Attributes accepted when creating a CalendarSync. BAA required for HIPAA workspaces. */
export type CreateAdminSchedulingCalendarSyncAttributes = {
    workspace_id: string;
    user_id: string;
    connector_id: string;
    provider: "google" | "outlook";
    calendar_external_id: string;
    calendar_name?: string;
    sync_direction?: "push" | "pull" | "bidirectional";
    role?: "conflict_check" | "add_events" | "both";
    sync_method?: "poll";
    poll_interval_minutes?: number;
    settings?: Record<string, unknown>;
    metadata?: Record<string, unknown>;
    baa_attestation?: {
        type: "google_workspace_baa" | "microsoft_baa" | "other";
        attested_at: string;
        attested_by_user_id: string;
        attestation_text: string;
        platform_acknowledgment: string;
    };
};
/** Attributes accepted when updating a CalendarSync. No `enabled` — use pause/resume. */
export type UpdateAdminSchedulingCalendarSyncAttributes = {
    calendar_name?: string;
    sync_direction?: "push" | "pull" | "bidirectional";
    role?: "conflict_check" | "add_events" | "both";
    sync_method?: "poll";
    poll_interval_minutes?: number;
    settings?: Record<string, unknown>;
    metadata?: Record<string, unknown>;
};
/**
 * Admin scheduling namespace — full scheduling domain management.
 *
 * Provides CRUD and lifecycle operations for all 8 scheduling resources:
 * locations, event types, events, participants, availability rules,
 * bookings, reminders, and calendar syncs.
 *
 * @example
 * ```typescript
 * const admin = new GptAdmin({ apiKey: 'sk_srv_...' });
 *
 * // Create a location
 * const loc = await admin.scheduling.locations.create({
 *   workspace_id: 'ws_abc', name: 'Room A', type: 'room',
 * });
 *
 * // List events by date range
 * const events = await admin.scheduling.events.listByDateRange(
 *   'ws_abc', '2026-04-01T00:00:00Z', '2026-04-30T23:59:59Z',
 * );
 * ```
 */
export declare function createSchedulingNamespace(rb: RequestBuilder): {
    /** Locations — reusable venue/resource registry. */
    locations: {
        /**
         * List locations in a workspace.
         *
         * @param workspaceId - The UUID of the workspace.
         * @param options - Optional pagination and request options.
         * @returns A page of `SchedulingLocation` records.
         */
        list: (workspaceId: string, options?: ListPaginationOptions) => Promise<SchedulingLocation[]>;
        /**
         * List locations filtered by type.
         *
         * @param type - One of "venue", "room", "virtual", "resource".
         * @param options - Optional request options.
         * @returns A list of `SchedulingLocation` records of the given type.
         */
        listByType: (type: "venue" | "room" | "virtual" | "resource", options?: RequestOptions) => Promise<SchedulingLocation[]>;
        /**
         * Retrieve a single location by ID.
         *
         * @param id - The UUID of the location.
         * @param options - Optional request options.
         * @returns The matching `SchedulingLocation`.
         */
        get: (id: string, options?: RequestOptions) => Promise<SchedulingLocation>;
        /**
         * Create a new location.
         *
         * @param attributes - Location attributes. `workspace_id`, `name`,
         *   and `type` are required.
         * @param options - Optional request options.
         * @returns The newly created `SchedulingLocation`.
         *
         * @example
         * ```typescript
         * const loc = await admin.scheduling.locations.create({
         *   workspace_id: 'ws_abc',
         *   name: 'Conference Room A',
         *   type: 'room',
         *   capacity: 12,
         * });
         * ```
         */
        create: (attributes: CreateAdminSchedulingLocationAttributes, options?: RequestOptions) => Promise<SchedulingLocation>;
        /**
         * Update a location's mutable fields.
         *
         * @param id - The UUID of the location.
         * @param attributes - Subset of attributes to change.
         * @param options - Optional request options.
         * @returns The updated `SchedulingLocation`.
         *
         * @example
         * ```typescript
         * await admin.scheduling.locations.update('loc_abc', {
         *   capacity: 24,
         *   instructions: 'Use side entrance',
         * });
         * ```
         */
        update: (id: string, attributes: UpdateAdminSchedulingLocationAttributes, options?: RequestOptions) => Promise<SchedulingLocation>;
        /**
         * Deactivate a location. The record is preserved but no longer offered
         * for new event types or bookings.
         *
         * @param id - The UUID of the location to deactivate.
         * @param options - Optional request options.
         * @returns The updated `SchedulingLocation` with `is_active: false`.
         *
         * @example
         * ```typescript
         * await admin.scheduling.locations.deactivate('loc_abc');
         * ```
         */
        deactivate: (id: string, options?: RequestOptions) => Promise<SchedulingLocation>;
    };
    /** Event Types — reusable templates for bookable appointment slots. */
    eventTypes: {
        /**
         * List event types in a workspace.
         *
         * @param workspaceId - The UUID of the workspace.
         * @param options - Optional pagination and request options.
         * @returns A page of `SchedulingEventType` records.
         */
        list: (workspaceId: string, options?: ListPaginationOptions) => Promise<SchedulingEventType[]>;
        /**
         * Retrieve a single event type by ID.
         *
         * @param id - The UUID of the event type.
         * @param options - Optional request options.
         * @returns The matching `SchedulingEventType`.
         */
        get: (id: string, options?: RequestOptions) => Promise<SchedulingEventType>;
        /**
         * Create a new event type.
         *
         * @param attributes - Event type attributes. `name` and
         *   `duration_minutes` are required.
         * @param options - Optional request options.
         * @returns The newly created `SchedulingEventType`.
         *
         * @example
         * ```typescript
         * const et = await admin.scheduling.eventTypes.create({
         *   name: '30-Minute Consultation',
         *   duration_minutes: 30,
         *   location_type: 'video',
         *   workspace_id: 'ws_abc',
         * });
         * ```
         */
        create: (attributes: CreateAdminSchedulingEventTypeAttributes, options?: RequestOptions) => Promise<SchedulingEventType>;
        /**
         * Update an event type. Slug cannot be changed.
         *
         * @param id - The UUID of the event type.
         * @param attributes - Subset of attributes to change.
         * @param options - Optional request options.
         * @returns The updated `SchedulingEventType`.
         *
         * @example
         * ```typescript
         * await admin.scheduling.eventTypes.update('et_abc', {
         *   duration_minutes: 45,
         *   requires_approval: true,
         * });
         * ```
         */
        update: (id: string, attributes: UpdateAdminSchedulingEventTypeAttributes, options?: RequestOptions) => Promise<SchedulingEventType>;
        /**
         * Archive an event type. Existing bookings are preserved; no new
         * bookings can be made against an archived type.
         *
         * @param id - The UUID of the event type to archive.
         * @param options - Optional request options.
         * @returns The updated `SchedulingEventType`.
         *
         * @example
         * ```typescript
         * await admin.scheduling.eventTypes.archive('et_abc');
         * ```
         */
        archive: (id: string, options?: RequestOptions) => Promise<SchedulingEventType>;
        /**
         * Look up an event type by its public slug within a workspace.
         *
         * @param slug - The slug (URL-friendly identifier).
         * @param workspaceId - The UUID of the workspace.
         * @param options - Optional request options.
         * @returns The matching `SchedulingEventType`.
         */
        getBySlug: (slug: string, workspaceId: string, options?: RequestOptions) => Promise<SchedulingEventType>;
    };
    /** Events — scheduled occurrences between workspace members. */
    events: {
        /**
         * List events in a workspace.
         *
         * @param workspaceId - The UUID of the workspace.
         * @param options - Optional pagination and request options.
         * @returns A page of `SchedulingEvent` records.
         */
        list: (workspaceId: string, options?: ListPaginationOptions) => Promise<SchedulingEvent[]>;
        /**
         * Retrieve a single event by ID.
         *
         * @param id - The UUID of the event.
         * @param options - Optional request options.
         * @returns The matching `SchedulingEvent`.
         */
        get: (id: string, options?: RequestOptions) => Promise<SchedulingEvent>;
        /**
         * Create a scheduled event.
         *
         * @param attributes - Event attributes. `start_time` and `end_time`
         *   are required.
         * @param options - Optional request options.
         * @returns The newly created `SchedulingEvent`.
         *
         * @example
         * ```typescript
         * const ev = await admin.scheduling.events.create({
         *   workspace_id: 'ws_abc',
         *   title: 'Team Sync',
         *   start_time: '2026-04-07T09:00:00Z',
         *   end_time: '2026-04-07T09:30:00Z',
         * });
         * ```
         */
        create: (attributes: CreateAdminSchedulingEventAttributes, options?: RequestOptions) => Promise<SchedulingEvent>;
        /**
         * Update event metadata (title, description, location, notes,
         * timezone). Use `reschedule` to move the time.
         *
         * @param id - The UUID of the event.
         * @param attributes - Subset of attributes to change.
         * @param options - Optional request options.
         * @returns The updated `SchedulingEvent`.
         *
         * @example
         * ```typescript
         * await admin.scheduling.events.update('se_abc', {
         *   title: 'Team Sync — agenda updated',
         * });
         * ```
         */
        update: (id: string, attributes: UpdateAdminSchedulingEventAttributes, options?: RequestOptions) => Promise<SchedulingEvent>;
        /**
         * Cancel an event.
         *
         * @param id - The UUID of the event to cancel.
         * @param attributes - Optional `{ cancellation_reason }`.
         * @param options - Optional request options.
         * @returns The updated `SchedulingEvent` with `status: "cancelled"`.
         *
         * @example
         * ```typescript
         * await admin.scheduling.events.cancel('se_abc', {
         *   cancellation_reason: 'Conflicting booking',
         * });
         * ```
         */
        cancel: (id: string, attributes?: CancelAdminSchedulingEventAttributes, options?: RequestOptions) => Promise<SchedulingEvent>;
        /**
         * Mark an event as completed.
         *
         * @param id - The UUID of the event.
         * @param options - Optional request options.
         * @returns The updated `SchedulingEvent` with `status: "completed"`.
         *
         * @example
         * ```typescript
         * await admin.scheduling.events.complete('se_abc');
         * ```
         */
        complete: (id: string, options?: RequestOptions) => Promise<SchedulingEvent>;
        /**
         * Reschedule an event to a new time window.
         *
         * @param id - The UUID of the event.
         * @param attributes - `{ new_start_time, new_end_time }` — both required.
         * @param options - Optional request options.
         * @returns The updated `SchedulingEvent` at the new time.
         *
         * @example
         * ```typescript
         * await admin.scheduling.events.reschedule('se_abc', {
         *   new_start_time: '2026-04-07T10:00:00Z',
         *   new_end_time: '2026-04-07T10:30:00Z',
         * });
         * ```
         */
        reschedule: (id: string, attributes: {
            new_start_time: string;
            new_end_time: string;
        }, options?: RequestOptions) => Promise<SchedulingEvent>;
        /**
         * List events within a date range.
         *
         * @param workspaceId - The UUID of the workspace.
         * @param startTime - ISO-8601 start of range.
         * @param endTime - ISO-8601 end of range.
         * @param options - Optional request options.
         * @returns Matching `SchedulingEvent` records.
         */
        listByDateRange: (workspaceId: string, startTime: string, endTime: string, options?: RequestOptions) => Promise<SchedulingEvent[]>;
        /**
         * List events for a participant within a workspace, scoped by their
         * email address.
         *
         * @param email - The participant's email.
         * @param workspaceId - The UUID of the workspace.
         * @param options - Optional request options.
         * @returns Matching `SchedulingEvent` records.
         */
        listByParticipant: (email: string, workspaceId: string, options?: RequestOptions) => Promise<SchedulingEvent[]>;
    };
    /** Participants — people attending scheduling events. */
    participants: {
        /**
         * List participants for a specific event.
         *
         * @param eventId - The UUID of the **event** (NOT a participant).
         * @param options - Optional pagination and request options.
         * @returns Participant records for the event.
         */
        list: (eventId: string, options?: ListPaginationOptions) => Promise<SchedulingParticipant[]>;
        /**
         * Retrieve a participant by ID.
         *
         * @param id - The UUID of the participant.
         * @param options - Optional request options.
         * @returns The matching `SchedulingParticipant`.
         */
        get: (id: string, options?: RequestOptions) => Promise<SchedulingParticipant>;
        /**
         * Add a participant to an event.
         *
         * @param attributes - Participant attributes. `event_id` and `email`
         *   are required.
         * @param options - Optional request options.
         * @returns The newly created `SchedulingParticipant`.
         *
         * @example
         * ```typescript
         * await admin.scheduling.participants.create({
         *   event_id: 'se_abc',
         *   email: 'alice@example.com',
         *   name: 'Alice',
         * });
         * ```
         */
        create: (attributes: CreateAdminSchedulingParticipantAttributes, options?: RequestOptions) => Promise<SchedulingParticipant>;
        /**
         * Update a participant's metadata. Use `respond` for RSVP changes.
         *
         * @param id - The UUID of the participant.
         * @param attributes - Subset of attributes to change.
         * @param options - Optional request options.
         * @returns The updated `SchedulingParticipant`.
         *
         * @example
         * ```typescript
         * await admin.scheduling.participants.update('pp_abc', {
         *   role: 'organizer',
         * });
         * ```
         */
        update: (id: string, attributes: UpdateAdminSchedulingParticipantAttributes, options?: RequestOptions) => Promise<SchedulingParticipant>;
        /**
         * Record a participant's RSVP response.
         *
         * @param id - The UUID of the participant.
         * @param status - One of "accepted" | "declined" | "tentative".
         * @param options - Optional request options.
         * @returns The updated `SchedulingParticipant`.
         *
         * @example
         * ```typescript
         * await admin.scheduling.participants.respond('pp_abc', 'accepted');
         * ```
         */
        respond: (id: string, status: "accepted" | "declined" | "tentative", options?: RequestOptions) => Promise<SchedulingParticipant>;
        /**
         * Remove a participant from an event.
         *
         * @param id - The UUID of the participant.
         * @param options - Optional request options.
         * @returns `true` on success.
         */
        remove: (id: string, options?: RequestOptions) => Promise<true>;
    };
    /** Availability Rules — when someone/something is bookable. */
    availabilityRules: {
        /**
         * List availability rules in a workspace.
         *
         * @param workspaceId - The UUID of the workspace.
         * @param options - Optional pagination and request options.
         * @returns A page of `SchedulingAvailabilityRule` records.
         */
        list: (workspaceId: string, options?: ListPaginationOptions) => Promise<SchedulingAvailabilityRule[]>;
        /**
         * Retrieve an availability rule by ID.
         *
         * @param id - The UUID of the rule.
         * @param options - Optional request options.
         * @returns The matching `SchedulingAvailabilityRule`.
         */
        get: (id: string, options?: RequestOptions) => Promise<SchedulingAvailabilityRule>;
        /**
         * Create an availability rule.
         *
         * @param attributes - Rule attributes. `workspace_id` and `type`
         *   are required.
         * @param options - Optional request options.
         * @returns The newly created `SchedulingAvailabilityRule`.
         *
         * @example
         * ```typescript
         * await admin.scheduling.availabilityRules.create({
         *   workspace_id: 'ws_abc',
         *   type: 'recurring',
         *   user_id: 'usr_def',
         *   weekly_schedule: { mon: [{ start: '09:00', end: '17:00' }] },
         *   timezone: 'America/New_York',
         * });
         * ```
         */
        create: (attributes: CreateAdminSchedulingAvailabilityRuleAttributes, options?: RequestOptions) => Promise<SchedulingAvailabilityRule>;
        /**
         * Update an availability rule.
         *
         * @param id - The UUID of the rule.
         * @param attributes - Subset of attributes to change.
         * @param options - Optional request options.
         * @returns The updated `SchedulingAvailabilityRule`.
         *
         * @example
         * ```typescript
         * await admin.scheduling.availabilityRules.update('ar_abc', {
         *   is_active: false,
         * });
         * ```
         */
        update: (id: string, attributes: UpdateAdminSchedulingAvailabilityRuleAttributes, options?: RequestOptions) => Promise<SchedulingAvailabilityRule>;
        /**
         * Permanently delete an availability rule.
         *
         * @param id - The UUID of the rule.
         * @param options - Optional request options.
         * @returns `true` on success.
         */
        destroy: (id: string, options?: RequestOptions) => Promise<true>;
        /**
         * List availability rules for a specific user.
         *
         * @param userId - The UUID of the user.
         * @param options - Optional request options.
         * @returns Matching `SchedulingAvailabilityRule` records.
         */
        listByUser: (userId: string, options?: RequestOptions) => Promise<SchedulingAvailabilityRule[]>;
        /**
         * List availability rules for a specific event type.
         *
         * @param eventTypeId - The UUID of the event type.
         * @param options - Optional request options.
         * @returns Matching `SchedulingAvailabilityRule` records.
         */
        listByEventType: (eventTypeId: string, options?: RequestOptions) => Promise<SchedulingAvailabilityRule[]>;
    };
    /** Bookings — external party appointment requests. */
    bookings: {
        /**
         * List bookings in a workspace.
         *
         * @param workspaceId - The UUID of the workspace.
         * @param options - Optional pagination and request options.
         * @returns A page of `SchedulingBooking` records.
         */
        list: (workspaceId: string, options?: ListPaginationOptions) => Promise<SchedulingBooking[]>;
        /**
         * Retrieve a booking by ID.
         *
         * @param id - The UUID of the booking.
         * @param options - Optional request options.
         * @returns The matching `SchedulingBooking`.
         */
        get: (id: string, options?: RequestOptions) => Promise<SchedulingBooking>;
        /**
         * Create a booking.
         *
         * @param attributes - Booking attributes. `event_type_id`,
         *   `start_time`, `end_time`, `booker_name`, `booker_email`
         *   are all required.
         * @param options - Optional request options.
         * @returns The newly created `SchedulingBooking`.
         *
         * @example
         * ```typescript
         * await admin.scheduling.bookings.create({
         *   event_type_id: 'et_abc',
         *   start_time: '2026-04-07T09:00:00Z',
         *   end_time: '2026-04-07T09:30:00Z',
         *   booker_name: 'Alice',
         *   booker_email: 'alice@example.com',
         *   workspace_id: 'ws_abc',
         * });
         * ```
         */
        create: (attributes: CreateAdminSchedulingBookingAttributes, options?: RequestOptions) => Promise<SchedulingBooking>;
        /**
         * Confirm a pending booking.
         *
         * @param id - The UUID of the booking.
         * @param options - Optional request options.
         * @returns The updated `SchedulingBooking` with `status: "confirmed"`.
         *
         * @example
         * ```typescript
         * await admin.scheduling.bookings.confirm('sb_abc');
         * ```
         */
        confirm: (id: string, options?: RequestOptions) => Promise<SchedulingBooking>;
        /**
         * Cancel a booking.
         *
         * @param id - The UUID of the booking.
         * @param attributes - Optional `{ cancellation_reason, cancelled_by }`.
         * @param options - Optional request options.
         * @returns The updated `SchedulingBooking` with `status: "cancelled"`.
         *
         * @example
         * ```typescript
         * await admin.scheduling.bookings.cancel('sb_abc', {
         *   cancellation_reason: 'Schedule conflict',
         *   cancelled_by: 'organizer',
         * });
         * ```
         */
        cancel: (id: string, attributes?: CancelAdminSchedulingBookingAttributes, options?: RequestOptions) => Promise<SchedulingBooking>;
        /**
         * Reschedule a booking. Both `new_start_time` and `new_end_time`
         * are required.
         *
         * @param id - The UUID of the booking.
         * @param attributes - `{ new_start_time, new_end_time }`.
         * @param options - Optional request options.
         * @returns The updated `SchedulingBooking` at the new time.
         *
         * @example
         * ```typescript
         * await admin.scheduling.bookings.reschedule('sb_abc', {
         *   new_start_time: '2026-04-22T14:00:00Z',
         *   new_end_time: '2026-04-22T14:30:00Z',
         * });
         * ```
         */
        reschedule: (id: string, attributes: RescheduleAdminSchedulingBookingAttributes, options?: RequestOptions) => Promise<SchedulingBooking>;
        /**
         * Mark a booking as a no-show after the scheduled time has passed.
         *
         * @param id - The UUID of the booking.
         * @param options - Optional request options.
         * @returns The updated `SchedulingBooking` with `status: "no_show"`.
         *
         * @example
         * ```typescript
         * await admin.scheduling.bookings.markNoShow('sb_abc');
         * ```
         */
        markNoShow: (id: string, options?: RequestOptions) => Promise<SchedulingBooking>;
        /**
         * List bookings filtered by booker email address.
         *
         * @param email - The booker's email address.
         * @param options - Optional request options.
         * @returns Matching `SchedulingBooking` records.
         */
        listByBooker: (email: string, options?: RequestOptions) => Promise<SchedulingBooking[]>;
    };
    /** Reminders — scheduled notifications tied to events. */
    reminders: {
        /**
         * List pending reminders.
         *
         * @param options - Optional pagination and request options.
         * @returns Pending `SchedulingReminder` records.
         */
        list: (options?: ListPaginationOptions) => Promise<SchedulingReminder[]>;
        /**
         * Retrieve a reminder by ID.
         *
         * @param id - The UUID of the reminder.
         * @param options - Optional request options.
         * @returns The matching `SchedulingReminder`.
         */
        get: (id: string, options?: RequestOptions) => Promise<SchedulingReminder>;
        /**
         * Create a reminder. Normally created by the platform's
         * `ScheduleReminders` change on Event/Booking creation.
         *
         * @param attributes - Reminder attributes. `event_id`,
         *   `minutes_before`, `scheduled_at`, `channel`, `workspace_id`
         *   are required.
         * @param options - Optional request options.
         * @returns The newly created `SchedulingReminder`.
         *
         * @example
         * ```typescript
         * await admin.scheduling.reminders.create({
         *   event_id: 'se_abc',
         *   minutes_before: 60,
         *   scheduled_at: '2026-04-07T08:00:00Z',
         *   channel: 'email',
         *   workspace_id: 'ws_abc',
         * });
         * ```
         */
        create: (attributes: CreateAdminSchedulingReminderAttributes, options?: RequestOptions) => Promise<SchedulingReminder>;
        /**
         * Cancel a pending reminder.
         *
         * @param id - The UUID of the reminder.
         * @param options - Optional request options.
         * @returns The updated `SchedulingReminder` with `status: "cancelled"`.
         *
         * @example
         * ```typescript
         * await admin.scheduling.reminders.cancel('rm_abc');
         * ```
         */
        cancel: (id: string, options?: RequestOptions) => Promise<SchedulingReminder>;
    };
    /** Calendar Syncs — bi-directional external calendar integrations. */
    calendarSyncs: {
        /**
         * List calendar syncs.
         *
         * @param options - Optional pagination and request options.
         * @returns A page of `SchedulingCalendarSync` records.
         */
        list: (options?: ListPaginationOptions) => Promise<SchedulingCalendarSync[]>;
        /**
         * Retrieve a calendar sync by ID.
         *
         * @param id - The UUID of the sync.
         * @param options - Optional request options.
         * @returns The matching `SchedulingCalendarSync`.
         */
        get: (id: string, options?: RequestOptions) => Promise<SchedulingCalendarSync>;
        /**
         * Create a calendar sync. Required: `workspace_id`, `user_id`,
         * `connector_id`, `provider`, `calendar_external_id`. For HIPAA
         * workspaces, `baa_attestation` is also required.
         *
         * @param attributes - Calendar sync attributes.
         * @param options - Optional request options.
         * @returns The newly created `SchedulingCalendarSync`.
         *
         * @example
         * ```typescript
         * await admin.scheduling.calendarSyncs.create({
         *   workspace_id: 'ws_abc',
         *   user_id: 'usr_def',
         *   connector_id: 'cn_oauth_xyz',
         *   provider: 'google',
         *   calendar_external_id: 'primary',
         *   role: 'both',
         * });
         * ```
         */
        create: (attributes: CreateAdminSchedulingCalendarSyncAttributes, options?: RequestOptions) => Promise<SchedulingCalendarSync>;
        /**
         * Update a calendar sync. There is NO `enabled` field — use
         * `pause()` / `resume()` to toggle sync state.
         *
         * @param id - The UUID of the sync.
         * @param attributes - Subset of attributes to change.
         * @param options - Optional request options.
         * @returns The updated `SchedulingCalendarSync`.
         *
         * @example
         * ```typescript
         * await admin.scheduling.calendarSyncs.update('cs_abc', {
         *   role: 'add_events',
         *   poll_interval_minutes: 10,
         * });
         * ```
         */
        update: (id: string, attributes: UpdateAdminSchedulingCalendarSyncAttributes, options?: RequestOptions) => Promise<SchedulingCalendarSync>;
        /**
         * Pause a calendar sync. Sync workers skip paused syncs.
         *
         * @param id - The UUID of the sync.
         * @param options - Optional request options.
         * @returns The updated `SchedulingCalendarSync` with `sync_status: "paused"`.
         *
         * @example
         * ```typescript
         * await admin.scheduling.calendarSyncs.pause('cs_abc');
         * ```
         */
        pause: (id: string, options?: RequestOptions) => Promise<SchedulingCalendarSync>;
        /**
         * Resume a paused calendar sync. Resets `error_count` to 0.
         *
         * @param id - The UUID of the sync.
         * @param options - Optional request options.
         * @returns The updated `SchedulingCalendarSync` with `sync_status: "active"`.
         *
         * @example
         * ```typescript
         * await admin.scheduling.calendarSyncs.resume('cs_abc');
         * ```
         */
        resume: (id: string, options?: RequestOptions) => Promise<SchedulingCalendarSync>;
        /**
         * Permanently delete a calendar sync.
         *
         * @param id - The UUID of the sync.
         * @param options - Optional request options.
         * @returns `true` on success.
         */
        delete: (id: string, options?: RequestOptions) => Promise<true>;
    };
};
export {};
//# sourceMappingURL=scheduling.d.ts.map