recal-sdk 0.3.3 → 1.0.0

package/dist/client/types.gen.d.ts

@@ -0,0 +1,1765 @@
+export type ClientOptions = {
+    baseUrl: 'https://api.recal.dev' | (string & {});
+};
+/**
+ * User
+ */
+export type User = {
+    createdAt: Date;
+    id: string;
+};
+/**
+ * Organization
+ */
+export type Organization = {
+    createdAt: Date;
+    name: string | null;
+    slug: string;
+    members?: Array<User>;
+};
+/**
+ * OAuth Connection
+ */
+export type AuthConnection = {
+    alive: boolean;
+    email: string | null;
+    expiresAt: Date | null;
+    provider: 'google' | 'microsoft';
+    scope: Array<string>;
+    accessToken?: unknown;
+    refreshToken?: unknown;
+};
+/**
+ * Recal Normalized Time Range
+ */
+export type TimeRange = {
+    /**
+     * End time of the time range in ISO format
+     */
+    end: Date;
+    /**
+     * Start time of the time range in ISO format
+     */
+    start: Date;
+};
+/**
+ * Recal Normalized Calendar
+ */
+export type Calendar = {
+    id: string;
+    original: unknown;
+    provider: 'google' | 'microsoft';
+    accessRole?: 'freeBusyReader' | 'owner' | 'reader' | 'writer';
+    backgroundColor?: string;
+    foregroundColor?: string;
+    selected?: boolean;
+    subject?: string;
+    /**
+     * A valid IANA timezone identifier
+     */
+    timeZone?: string;
+};
+/**
+ * Recal Normalized Event
+ */
+export type Event = {
+    /**
+     * Recal Normalized Attendee
+     */
+    attendees: Array<{
+        email: string;
+        original: unknown;
+        self: true;
+    } | {
+        email: string;
+        original: unknown;
+        responseStatus?: 'accepted' | 'declined' | 'needsAction' | 'tentative';
+    }>;
+    calendarId: string;
+    id: string;
+    original: unknown;
+    description?: string;
+    end?: Date;
+    location?: string;
+    metaId?: string;
+    start?: Date;
+    subject?: string;
+};
+/**
+ * Recal Normalized Meta Event
+ */
+export type MetaEvent = {
+    /**
+     * Recal Normalized Meta Event Attendee
+     */
+    attendees: Array<{
+        email: string;
+        originals: Array<unknown>;
+        self: true;
+    } | {
+        email: string;
+        originals: Array<unknown>;
+        responseStatus?: 'accepted' | 'declined' | 'needsAction' | 'tentative';
+    }>;
+    originals: Array<unknown>;
+    description?: string;
+    end?: Date;
+    location?: string;
+    metaId?: string;
+    start?: Date;
+    subject?: string;
+};
+/**
+ * Recal Normalized Create Meta Event
+ */
+export type CreateMetaEvent = {
+    attendees?: Array<{
+        email: string;
+    }>;
+    description?: string;
+    end?: string;
+    location?: string;
+    meeting?: {
+        url: string;
+    } | boolean;
+    metaId?: string;
+    sendNotificationsFor?: Array<'google' | 'microsoft'>;
+    start?: string;
+    subject?: string;
+};
+/**
+ * Recal Normalized Update Meta Event
+ */
+export type UpdateMetaEvent = {
+    attendees?: Array<{
+        email: string;
+    }>;
+    description?: string;
+    end?: string;
+    location?: string;
+    meeting?: {
+        url: string;
+    } | boolean;
+    metaId?: string;
+    sendNotificationsFor?: Array<'google' | 'microsoft'>;
+    start?: string;
+    subject?: string;
+};
+/**
+ * Recal Normalized Create Event
+ */
+export type CreateEvent = {
+    attendees?: Array<{
+        email: string;
+    }>;
+    description?: string;
+    end?: string;
+    id?: string;
+    location?: string;
+    meeting?: {
+        url: string;
+    } | boolean;
+    metaId?: string;
+    sendNotifications?: boolean;
+    start?: string;
+    subject?: string;
+};
+/**
+ * Recal Normalized Update Event
+ */
+export type UpdateEvent = {
+    attendees?: Array<{
+        email: string;
+    }>;
+    description?: string;
+    end?: string;
+    id?: string;
+    location?: string;
+    meeting?: {
+        url: string;
+    } | boolean;
+    metaId?: string;
+    sendNotifications?: boolean;
+    start?: string;
+    subject?: string;
+};
+export type GetV1OrganizationsData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/organizations';
+};
+export type GetV1OrganizationsResponses = {
+    /**
+     * All organizations
+     */
+    200: {
+        data: Array<Organization>;
+    };
+};
+export type GetV1OrganizationsResponse = GetV1OrganizationsResponses[keyof GetV1OrganizationsResponses];
+export type PostV1OrganizationsData = {
+    body?: {
+        name: string | null;
+        slug: string;
+    };
+    path?: never;
+    query?: never;
+    url: '/v1/organizations';
+};
+export type PostV1OrganizationsErrors = {
+    /**
+     * Organization with slug already exists
+     */
+    409: {
+        data: null;
+        error: string;
+    };
+};
+export type PostV1OrganizationsError = PostV1OrganizationsErrors[keyof PostV1OrganizationsErrors];
+export type PostV1OrganizationsResponses = {
+    /**
+     * Created organization
+     */
+    200: {
+        data: Organization;
+    };
+};
+export type PostV1OrganizationsResponse = PostV1OrganizationsResponses[keyof PostV1OrganizationsResponses];
+export type DeleteV1OrganizationsOrgSlugData = {
+    body?: never;
+    path: {
+        orgSlug: string;
+    };
+    query?: never;
+    url: '/v1/organizations/{orgSlug}';
+};
+export type DeleteV1OrganizationsOrgSlugErrors = {
+    /**
+     * Organization not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type DeleteV1OrganizationsOrgSlugError = DeleteV1OrganizationsOrgSlugErrors[keyof DeleteV1OrganizationsOrgSlugErrors];
+export type DeleteV1OrganizationsOrgSlugResponses = {
+    /**
+     * Deleted organization
+     */
+    200: {
+        data: Organization;
+    };
+};
+export type DeleteV1OrganizationsOrgSlugResponse = DeleteV1OrganizationsOrgSlugResponses[keyof DeleteV1OrganizationsOrgSlugResponses];
+export type GetV1OrganizationsOrgSlugData = {
+    body?: never;
+    path: {
+        orgSlug: string;
+    };
+    query?: never;
+    url: '/v1/organizations/{orgSlug}';
+};
+export type GetV1OrganizationsOrgSlugErrors = {
+    /**
+     * Organization not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type GetV1OrganizationsOrgSlugError = GetV1OrganizationsOrgSlugErrors[keyof GetV1OrganizationsOrgSlugErrors];
+export type GetV1OrganizationsOrgSlugResponses = {
+    /**
+     * Organization
+     */
+    200: {
+        data: Organization;
+    };
+};
+export type GetV1OrganizationsOrgSlugResponse = GetV1OrganizationsOrgSlugResponses[keyof GetV1OrganizationsOrgSlugResponses];
+export type PutV1OrganizationsOrgSlugData = {
+    body?: {
+        name: string | null;
+        slug: string;
+    };
+    path: {
+        orgSlug: string;
+    };
+    query?: never;
+    url: '/v1/organizations/{orgSlug}';
+};
+export type PutV1OrganizationsOrgSlugErrors = {
+    /**
+     * Organization not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type PutV1OrganizationsOrgSlugError = PutV1OrganizationsOrgSlugErrors[keyof PutV1OrganizationsOrgSlugErrors];
+export type PutV1OrganizationsOrgSlugResponses = {
+    /**
+     * Updated organization
+     */
+    200: {
+        data: Organization;
+    };
+};
+export type PutV1OrganizationsOrgSlugResponse = PutV1OrganizationsOrgSlugResponses[keyof PutV1OrganizationsOrgSlugResponses];
+export type DeleteV1OrganizationsOrgSlugMembersData = {
+    body?: {
+        userIds: Array<string>;
+    };
+    path: {
+        orgSlug: string;
+    };
+    query?: never;
+    url: '/v1/organizations/{orgSlug}/members';
+};
+export type DeleteV1OrganizationsOrgSlugMembersErrors = {
+    /**
+     * Organization not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type DeleteV1OrganizationsOrgSlugMembersError = DeleteV1OrganizationsOrgSlugMembersErrors[keyof DeleteV1OrganizationsOrgSlugMembersErrors];
+export type DeleteV1OrganizationsOrgSlugMembersResponses = {
+    200: {
+        data: string;
+    };
+};
+export type DeleteV1OrganizationsOrgSlugMembersResponse = DeleteV1OrganizationsOrgSlugMembersResponses[keyof DeleteV1OrganizationsOrgSlugMembersResponses];
+export type GetV1OrganizationsOrgSlugMembersData = {
+    body?: never;
+    path: {
+        orgSlug: string;
+    };
+    query?: {
+        include?: Array<'oauthConnections' | 'organizations'> | 'oauthConnections' | 'organizations';
+    };
+    url: '/v1/organizations/{orgSlug}/members';
+};
+export type GetV1OrganizationsOrgSlugMembersErrors = {
+    /**
+     * Organization not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type GetV1OrganizationsOrgSlugMembersError = GetV1OrganizationsOrgSlugMembersErrors[keyof GetV1OrganizationsOrgSlugMembersErrors];
+export type GetV1OrganizationsOrgSlugMembersResponses = {
+    /**
+     * All members of an organization
+     */
+    200: {
+        data: Array<{
+            createdAt: Date;
+            id: string;
+            oauthConnections?: Array<AuthConnection>;
+            organizations?: Array<Organization>;
+        }>;
+    };
+};
+export type GetV1OrganizationsOrgSlugMembersResponse = GetV1OrganizationsOrgSlugMembersResponses[keyof GetV1OrganizationsOrgSlugMembersResponses];
+export type PostV1OrganizationsOrgSlugMembersData = {
+    body?: {
+        userIds: Array<string>;
+    };
+    path: {
+        orgSlug: string;
+    };
+    query?: never;
+    url: '/v1/organizations/{orgSlug}/members';
+};
+export type PostV1OrganizationsOrgSlugMembersErrors = {
+    /**
+     * Organization not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type PostV1OrganizationsOrgSlugMembersError = PostV1OrganizationsOrgSlugMembersErrors[keyof PostV1OrganizationsOrgSlugMembersErrors];
+export type PostV1OrganizationsOrgSlugMembersResponses = {
+    /**
+     * All users are already members of the organization
+     */
+    200: {
+        data: string;
+    };
+    /**
+     * n users added successfully to the organization
+     */
+    201: {
+        data: string;
+    };
+};
+export type PostV1OrganizationsOrgSlugMembersResponse = PostV1OrganizationsOrgSlugMembersResponses[keyof PostV1OrganizationsOrgSlugMembersResponses];
+export type GetV1OrganizationsOrgSlugCalendarBusyData = {
+    body?: never;
+    path: {
+        orgSlug: string;
+    };
+    query: {
+        end: string;
+        start: string;
+        /**
+         * Boolean query parameter (accepts "true" or "false")
+         */
+        primaryOnly?: 'false' | 'true';
+        provider?: Array<'google' | 'microsoft'> | 'google' | 'microsoft';
+    };
+    url: '/v1/organizations/{orgSlug}/calendar/busy';
+};
+export type GetV1OrganizationsOrgSlugCalendarBusyErrors = {
+    /**
+     * Organization not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type GetV1OrganizationsOrgSlugCalendarBusyError = GetV1OrganizationsOrgSlugCalendarBusyErrors[keyof GetV1OrganizationsOrgSlugCalendarBusyErrors];
+export type GetV1OrganizationsOrgSlugCalendarBusyResponses = {
+    /**
+     * Busy times of all users of an organization
+     */
+    200: {
+        data: Array<TimeRange>;
+    };
+};
+export type GetV1OrganizationsOrgSlugCalendarBusyResponse = GetV1OrganizationsOrgSlugCalendarBusyResponses[keyof GetV1OrganizationsOrgSlugCalendarBusyResponses];
+export type GetV1OrganizationsOrgSlugSchedulingData = {
+    body?: never;
+    path: {
+        orgSlug: string;
+    };
+    query: {
+        /**
+         * End time of the time range in ISO format
+         */
+        end: string;
+        /**
+         * Padding in minutes to add before and after busy times
+         */
+        padding: string | unknown;
+        /**
+         * Duration of each slot in minutes
+         */
+        slotDuration: string | unknown;
+        /**
+         * Start time of the time range in ISO format
+         */
+        start: string;
+        /**
+         * Requested earliest time of each day (in the time zone of the request)
+         */
+        earliestTimeEachDay?: string;
+        /**
+         * Requested latest time of each day (in the time zone of the request)
+         */
+        latestTimeEachDay?: string;
+        /**
+         * An integer >= 0 (default: 0)
+         */
+        maxOverlaps?: string | unknown;
+        provider?: Array<'google' | 'microsoft'> | 'google' | 'microsoft';
+    };
+    url: '/v1/organizations/{orgSlug}/scheduling';
+};
+export type GetV1OrganizationsOrgSlugSchedulingErrors = {
+    /**
+     * Organization not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type GetV1OrganizationsOrgSlugSchedulingError = GetV1OrganizationsOrgSlugSchedulingErrors[keyof GetV1OrganizationsOrgSlugSchedulingErrors];
+export type GetV1OrganizationsOrgSlugSchedulingResponses = {
+    /**
+     * Available time slots
+     */
+    200: {
+        data: {
+            availableSlots: Array<{
+                /**
+                 * End time of the time range in ISO format
+                 */
+                end: Date;
+                /**
+                 * Start time of the time range in ISO format
+                 */
+                start: Date;
+                userId: string;
+            }>;
+            options: {
+                /**
+                 * End time of the time range in ISO format
+                 */
+                end: Date;
+                maxOverlaps: number;
+                /**
+                 * Padding in minutes to add before and after busy times
+                 */
+                padding: number;
+                /**
+                 * Duration of each slot in minutes
+                 */
+                slotDuration: number;
+                /**
+                 * Start time of the time range in ISO format
+                 */
+                start: Date;
+                /**
+                 * Requested earliest time of each day (in the time zone of the request)
+                 */
+                earliestTimeEachDay?: string;
+                /**
+                 * Requested latest time of each day (in the time zone of the request)
+                 */
+                latestTimeEachDay?: string;
+            };
+        };
+    };
+};
+export type GetV1OrganizationsOrgSlugSchedulingResponse = GetV1OrganizationsOrgSlugSchedulingResponses[keyof GetV1OrganizationsOrgSlugSchedulingResponses];
+export type GetV1UsersData = {
+    body?: never;
+    path?: never;
+    query?: never;
+    url: '/v1/users';
+};
+export type GetV1UsersResponses = {
+    /**
+     * List of users
+     */
+    200: {
+        data: Array<{
+            createdAt: Date;
+            id: string;
+            oauthConnections?: Array<AuthConnection>;
+            organizations?: Array<Organization>;
+        }>;
+    };
+};
+export type GetV1UsersResponse = GetV1UsersResponses[keyof GetV1UsersResponses];
+export type PostV1UsersData = {
+    body?: {
+        id: string;
+        organizationSlugs?: Array<string>;
+    };
+    path?: never;
+    query?: never;
+    url: '/v1/users';
+};
+export type PostV1UsersErrors = {
+    /**
+     * Organization not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+    /**
+     * User already exists
+     */
+    409: {
+        data: null;
+        error: string;
+    };
+};
+export type PostV1UsersError = PostV1UsersErrors[keyof PostV1UsersErrors];
+export type PostV1UsersResponses = {
+    /**
+     * Created user
+     */
+    201: {
+        data: {
+            createdAt: Date;
+            id: string;
+            oauthConnections?: Array<AuthConnection>;
+            organizations?: Array<Organization>;
+        };
+    };
+};
+export type PostV1UsersResponse = PostV1UsersResponses[keyof PostV1UsersResponses];
+export type DeleteV1UsersUserIdData = {
+    body?: never;
+    path: {
+        userId: string;
+    };
+    query?: never;
+    url: '/v1/users/{userId}';
+};
+export type DeleteV1UsersUserIdErrors = {
+    /**
+     * User not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type DeleteV1UsersUserIdError = DeleteV1UsersUserIdErrors[keyof DeleteV1UsersUserIdErrors];
+export type DeleteV1UsersUserIdResponses = {
+    /**
+     * User
+     */
+    200: {
+        data: {
+            createdAt: Date;
+            id: string;
+            oauthConnections?: Array<AuthConnection>;
+            organizations?: Array<Organization>;
+        };
+    };
+};
+export type DeleteV1UsersUserIdResponse = DeleteV1UsersUserIdResponses[keyof DeleteV1UsersUserIdResponses];
+export type GetV1UsersUserIdData = {
+    body?: never;
+    path: {
+        userId: string;
+    };
+    query?: {
+        include?: Array<'oauthConnections' | 'organizations'> | 'oauthConnections' | 'organizations';
+    };
+    url: '/v1/users/{userId}';
+};
+export type GetV1UsersUserIdErrors = {
+    /**
+     * User not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type GetV1UsersUserIdError = GetV1UsersUserIdErrors[keyof GetV1UsersUserIdErrors];
+export type GetV1UsersUserIdResponses = {
+    /**
+     * User
+     */
+    200: {
+        data: {
+            createdAt: Date;
+            id: string;
+            oauthConnections?: Array<AuthConnection>;
+            organizations?: Array<Organization>;
+        };
+    };
+};
+export type GetV1UsersUserIdResponse = GetV1UsersUserIdResponses[keyof GetV1UsersUserIdResponses];
+export type PutV1UsersUserIdData = {
+    body?: {
+        userId: string;
+    };
+    path: {
+        userId: string;
+    };
+    query?: never;
+    url: '/v1/users/{userId}';
+};
+export type PutV1UsersUserIdErrors = {
+    /**
+     * User not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+    /**
+     * User already exists
+     */
+    409: {
+        data: null;
+        error: string;
+    };
+};
+export type PutV1UsersUserIdError = PutV1UsersUserIdErrors[keyof PutV1UsersUserIdErrors];
+export type PutV1UsersUserIdResponses = {
+    /**
+     * User
+     */
+    200: {
+        data: {
+            createdAt: Date;
+            id: string;
+            oauthConnections?: Array<AuthConnection>;
+            organizations?: Array<Organization>;
+        };
+    };
+};
+export type PutV1UsersUserIdResponse = PutV1UsersUserIdResponses[keyof PutV1UsersUserIdResponses];
+export type GetV1UsersUserIdOrganizationsData = {
+    body?: never;
+    path: {
+        userId: string;
+    };
+    query?: never;
+    url: '/v1/users/{userId}/organizations';
+};
+export type GetV1UsersUserIdOrganizationsErrors = {
+    /**
+     * User not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type GetV1UsersUserIdOrganizationsError = GetV1UsersUserIdOrganizationsErrors[keyof GetV1UsersUserIdOrganizationsErrors];
+export type GetV1UsersUserIdOrganizationsResponses = {
+    /**
+     * List of organizations
+     */
+    200: {
+        data: Array<Organization>;
+    };
+};
+export type GetV1UsersUserIdOrganizationsResponse = GetV1UsersUserIdOrganizationsResponses[keyof GetV1UsersUserIdOrganizationsResponses];
+export type GetV1UsersUserIdCalendarData = {
+    body?: never;
+    path: {
+        userId: string;
+    };
+    query?: {
+        provider?: Array<'google' | 'microsoft'> | 'google' | 'microsoft';
+    };
+    url: '/v1/users/{userId}/calendar';
+};
+export type GetV1UsersUserIdCalendarErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        data: null;
+        error: string;
+    };
+    /**
+     * User not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type GetV1UsersUserIdCalendarError = GetV1UsersUserIdCalendarErrors[keyof GetV1UsersUserIdCalendarErrors];
+export type GetV1UsersUserIdCalendarResponses = {
+    /**
+     * List of calendars
+     */
+    200: {
+        data: Array<Calendar>;
+    };
+};
+export type GetV1UsersUserIdCalendarResponse = GetV1UsersUserIdCalendarResponses[keyof GetV1UsersUserIdCalendarResponses];
+export type GetV1UsersUserIdCalendarBusyData = {
+    body?: never;
+    path: {
+        userId: string;
+    };
+    query: {
+        /**
+         * End time of the time range in ISO format
+         */
+        end: string;
+        /**
+         * Start time of the time range in ISO format
+         */
+        start: string;
+        calendarIds?: Array<string>;
+        provider?: Array<'google' | 'microsoft'> | 'google' | 'microsoft';
+    };
+    url: '/v1/users/{userId}/calendar/busy';
+};
+export type GetV1UsersUserIdCalendarBusyErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        data: null;
+        error: string;
+    };
+    /**
+     * User not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type GetV1UsersUserIdCalendarBusyError = GetV1UsersUserIdCalendarBusyErrors[keyof GetV1UsersUserIdCalendarBusyErrors];
+export type GetV1UsersUserIdCalendarBusyResponses = {
+    /**
+     * List of busy intervals
+     */
+    200: {
+        data: Array<TimeRange>;
+    };
+};
+export type GetV1UsersUserIdCalendarBusyResponse = GetV1UsersUserIdCalendarBusyResponses[keyof GetV1UsersUserIdCalendarBusyResponses];
+export type GetV1UsersUserIdCalendarEventsData = {
+    body?: never;
+    path: {
+        userId: string;
+    };
+    query: {
+        /**
+         * End time of the time range in ISO format
+         */
+        end: string;
+        /**
+         * Start time of the time range in ISO format
+         */
+        start: string;
+        calendarIds?: Array<string>;
+        provider?: Array<'google' | 'microsoft'> | 'google' | 'microsoft';
+    };
+    url: '/v1/users/{userId}/calendar/events';
+};
+export type GetV1UsersUserIdCalendarEventsErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        data: null;
+        error: string;
+    };
+    /**
+     * User not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type GetV1UsersUserIdCalendarEventsError = GetV1UsersUserIdCalendarEventsErrors[keyof GetV1UsersUserIdCalendarEventsErrors];
+export type GetV1UsersUserIdCalendarEventsResponses = {
+    /**
+     * List of events
+     */
+    200: {
+        data: Array<Event>;
+    };
+};
+export type GetV1UsersUserIdCalendarEventsResponse = GetV1UsersUserIdCalendarEventsResponses[keyof GetV1UsersUserIdCalendarEventsResponses];
+export type PostV1UsersUserIdCalendarEventsMetaData = {
+    body?: CreateMetaEvent;
+    path: {
+        userId: string;
+    };
+    query?: {
+        provider?: Array<'google' | 'microsoft'> | 'google' | 'microsoft';
+    };
+    url: '/v1/users/{userId}/calendar/events/meta';
+};
+export type PostV1UsersUserIdCalendarEventsMetaErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        data: null;
+        error: string;
+    };
+    /**
+     * User not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type PostV1UsersUserIdCalendarEventsMetaError = PostV1UsersUserIdCalendarEventsMetaErrors[keyof PostV1UsersUserIdCalendarEventsMetaErrors];
+export type PostV1UsersUserIdCalendarEventsMetaResponses = {
+    /**
+     * Meta event created
+     */
+    200: {
+        data: MetaEvent;
+    };
+};
+export type PostV1UsersUserIdCalendarEventsMetaResponse = PostV1UsersUserIdCalendarEventsMetaResponses[keyof PostV1UsersUserIdCalendarEventsMetaResponses];
+export type DeleteV1UsersUserIdCalendarEventsMetaMetaIdData = {
+    body?: never;
+    path: {
+        metaId: string;
+        userId: string;
+    };
+    query?: {
+        provider?: Array<'google' | 'microsoft'> | 'google' | 'microsoft';
+    };
+    url: '/v1/users/{userId}/calendar/events/meta/{metaId}';
+};
+export type DeleteV1UsersUserIdCalendarEventsMetaMetaIdErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        data: null;
+        error: string;
+    };
+    /**
+     * Event not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type DeleteV1UsersUserIdCalendarEventsMetaMetaIdError = DeleteV1UsersUserIdCalendarEventsMetaMetaIdErrors[keyof DeleteV1UsersUserIdCalendarEventsMetaMetaIdErrors];
+export type DeleteV1UsersUserIdCalendarEventsMetaMetaIdResponses = {
+    /**
+     * Meta event deleted
+     */
+    200: {
+        data: {
+            success: true;
+        };
+    };
+};
+export type DeleteV1UsersUserIdCalendarEventsMetaMetaIdResponse = DeleteV1UsersUserIdCalendarEventsMetaMetaIdResponses[keyof DeleteV1UsersUserIdCalendarEventsMetaMetaIdResponses];
+export type GetV1UsersUserIdCalendarEventsMetaMetaIdData = {
+    body?: never;
+    path: {
+        metaId: string;
+        userId: string;
+    };
+    query?: {
+        provider?: Array<'google' | 'microsoft'> | 'google' | 'microsoft';
+    };
+    url: '/v1/users/{userId}/calendar/events/meta/{metaId}';
+};
+export type GetV1UsersUserIdCalendarEventsMetaMetaIdErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        data: null;
+        error: string;
+    };
+    /**
+     * Event not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type GetV1UsersUserIdCalendarEventsMetaMetaIdError = GetV1UsersUserIdCalendarEventsMetaMetaIdErrors[keyof GetV1UsersUserIdCalendarEventsMetaMetaIdErrors];
+export type GetV1UsersUserIdCalendarEventsMetaMetaIdResponses = {
+    /**
+     * Event
+     */
+    200: {
+        data: MetaEvent;
+    };
+};
+export type GetV1UsersUserIdCalendarEventsMetaMetaIdResponse = GetV1UsersUserIdCalendarEventsMetaMetaIdResponses[keyof GetV1UsersUserIdCalendarEventsMetaMetaIdResponses];
+export type PutV1UsersUserIdCalendarEventsMetaMetaIdData = {
+    body?: UpdateMetaEvent;
+    path: {
+        metaId: string;
+        userId: string;
+    };
+    query?: {
+        provider?: Array<'google' | 'microsoft'> | 'google' | 'microsoft';
+    };
+    url: '/v1/users/{userId}/calendar/events/meta/{metaId}';
+};
+export type PutV1UsersUserIdCalendarEventsMetaMetaIdErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        data: null;
+        error: string;
+    };
+    /**
+     * Event not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type PutV1UsersUserIdCalendarEventsMetaMetaIdError = PutV1UsersUserIdCalendarEventsMetaMetaIdErrors[keyof PutV1UsersUserIdCalendarEventsMetaMetaIdErrors];
+export type PutV1UsersUserIdCalendarEventsMetaMetaIdResponses = {
+    /**
+     * Meta event updated
+     */
+    200: {
+        data: MetaEvent;
+    };
+};
+export type PutV1UsersUserIdCalendarEventsMetaMetaIdResponse = PutV1UsersUserIdCalendarEventsMetaMetaIdResponses[keyof PutV1UsersUserIdCalendarEventsMetaMetaIdResponses];
+export type PostV1UsersUserIdCalendarEventsProviderCalendarIdData = {
+    body?: CreateEvent;
+    path: {
+        calendarId: string;
+        provider: 'google' | 'microsoft';
+        userId: string;
+    };
+    query?: never;
+    url: '/v1/users/{userId}/calendar/events/{provider}/{calendarId}';
+};
+export type PostV1UsersUserIdCalendarEventsProviderCalendarIdErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        data: null;
+        error: string;
+    };
+    /**
+     * User not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type PostV1UsersUserIdCalendarEventsProviderCalendarIdError = PostV1UsersUserIdCalendarEventsProviderCalendarIdErrors[keyof PostV1UsersUserIdCalendarEventsProviderCalendarIdErrors];
+export type PostV1UsersUserIdCalendarEventsProviderCalendarIdResponses = {
+    /**
+     * Event created
+     */
+    200: {
+        data: Event;
+    };
+};
+export type PostV1UsersUserIdCalendarEventsProviderCalendarIdResponse = PostV1UsersUserIdCalendarEventsProviderCalendarIdResponses[keyof PostV1UsersUserIdCalendarEventsProviderCalendarIdResponses];
+export type DeleteV1UsersUserIdCalendarEventsProviderCalendarIdEventIdData = {
+    body?: never;
+    path: {
+        calendarId: string;
+        eventId: string;
+        provider: 'google' | 'microsoft';
+        userId: string;
+    };
+    query?: never;
+    url: '/v1/users/{userId}/calendar/events/{provider}/{calendarId}/{eventId}';
+};
+export type DeleteV1UsersUserIdCalendarEventsProviderCalendarIdEventIdErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        data: null;
+        error: string;
+    };
+    /**
+     * User not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type DeleteV1UsersUserIdCalendarEventsProviderCalendarIdEventIdError = DeleteV1UsersUserIdCalendarEventsProviderCalendarIdEventIdErrors[keyof DeleteV1UsersUserIdCalendarEventsProviderCalendarIdEventIdErrors];
+export type DeleteV1UsersUserIdCalendarEventsProviderCalendarIdEventIdResponses = {
+    /**
+     * Event deleted
+     */
+    200: {
+        data: {
+            success: true;
+        };
+    };
+};
+export type DeleteV1UsersUserIdCalendarEventsProviderCalendarIdEventIdResponse = DeleteV1UsersUserIdCalendarEventsProviderCalendarIdEventIdResponses[keyof DeleteV1UsersUserIdCalendarEventsProviderCalendarIdEventIdResponses];
+export type GetV1UsersUserIdCalendarEventsProviderCalendarIdEventIdData = {
+    body?: never;
+    path: {
+        calendarId: string;
+        eventId: string;
+        provider: 'google' | 'microsoft';
+        userId: string;
+    };
+    query?: never;
+    url: '/v1/users/{userId}/calendar/events/{provider}/{calendarId}/{eventId}';
+};
+export type GetV1UsersUserIdCalendarEventsProviderCalendarIdEventIdErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        data: null;
+        error: string;
+    };
+    /**
+     * User not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type GetV1UsersUserIdCalendarEventsProviderCalendarIdEventIdError = GetV1UsersUserIdCalendarEventsProviderCalendarIdEventIdErrors[keyof GetV1UsersUserIdCalendarEventsProviderCalendarIdEventIdErrors];
+export type GetV1UsersUserIdCalendarEventsProviderCalendarIdEventIdResponses = {
+    /**
+     * Event found
+     */
+    200: {
+        data: Event;
+    };
+};
+export type GetV1UsersUserIdCalendarEventsProviderCalendarIdEventIdResponse = GetV1UsersUserIdCalendarEventsProviderCalendarIdEventIdResponses[keyof GetV1UsersUserIdCalendarEventsProviderCalendarIdEventIdResponses];
+export type PutV1UsersUserIdCalendarEventsProviderCalendarIdEventIdData = {
+    body?: UpdateEvent;
+    path: {
+        calendarId: string;
+        eventId: string;
+        provider: 'google' | 'microsoft';
+        userId: string;
+    };
+    query?: never;
+    url: '/v1/users/{userId}/calendar/events/{provider}/{calendarId}/{eventId}';
+};
+export type PutV1UsersUserIdCalendarEventsProviderCalendarIdEventIdErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        data: null;
+        error: string;
+    };
+    /**
+     * User not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type PutV1UsersUserIdCalendarEventsProviderCalendarIdEventIdError = PutV1UsersUserIdCalendarEventsProviderCalendarIdEventIdErrors[keyof PutV1UsersUserIdCalendarEventsProviderCalendarIdEventIdErrors];
+export type PutV1UsersUserIdCalendarEventsProviderCalendarIdEventIdResponses = {
+    /**
+     * Event updated
+     */
+    200: {
+        data: Event;
+    };
+};
+export type PutV1UsersUserIdCalendarEventsProviderCalendarIdEventIdResponse = PutV1UsersUserIdCalendarEventsProviderCalendarIdEventIdResponses[keyof PutV1UsersUserIdCalendarEventsProviderCalendarIdEventIdResponses];
+export type GetV1UsersUserIdOauthData = {
+    body?: never;
+    path: {
+        userId: string;
+    };
+    query?: {
+        /**
+         * Show access and refresh tokens
+         */
+        showToken?: 'false' | 'true';
+    };
+    url: '/v1/users/{userId}/oauth';
+};
+export type GetV1UsersUserIdOauthErrors = {
+    /**
+     * User not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type GetV1UsersUserIdOauthError = GetV1UsersUserIdOauthErrors[keyof GetV1UsersUserIdOauthErrors];
+export type GetV1UsersUserIdOauthResponses = {
+    /**
+     * All oauth connections of the user
+     */
+    200: {
+        data: Array<AuthConnection>;
+    };
+};
+export type GetV1UsersUserIdOauthResponse = GetV1UsersUserIdOauthResponses[keyof GetV1UsersUserIdOauthResponses];
+export type GetV1UsersUserIdOauthLinksData = {
+    body?: never;
+    path: {
+        userId: string;
+    };
+    query: {
+        /**
+         * Access type of the oauth connection
+         */
+        accessType: 'offline' | 'online';
+        /**
+         * Scope of the oauth connection
+         */
+        scope: Array<string> | 'edit' | 'free-busy';
+        provider?: Array<'google' | 'microsoft'>;
+    };
+    url: '/v1/users/{userId}/oauth/links';
+};
+export type GetV1UsersUserIdOauthLinksErrors = {
+    /**
+     * Invalid request
+     */
+    400: {
+        data: null;
+        error: string;
+    };
+    /**
+     * User not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type GetV1UsersUserIdOauthLinksError = GetV1UsersUserIdOauthLinksErrors[keyof GetV1UsersUserIdOauthLinksErrors];
+export type GetV1UsersUserIdOauthLinksResponses = {
+    /**
+     * Auth urls for the oauth providers
+     */
+    200: {
+        data: Array<{
+            /**
+             * Auth url for the user to connect to the oauth provider
+             */
+            link: string;
+            provider: 'google' | 'microsoft';
+        }>;
+    };
+};
+export type GetV1UsersUserIdOauthLinksResponse = GetV1UsersUserIdOauthLinksResponses[keyof GetV1UsersUserIdOauthLinksResponses];
+export type GetV1UsersUserIdOauthProviderLinkData = {
+    body?: never;
+    path: {
+        provider: 'google' | 'microsoft';
+        userId: string;
+    };
+    query: {
+        /**
+         * Access type of the oauth connection
+         */
+        accessType: 'offline' | 'online';
+        /**
+         * Scope of the oauth connection
+         */
+        scope: Array<string> | 'edit' | 'free-busy';
+        /**
+         * Redirect url for the oauth provider
+         */
+        redirectUrl?: string;
+    };
+    url: '/v1/users/{userId}/oauth/{provider}/link';
+};
+export type GetV1UsersUserIdOauthProviderLinkErrors = {
+    /**
+     * Invalid request
+     */
+    400: {
+        data: null;
+        error: string;
+    };
+    /**
+     * User not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type GetV1UsersUserIdOauthProviderLinkError = GetV1UsersUserIdOauthProviderLinkErrors[keyof GetV1UsersUserIdOauthProviderLinkErrors];
+export type GetV1UsersUserIdOauthProviderLinkResponses = {
+    /**
+     * Auth url for the oauth provider
+     */
+    200: {
+        data: {
+            /**
+             * Auth url for the user to connect to the oauth provider
+             */
+            link: string;
+        };
+    };
+};
+export type GetV1UsersUserIdOauthProviderLinkResponse = GetV1UsersUserIdOauthProviderLinkResponses[keyof GetV1UsersUserIdOauthProviderLinkResponses];
+export type PostV1UsersOauthProviderVerifyData = {
+    body?: {
+        code: string;
+        scope: Array<string>;
+        state: string;
+    };
+    path: {
+        provider: 'google' | 'microsoft';
+    };
+    query?: {
+        /**
+         * Redirect url for the oauth provider
+         */
+        redirectUrl?: string;
+    };
+    url: '/v1/users/oauth/{provider}/verify';
+};
+export type PostV1UsersOauthProviderVerifyErrors = {
+    /**
+     * Invalid request
+     */
+    400: {
+        data: null;
+        error: string;
+    };
+    /**
+     * User not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type PostV1UsersOauthProviderVerifyError = PostV1UsersOauthProviderVerifyErrors[keyof PostV1UsersOauthProviderVerifyErrors];
+export type PostV1UsersOauthProviderVerifyResponses = {
+    /**
+     * OAuth code verified successfully
+     */
+    200: unknown;
+};
+export type DeleteV1UsersUserIdOauthProviderData = {
+    body?: never;
+    path: {
+        provider: 'google' | 'microsoft';
+        userId: string;
+    };
+    query?: never;
+    url: '/v1/users/{userId}/oauth/{provider}';
+};
+export type DeleteV1UsersUserIdOauthProviderErrors = {
+    /**
+     * User not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type DeleteV1UsersUserIdOauthProviderError = DeleteV1UsersUserIdOauthProviderErrors[keyof DeleteV1UsersUserIdOauthProviderErrors];
+export type DeleteV1UsersUserIdOauthProviderResponses = {
+    /**
+     * OAuth connection deleted
+     */
+    200: unknown;
+};
+export type GetV1UsersUserIdOauthProviderData = {
+    body?: never;
+    path: {
+        provider: 'google' | 'microsoft';
+        userId: string;
+    };
+    query?: {
+        /**
+         * Show access and refresh tokens
+         */
+        showToken?: 'false' | 'true';
+    };
+    url: '/v1/users/{userId}/oauth/{provider}';
+};
+export type GetV1UsersUserIdOauthProviderErrors = {
+    /**
+     * User not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type GetV1UsersUserIdOauthProviderError = GetV1UsersUserIdOauthProviderErrors[keyof GetV1UsersUserIdOauthProviderErrors];
+export type GetV1UsersUserIdOauthProviderResponses = {
+    /**
+     * OAuth connection of the user
+     */
+    200: {
+        data: AuthConnection;
+    };
+};
+export type GetV1UsersUserIdOauthProviderResponse = GetV1UsersUserIdOauthProviderResponses[keyof GetV1UsersUserIdOauthProviderResponses];
+export type PostV1UsersUserIdOauthProviderData = {
+    body?: {
+        accessToken: string;
+        email: string | null;
+        expiresAt: string | null;
+        refreshToken: string | unknown;
+        scope: Array<string>;
+    };
+    path: {
+        provider: 'google' | 'microsoft';
+        userId: string;
+    };
+    query?: never;
+    url: '/v1/users/{userId}/oauth/{provider}';
+};
+export type PostV1UsersUserIdOauthProviderErrors = {
+    /**
+     * Invalid request
+     */
+    400: {
+        data: null;
+        error: string;
+    };
+    /**
+     * User not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type PostV1UsersUserIdOauthProviderError = PostV1UsersUserIdOauthProviderErrors[keyof PostV1UsersUserIdOauthProviderErrors];
+export type PostV1UsersUserIdOauthProviderResponses = {
+    /**
+     * OAuth connection created
+     */
+    201: {
+        data: AuthConnection;
+    };
+};
+export type PostV1UsersUserIdOauthProviderResponse = PostV1UsersUserIdOauthProviderResponses[keyof PostV1UsersUserIdOauthProviderResponses];
+export type GetV1UsersUserIdOauthProviderTokenData = {
+    body?: never;
+    path: {
+        provider: 'google' | 'microsoft';
+        userId: string;
+    };
+    query?: never;
+    url: '/v1/users/{userId}/oauth/{provider}/token';
+};
+export type GetV1UsersUserIdOauthProviderTokenErrors = {
+    /**
+     * Invalid request
+     */
+    400: {
+        data: null;
+        error: string;
+    };
+    /**
+     * User not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type GetV1UsersUserIdOauthProviderTokenError = GetV1UsersUserIdOauthProviderTokenErrors[keyof GetV1UsersUserIdOauthProviderTokenErrors];
+export type GetV1UsersUserIdOauthProviderTokenResponses = {
+    /**
+     * Access token
+     */
+    200: {
+        data: {
+            accessToken: string;
+        };
+    };
+};
+export type GetV1UsersUserIdOauthProviderTokenResponse = GetV1UsersUserIdOauthProviderTokenResponses[keyof GetV1UsersUserIdOauthProviderTokenResponses];
+export type GetV1UsersUserIdSchedulingData = {
+    body?: never;
+    path: {
+        userId: string;
+    };
+    query: {
+        /**
+         * End time of the time range in ISO format
+         */
+        end: string;
+        /**
+         * Padding in minutes to add before and after busy times
+         */
+        padding: string | unknown;
+        /**
+         * Duration of each slot in minutes
+         */
+        slotDuration: string | unknown;
+        /**
+         * Start time of the time range in ISO format
+         */
+        start: string;
+        /**
+         * Requested earliest time of each day (in the time zone of the request)
+         */
+        earliestTimeEachDay?: string;
+        /**
+         * Requested latest time of each day (in the time zone of the request)
+         */
+        latestTimeEachDay?: string;
+        /**
+         * An integer >= 0 (default: 0)
+         */
+        maxOverlaps?: string | unknown;
+        provider?: Array<'google' | 'microsoft'> | 'google' | 'microsoft';
+    };
+    url: '/v1/users/{userId}/scheduling';
+};
+export type GetV1UsersUserIdSchedulingErrors = {
+    /**
+     * Bad request
+     */
+    400: {
+        data: null;
+        error: string;
+    };
+    /**
+     * User not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type GetV1UsersUserIdSchedulingError = GetV1UsersUserIdSchedulingErrors[keyof GetV1UsersUserIdSchedulingErrors];
+export type GetV1UsersUserIdSchedulingResponses = {
+    /**
+     * Available time slots
+     */
+    200: {
+        data: {
+            availableSlots: Array<TimeRange>;
+            options: {
+                /**
+                 * End time of the time range in ISO format
+                 */
+                end: Date;
+                maxOverlaps: number;
+                /**
+                 * Padding in minutes to add before and after busy times
+                 */
+                padding: number;
+                /**
+                 * Duration of each slot in minutes
+                 */
+                slotDuration: number;
+                /**
+                 * Start time of the time range in ISO format
+                 */
+                start: Date;
+                /**
+                 * Requested earliest time of each day (in the time zone of the request)
+                 */
+                earliestTimeEachDay?: string;
+                /**
+                 * Requested latest time of each day (in the time zone of the request)
+                 */
+                latestTimeEachDay?: string;
+            };
+        };
+    };
+};
+export type GetV1UsersUserIdSchedulingResponse = GetV1UsersUserIdSchedulingResponses[keyof GetV1UsersUserIdSchedulingResponses];
+export type PostV1UsersUserIdSchedulingData = {
+    body?: {
+        schedules: Array<{
+            /**
+             * The days to apply this scheduling element to
+             */
+            days: Array<'friday' | 'monday' | 'saturday' | 'sunday' | 'thursday' | 'tuesday' | 'wednesday'>;
+            /**
+             * End time
+             */
+            end: string;
+            /**
+             * Start time
+             */
+            start: string;
+        }>;
+    };
+    path: {
+        userId: string;
+    };
+    query: {
+        /**
+         * End time of the time range in ISO format
+         */
+        end: string;
+        /**
+         * Padding in minutes to add before and after busy times
+         */
+        padding: string | unknown;
+        /**
+         * Duration of each slot in minutes
+         */
+        slotDuration: string | unknown;
+        /**
+         * Start time of the time range in ISO format
+         */
+        start: string;
+        /**
+         * An integer >= 0 (default: 0)
+         */
+        maxOverlaps?: string | unknown;
+        provider?: Array<'google' | 'microsoft'> | 'google' | 'microsoft';
+    };
+    url: '/v1/users/{userId}/scheduling';
+};
+export type PostV1UsersUserIdSchedulingErrors = {
+    /**
+     * User has no connected calendars
+     */
+    400: {
+        data: null;
+        error: string;
+    };
+    /**
+     * User not found
+     */
+    404: {
+        data: null;
+        error: string;
+    };
+};
+export type PostV1UsersUserIdSchedulingError = PostV1UsersUserIdSchedulingErrors[keyof PostV1UsersUserIdSchedulingErrors];
+export type PostV1UsersUserIdSchedulingResponses = {
+    /**
+     * Available time slots
+     */
+    200: {
+        data: {
+            availableSlots: Array<TimeRange>;
+            options: {
+                /**
+                 * End time of the time range in ISO format
+                 */
+                end: Date;
+                maxOverlaps: number;
+                /**
+                 * Padding in minutes to add before and after busy times
+                 */
+                padding: number;
+                /**
+                 * Duration of each slot in minutes
+                 */
+                slotDuration: number;
+                /**
+                 * Start time of the time range in ISO format
+                 */
+                start: Date;
+                /**
+                 * Requested earliest time of each day (in the time zone of the request)
+                 */
+                earliestTimeEachDay?: string;
+                /**
+                 * Requested latest time of each day (in the time zone of the request)
+                 */
+                latestTimeEachDay?: string;
+            };
+        };
+    };
+};
+export type PostV1UsersUserIdSchedulingResponse = PostV1UsersUserIdSchedulingResponses[keyof PostV1UsersUserIdSchedulingResponses];
+export type PostV1UsersSchedulingData = {
+    body?: {
+        users: Array<{
+            id: string;
+            calendarIds?: Array<string>;
+            schedules?: Array<{
+                /**
+                 * The days to apply this scheduling element to
+                 */
+                days: Array<'friday' | 'monday' | 'saturday' | 'sunday' | 'thursday' | 'tuesday' | 'wednesday'>;
+                /**
+                 * End time
+                 */
+                end: string;
+                /**
+                 * Start time
+                 */
+                start: string;
+            }>;
+        }>;
+    };
+    path?: never;
+    query: {
+        /**
+         * End time of the time range in ISO format
+         */
+        end: string;
+        /**
+         * Padding in minutes to add before and after busy times
+         */
+        padding: string | unknown;
+        /**
+         * Duration of each slot in minutes
+         */
+        slotDuration: string | unknown;
+        /**
+         * Start time of the time range in ISO format
+         */
+        start: string;
+        /**
+         * An integer >= 0 (default: 0)
+         */
+        maxOverlaps?: string | unknown;
+        provider?: Array<'google' | 'microsoft'> | 'google' | 'microsoft';
+    };
+    url: '/v1/users/scheduling';
+};
+export type PostV1UsersSchedulingResponses = {
+    /**
+     * Available time slots for each user
+     */
+    200: {
+        data: Array<{
+            availableSlots: Array<TimeRange>;
+            options: {
+                /**
+                 * End time of the time range in ISO format
+                 */
+                end: Date;
+                maxOverlaps: number;
+                /**
+                 * Padding in minutes to add before and after busy times
+                 */
+                padding: number;
+                /**
+                 * Duration of each slot in minutes
+                 */
+                slotDuration: number;
+                /**
+                 * Start time of the time range in ISO format
+                 */
+                start: Date;
+                /**
+                 * Requested earliest time of each day (in the time zone of the request)
+                 */
+                earliestTimeEachDay?: string;
+                /**
+                 * Requested latest time of each day (in the time zone of the request)
+                 */
+                latestTimeEachDay?: string;
+            };
+            userId: string;
+            calendarIds?: Array<string>;
+            schedules?: Array<{
+                /**
+                 * The days to apply this scheduling element to
+                 */
+                days: Array<'friday' | 'monday' | 'saturday' | 'sunday' | 'thursday' | 'tuesday' | 'wednesday'>;
+                /**
+                 * End time
+                 */
+                end: string;
+                /**
+                 * Start time
+                 */
+                start: string;
+            }>;
+        } | {
+            error: string;
+            userId: string;
+        }>;
+    };
+};
+export type PostV1UsersSchedulingResponse = PostV1UsersSchedulingResponses[keyof PostV1UsersSchedulingResponses];
+//# sourceMappingURL=types.gen.d.ts.map