@ikonintegration/bccsa-program-api 2.0.0

package/dist/Api.d.ts

@@ -0,0 +1,2384 @@
+/** Default API Error response */
+export interface ErrorResponse {
+    /** Error message */
+    err: string;
+    /** Error code */
+    errCode: string;
+}
+export interface Input9Jxov33U7D {
+    /** @minLength 1 */
+    customerID: string;
+    /** @minLength 1 */
+    name: string;
+}
+export interface InputUse5Vle8Ta {
+    /** @minLength 1 */
+    customerID: string;
+    /** @minLength 1 */
+    id: string;
+    /** @minLength 1 */
+    name: string;
+}
+export interface CityCreateSchema {
+    /**
+     * Customer ID
+     * @minLength 1
+     */
+    customerID: string;
+    /**
+     * Region ID
+     * @minLength 1
+     */
+    regionID: string;
+    /**
+     * City name
+     * @minLength 1
+     */
+    name: string;
+    /**
+     * Province code
+     * @minLength 1
+     */
+    province: string;
+}
+export interface CityUpdateSchema {
+    /**
+     * Customer ID
+     * @minLength 1
+     */
+    customerID: string;
+    /**
+     * Region ID
+     * @minLength 1
+     */
+    regionID: string;
+    /**
+     * City ID
+     * @minLength 1
+     */
+    id: string;
+    /**
+     * City name
+     * @minLength 1
+     */
+    name: string;
+    /**
+     * Province code
+     * @minLength 1
+     */
+    province: string;
+}
+export interface VenueCreateSchema {
+    /**
+     * Customer ID
+     * @minLength 1
+     */
+    customerID: string;
+    /**
+     * City ID
+     * @minLength 1
+     */
+    cityID: string;
+    /**
+     * Venue name
+     * @minLength 1
+     */
+    name: string;
+    /** Venue address */
+    address: {
+        /**
+         * Street address line 1
+         * @minLength 1
+         */
+        street1: string;
+        /** Street address line 2 */
+        street2?: string | null;
+        /**
+         * Postal code
+         * @minLength 1
+         */
+        postalCode: string;
+        /**
+         * Province code
+         * @minLength 1
+         */
+        province: string;
+    };
+    /** Additional comments */
+    comments?: string | null;
+}
+export interface VenueUpdateSchema {
+    /**
+     * Customer ID
+     * @minLength 1
+     */
+    customerID: string;
+    /**
+     * City ID
+     * @minLength 1
+     */
+    cityID: string;
+    /**
+     * Venue ID
+     * @minLength 1
+     */
+    id: string;
+    /**
+     * Venue name
+     * @minLength 1
+     */
+    name: string;
+    /** Venue address */
+    address: {
+        /**
+         * Street address line 1
+         * @minLength 1
+         */
+        street1: string;
+        /** Street address line 2 */
+        street2?: string | null;
+        /**
+         * Postal code
+         * @minLength 1
+         */
+        postalCode: string;
+        /**
+         * Province code
+         * @minLength 1
+         */
+        province: string;
+    };
+    /** Additional comments */
+    comments?: string | null;
+}
+export interface InstructorCreateSchema {
+    /**
+     * User ID of the instructor
+     * @minLength 1
+     */
+    userID: string;
+}
+export interface InstructorUpdateSchema {
+    /** Whether the instructor is disabled */
+    disabled: boolean;
+}
+export interface InstructorCourseUpdateSchema {
+    /** List of course IDs */
+    courseIDs: string[];
+}
+export interface InstructorRegionUpdateSchema {
+    /** List of region IDs */
+    regionIDs: string[];
+}
+export interface Input33N9Vgyjyy {
+    startTime: string | number;
+    endTime: string | number;
+    expandSessions?: boolean;
+}
+export interface Input56Hzg6Xiz2 {
+    startTime: string | number;
+    endTime: string | number;
+    description?: string;
+}
+export interface Input3Yilrlis7M {
+    startTime: string | number;
+    endTime: string | number;
+    description?: string;
+}
+export interface InputKi6Tbrci1R {
+    /** @minLength 1 */
+    calendarColor: string;
+}
+export interface SessionCourseTemplateCreateSchema {
+    /**
+     * Tenant ID
+     * @minLength 1
+     */
+    tenantID: string;
+    /**
+     * Course ID
+     * @minLength 1
+     */
+    courseID: string;
+    /**
+     * Template name
+     * @minLength 1
+     */
+    name: string;
+    /**
+     * Internal template name
+     * @minLength 1
+     */
+    internalName: string;
+    autoEnrolOnSession?: string | null;
+    releaseType: SessionCourseTemplateCreateSchemaReleaseTypeEnum;
+    productsForPurchase?: string[];
+    productPurchaseMessage?: string | null;
+    disabledEmails?: (string | null)[];
+    disableLicenseEmails?: boolean;
+    calendarColor?: string | null;
+    capacity: number;
+    reservedCapacity?: number | null;
+    minCapacity?: number;
+    notificationDetails: {
+        adminEmails: string[];
+        shouldNotifyEnrolmentToAdmins?: boolean;
+        notifyWhenSessionFull?: boolean;
+    };
+    hasMaterial: SessionCourseTemplateCreateSchemaHasMaterialEnum;
+    requiresInstructor?: boolean;
+    requiresAdminReview?: boolean;
+    overview?: string | null;
+    specialInstructions?: string | null;
+    chargeDeferred?: boolean;
+    checkGradeDelay?: number;
+    courseMaterialProductID?: string | null;
+    isEligibleForNoCost?: boolean;
+    cancelationPolicyID?: string | null;
+    reschedulePolicyID?: string | null;
+    confirmInfoOnEnrolment?: boolean;
+    bypassAgreement?: boolean;
+    chargeForMaterials?: boolean;
+    isReferralPercentage?: boolean;
+    referralAmount?: number;
+    possibleReferrals?: (string | null)[];
+    askForReferrals?: boolean;
+    isPrivate: boolean;
+    internalNotes?: string | null;
+    instructorNotes?: string | null;
+    content?: {
+        sections: {
+            order: number;
+            /** @minLength 1 */
+            name: string;
+            enabled: boolean;
+            warning?: {
+                type?: string | null;
+                /** @minLength 1 */
+                content?: string;
+            };
+            /** @minLength 1 */
+            content: string;
+            files?: string[] | null;
+        }[];
+    };
+    type: SessionCourseTemplateCreateSchemaTypeEnum;
+    duration?: number;
+    venueID?: string | null;
+    venueComplement?: string | null;
+    considerFailures?: boolean;
+    onlineAccessPeriod?: number;
+    providerCourseTemplateID?: string | null | number;
+    calculateScoreAsPercentage?: boolean;
+    courseProviderID?: string | null;
+    accessLink?: string | null;
+}
+export interface SessionCourseTemplateUpdateSchema {
+    /**
+     * Template name
+     * @minLength 1
+     */
+    name: string;
+    /**
+     * Internal template name
+     * @minLength 1
+     */
+    internalName: string;
+    autoEnrolOnSession?: string | null;
+    releaseType: SessionCourseTemplateUpdateSchemaReleaseTypeEnum;
+    productsForPurchase?: string[];
+    productPurchaseMessage?: string | null;
+    disabledEmails?: (string | null)[];
+    disableLicenseEmails?: boolean;
+    calendarColor?: string | null;
+    capacity: number;
+    reservedCapacity?: number | null;
+    minCapacity?: number;
+    notificationDetails: {
+        adminEmails: string[];
+        shouldNotifyEnrolmentToAdmins?: boolean;
+        notifyWhenSessionFull?: boolean;
+    };
+    hasMaterial: SessionCourseTemplateUpdateSchemaHasMaterialEnum;
+    requiresInstructor?: boolean;
+    requiresAdminReview?: boolean;
+    overview?: string | null;
+    specialInstructions?: string | null;
+    chargeDeferred?: boolean;
+    checkGradeDelay?: number;
+    courseMaterialProductID?: string | null;
+    isEligibleForNoCost?: boolean;
+    cancelationPolicyID?: string | null;
+    reschedulePolicyID?: string | null;
+    confirmInfoOnEnrolment?: boolean;
+    bypassAgreement?: boolean;
+    chargeForMaterials?: boolean;
+    isReferralPercentage?: boolean;
+    referralAmount?: number;
+    possibleReferrals?: (string | null)[];
+    askForReferrals?: boolean;
+    isPrivate: boolean;
+    internalNotes?: string | null;
+    instructorNotes?: string | null;
+    content?: {
+        sections: {
+            order: number;
+            /** @minLength 1 */
+            name: string;
+            enabled: boolean;
+            warning?: {
+                type?: string | null;
+                /** @minLength 1 */
+                content?: string;
+            };
+            /** @minLength 1 */
+            content: string;
+            files?: string[] | null;
+        }[];
+    };
+    type: SessionCourseTemplateUpdateSchemaTypeEnum;
+    duration?: number;
+    venueID?: string | null;
+    venueComplement?: string | null;
+    considerFailures?: boolean;
+    onlineAccessPeriod?: number;
+    providerCourseTemplateID?: string | null | number;
+    calculateScoreAsPercentage?: boolean;
+    courseProviderID?: string | null;
+    accessLink?: string | null;
+}
+export interface SearchSessionsByIDsSchema {
+    /** Array of session IDs to search */
+    IDs: string[];
+}
+export interface SessionCreateSchema {
+    /**
+     * Tenant ID
+     * @minLength 1
+     */
+    tenantID: string;
+    /**
+     * Course ID
+     * @minLength 1
+     */
+    courseID: string;
+    /**
+     * Template ID
+     * @minLength 1
+     */
+    templateID: string;
+    /**
+     * Session name
+     * @minLength 1
+     */
+    name: string;
+    /**
+     * Internal session name
+     * @minLength 1
+     */
+    internalName: string;
+    autoEnrolOnSession?: string | null;
+    releaseType: SessionCreateSchemaReleaseTypeEnum;
+    capacity: number;
+    reservedCapacity?: number | null;
+    disabledEmails?: (string | null)[];
+    disableLicenseEmails?: boolean;
+    minCapacity?: number;
+    notificationDetails: {
+        adminEmails: string[];
+        shouldNotifyEnrolmentToAdmins?: boolean;
+        notifyWhenSessionFull?: boolean;
+    };
+    hasMaterial: SessionCreateSchemaHasMaterialEnum;
+    requiresInstructor?: boolean;
+    requiresAdminReview?: boolean;
+    overview?: string | null;
+    specialInstructions?: string | null;
+    chargeDeferred?: boolean;
+    checkGradeDelay?: number[];
+    courseMaterialProductID?: string | null;
+    isEligibleForNoCost?: boolean;
+    cancelationPolicyID?: string | null;
+    reschedulePolicyID?: string | null;
+    confirmInfoOnEnrolment?: boolean;
+    bypassAgreement?: boolean;
+    chargeForMaterials?: boolean;
+    isReferralPercentage?: boolean;
+    referralAmount?: number;
+    possibleReferrals?: (string | null)[];
+    productsForPurchase?: string[];
+    productPurchaseMessage?: string | null;
+    enableProductPurchase?: boolean;
+    askForReferrals?: boolean;
+    isPrivate: boolean;
+    internalNotes?: string | null;
+    instructorNotes?: string | null;
+    content?: {
+        sections: {
+            order: number;
+            /** @minLength 1 */
+            name: string;
+            enabled: boolean;
+            warning?: {
+                type?: string | null;
+                /** @minLength 1 */
+                content?: string;
+            };
+            /** @minLength 1 */
+            content: string;
+            files?: string[] | null;
+        }[];
+    };
+    type: SessionCreateSchemaTypeEnum;
+    duration?: number;
+    venueID?: string | null;
+    venueComplement?: string | null;
+    considerFailures?: boolean;
+    onlineAccessPeriod?: number;
+    providerCourseTemplateID?: string | null | number;
+    calculateScoreAsPercentage?: boolean;
+    courseProviderID?: string | null;
+    accessLink?: string | null;
+    launchSchedule?: {
+        dayOfWeek: number;
+        /** @minLength 1 */
+        startTime: string;
+        /** @minLength 1 */
+        endTime: string;
+    }[] | null;
+    allowEnrolmentUntil?: number | null;
+    calendarColor?: string | null;
+    isMaterialSent?: boolean;
+    materialShippingInfo?: any;
+    isCourseMaterialShipped?: boolean;
+    lockReason?: string | null;
+    dbEntity?: string | null;
+    startDate: (string | number)[];
+    endDate: (string | number)[];
+    onlineCourseLabel?: string[] | null;
+    onlineCourseID?: string[] | null;
+    onlineGradeID?: any[];
+    onlineQuizID?: any[];
+    onlineScoreGradeID?: string[] | null;
+    enrolmentCount?: number;
+    enrolmentReservedCount?: number;
+    charges?: any;
+}
+export interface SessionUpdateSchema {
+    /**
+     * Session name
+     * @minLength 1
+     */
+    name: string;
+    /**
+     * Internal session name
+     * @minLength 1
+     */
+    internalName: string;
+    autoEnrolOnSession?: string | null;
+    releaseType: SessionUpdateSchemaReleaseTypeEnum;
+    capacity: number;
+    reservedCapacity?: number | null;
+    disabledEmails?: (string | null)[];
+    disableLicenseEmails?: boolean;
+    minCapacity?: number;
+    notificationDetails: {
+        adminEmails: string[];
+        shouldNotifyEnrolmentToAdmins?: boolean;
+        notifyWhenSessionFull?: boolean;
+    };
+    stateBeforeLock?: string | null;
+    hasMaterial: SessionUpdateSchemaHasMaterialEnum;
+    requiresInstructor?: boolean;
+    requiresAdminReview?: boolean;
+    overview?: string | null;
+    specialInstructions?: string | null;
+    chargeDeferred?: boolean;
+    courseMaterialProductID?: string | null;
+    isEligibleForNoCost?: boolean;
+    cancelationPolicyID?: string | null;
+    reschedulePolicyID?: string | null;
+    confirmInfoOnEnrolment?: boolean;
+    bypassAgreement?: boolean;
+    chargeForMaterials?: boolean;
+    checkGradeDelay?: number[];
+    isReferralPercentage?: boolean;
+    referralAmount?: number;
+    possibleReferrals?: (string | null)[];
+    productsForPurchase?: string[];
+    productPurchaseMessage?: string | null;
+    enableProductPurchase?: boolean;
+    askForReferrals?: boolean;
+    isPrivate: boolean;
+    internalNotes?: string | null;
+    instructorNotes?: string | null;
+    content?: {
+        sections: {
+            order: number;
+            /** @minLength 1 */
+            name: string;
+            enabled: boolean;
+            warning?: {
+                type?: string | null;
+                /** @minLength 1 */
+                content?: string;
+            };
+            /** @minLength 1 */
+            content: string;
+            files?: string[] | null;
+        }[];
+    };
+    type: SessionUpdateSchemaTypeEnum;
+    duration?: number;
+    venueID?: string | null;
+    venueComplement?: string | null;
+    considerFailures?: boolean;
+    onlineAccessPeriod?: number;
+    providerCourseTemplateID?: string | null | number;
+    calculateScoreAsPercentage?: boolean;
+    courseProviderID?: string | null;
+    accessLink?: string | null;
+    launchSchedule?: {
+        dayOfWeek: number;
+        /** @minLength 1 */
+        startTime: string;
+        /** @minLength 1 */
+        endTime: string;
+    }[] | null;
+    allowEnrolmentUntil?: number | null;
+    calendarColor?: string | null;
+    isMaterialSent?: boolean;
+    materialShippingInfo?: any;
+    isCourseMaterialShipped?: boolean;
+    lockReason?: string | null;
+    documents?: {
+        fileName: string;
+        fileID: string;
+    }[];
+    dbEntity?: string | null;
+    startDate: (string | number)[];
+    endDate: (string | number)[];
+    onlineCourseLabel?: string[] | null;
+    onlineCourseID?: string[] | null;
+    onlineGradeID?: any[];
+    onlineQuizID?: any[];
+    onlineScoreGradeID?: string[] | null;
+    enrolmentCount?: number;
+    enrolmentReservedCount?: number;
+    charges?: any;
+}
+export interface SessionPublishSchema {
+    /** Whether to publish the session */
+    published: boolean;
+}
+export interface SessionShipStatusSchema {
+    /** Whether material has been shipped */
+    materialShipped: boolean;
+}
+export interface SessionDuplicateSchema {
+    /** Array of timestamps for new sessions */
+    newSessionDates: number[];
+}
+export interface InputQ59Gbvuj7G {
+    attendanceStatus: InputQ59Gbvuj7GAttendanceStatusEnum;
+    additionalNotes?: string | null;
+}
+export interface Input5S9Qlxsfdw {
+    attendanceStatus: Input5S9QlxsfdwAttendanceStatusEnum;
+    additionalNotes?: string | null;
+}
+export interface InputKdcf6Vev2F {
+    /** @minLength 1 */
+    ticketID: string;
+    /** @minLength 1 */
+    externalID: string;
+    invitationCode?: string | null;
+    isReservedSeat?: boolean;
+    [key: string]: any;
+}
+export interface InputPcoc6Mas3J {
+    materialShippingInfo?: Record<string, any>;
+    [key: string]: any;
+}
+export interface Input56A08Qop2C {
+    amount: number;
+    chargeResult: Input56A08Qop2CChargeResultEnum;
+    description?: string | null;
+    /** @minLength 1 */
+    paymentProvider: string;
+    providerTransactionID?: string | null;
+    timestamp: number;
+}
+export interface InputHuw5M2U5Gx {
+    resultStatus: InputHuw5M2U5GxResultStatusEnum;
+    resultNotes?: string | null;
+    resultGrade?: number;
+    retainAcessToCourse?: boolean;
+    resultOverrideDate?: number;
+    isManuallyPublished?: boolean;
+    orgID?: string | null;
+    employerName?: string | null;
+}
+export interface InputXxwuna2Nn {
+    resultStatus: InputXxwuna2NnResultStatusEnum;
+    resultNotes?: string | null;
+    resultGrade?: number;
+    retainAcessToCourse?: boolean;
+    resultOverrideDate?: number;
+    isManuallyPublished?: boolean;
+    orgID?: string | null;
+    employerName?: string | null;
+}
+export interface SessionInstructorSchema {
+    /** Instructor type */
+    instructorType: SessionInstructorSchemaInstructorTypeEnum;
+}
+export interface SessionsInstructorSetSchema {
+    /** Array of session IDs */
+    sessions: string[];
+    /** Instructor type */
+    instructorType: SessionsInstructorSetSchemaInstructorTypeEnum;
+}
+export interface InputW0Gt14Iief {
+    activationCode?: string | null;
+    /** @minLength 1 */
+    email: string;
+    userID?: string | null;
+    isReservedSeat?: boolean;
+    maxUsage: number;
+}
+export interface InputF61Tonm0Be {
+    useCount?: any;
+    maxUsage: number;
+}
+export interface SessionDocumentSchema {
+    /**
+     * File ID
+     * @minLength 1
+     */
+    fileID: string;
+    /**
+     * File name
+     * @minLength 1
+     */
+    fileName: string;
+}
+export interface SessionBatchUpdateSchema {
+    students: {
+        /**
+         * User ID
+         * @minLength 1
+         */
+        userID: string;
+        /**
+         * External ID
+         * @minLength 1
+         */
+        externalID: string;
+        /** Attendance data */
+        attendance?: {
+            attendanceStatus: SessionBatchUpdateSchemaAttendanceStatusEnum;
+            additionalNotes?: string | null;
+        };
+        /** Result data */
+        result?: {
+            resultStatus: SessionBatchUpdateSchemaResultStatusEnum;
+            resultNotes?: string | null;
+            resultGrade?: number;
+        };
+    }[];
+}
+export interface EnrolmentsPerPeriodReportSchema {
+    filters: {
+        /** Start timestamp */
+        from: number;
+        /** End timestamp */
+        to: number;
+        /** Optional course filter */
+        courseID?: string | null;
+    };
+}
+export interface SessionResultReportSchema {
+    filters: {
+        /**
+         * Course ID
+         * @minLength 1
+         */
+        courseID: string;
+        /**
+         * Start date
+         * @minLength 1
+         */
+        from: string;
+        /**
+         * End date
+         * @minLength 1
+         */
+        to: string;
+        /** Optional instructor filter */
+        instructorID?: string | null;
+    };
+}
+export interface SessionResultsReportSchema {
+    filters: {
+        /**
+         * Start date
+         * @minLength 1
+         */
+        dateFrom: string;
+        /**
+         * End date
+         * @minLength 1
+         */
+        dateTo: string;
+        /** Optional course IDs filter */
+        courseIDs?: any;
+        /** Optional pagination from */
+        from?: any;
+    };
+}
+export interface SessionListReportSchema {
+    filters: {
+        /**
+         * Start date
+         * @minLength 1
+         */
+        from: string;
+        /**
+         * End date
+         * @minLength 1
+         */
+        to: string;
+        /** Optional course filter */
+        courseID?: string | null;
+        /** Optional instructor filter */
+        instructorID?: string | null;
+        /** Optional state filter */
+        state?: string | null;
+    };
+}
+export declare enum SessionCourseTemplateCreateSchemaReleaseTypeEnum {
+    NONE = "NONE",
+    AUTO = "AUTO",
+    MANUAL = "MANUAL",
+    SCHEDULE = "SCHEDULE"
+}
+export declare enum SessionCourseTemplateCreateSchemaHasMaterialEnum {
+    NONE = "NONE",
+    INDIVIDUAL = "INDIVIDUAL",
+    ALL = "ALL"
+}
+export declare enum SessionCourseTemplateCreateSchemaTypeEnum {
+    SCHEDULED_PRESENTIAL = "SCHEDULED_PRESENTIAL",
+    SCHEDULED_ONLINE_EXT = "SCHEDULED_ONLINE_EXT",
+    SCHEDULED_VILT = "SCHEDULED_VILT",
+    SCHEDULED_WEBINAR = "SCHEDULED_WEBINAR",
+    ONLINE_EXT = "ONLINE_EXT",
+    ONLINE = "ONLINE"
+}
+export declare enum SessionCourseTemplateUpdateSchemaReleaseTypeEnum {
+    NONE = "NONE",
+    AUTO = "AUTO",
+    MANUAL = "MANUAL",
+    SCHEDULE = "SCHEDULE"
+}
+export declare enum SessionCourseTemplateUpdateSchemaHasMaterialEnum {
+    NONE = "NONE",
+    INDIVIDUAL = "INDIVIDUAL",
+    ALL = "ALL"
+}
+export declare enum SessionCourseTemplateUpdateSchemaTypeEnum {
+    SCHEDULED_PRESENTIAL = "SCHEDULED_PRESENTIAL",
+    SCHEDULED_ONLINE_EXT = "SCHEDULED_ONLINE_EXT",
+    SCHEDULED_VILT = "SCHEDULED_VILT",
+    SCHEDULED_WEBINAR = "SCHEDULED_WEBINAR",
+    ONLINE_EXT = "ONLINE_EXT",
+    ONLINE = "ONLINE"
+}
+export declare enum SessionCreateSchemaReleaseTypeEnum {
+    NONE = "NONE",
+    AUTO = "AUTO",
+    MANUAL = "MANUAL",
+    SCHEDULE = "SCHEDULE"
+}
+export declare enum SessionCreateSchemaHasMaterialEnum {
+    NONE = "NONE",
+    INDIVIDUAL = "INDIVIDUAL",
+    ALL = "ALL"
+}
+export declare enum SessionCreateSchemaTypeEnum {
+    SCHEDULED_PRESENTIAL = "SCHEDULED_PRESENTIAL",
+    SCHEDULED_ONLINE_EXT = "SCHEDULED_ONLINE_EXT",
+    SCHEDULED_VILT = "SCHEDULED_VILT",
+    SCHEDULED_WEBINAR = "SCHEDULED_WEBINAR",
+    ONLINE_EXT = "ONLINE_EXT",
+    ONLINE = "ONLINE"
+}
+export declare enum SessionUpdateSchemaReleaseTypeEnum {
+    NONE = "NONE",
+    AUTO = "AUTO",
+    MANUAL = "MANUAL",
+    SCHEDULE = "SCHEDULE"
+}
+export declare enum SessionUpdateSchemaHasMaterialEnum {
+    NONE = "NONE",
+    INDIVIDUAL = "INDIVIDUAL",
+    ALL = "ALL"
+}
+export declare enum SessionUpdateSchemaTypeEnum {
+    SCHEDULED_PRESENTIAL = "SCHEDULED_PRESENTIAL",
+    SCHEDULED_ONLINE_EXT = "SCHEDULED_ONLINE_EXT",
+    SCHEDULED_VILT = "SCHEDULED_VILT",
+    SCHEDULED_WEBINAR = "SCHEDULED_WEBINAR",
+    ONLINE_EXT = "ONLINE_EXT",
+    ONLINE = "ONLINE"
+}
+export declare enum InputQ59Gbvuj7GAttendanceStatusEnum {
+    INCOMPLETE = "INCOMPLETE",
+    NO_SHOW = "NO_SHOW",
+    ATTENDED = "ATTENDED"
+}
+export declare enum Input5S9QlxsfdwAttendanceStatusEnum {
+    INCOMPLETE = "INCOMPLETE",
+    NO_SHOW = "NO_SHOW",
+    ATTENDED = "ATTENDED"
+}
+export declare enum Input56A08Qop2CChargeResultEnum {
+    SUCCESS = "SUCCESS",
+    FAIL = "FAIL"
+}
+export declare enum InputHuw5M2U5GxResultStatusEnum {
+    INCOMPLETE = "INCOMPLETE",
+    FAIL = "FAIL",
+    PASS = "PASS"
+}
+export declare enum InputXxwuna2NnResultStatusEnum {
+    INCOMPLETE = "INCOMPLETE",
+    FAIL = "FAIL",
+    PASS = "PASS"
+}
+/** Instructor type */
+export declare enum SessionInstructorSchemaInstructorTypeEnum {
+    PRIMARY = "PRIMARY",
+    SECONDARY = "SECONDARY"
+}
+/** Instructor type */
+export declare enum SessionsInstructorSetSchemaInstructorTypeEnum {
+    PRIMARY = "PRIMARY",
+    SECONDARY = "SECONDARY"
+}
+export declare enum SessionBatchUpdateSchemaAttendanceStatusEnum {
+    INCOMPLETE = "INCOMPLETE",
+    NO_SHOW = "NO_SHOW",
+    ATTENDED = "ATTENDED"
+}
+export declare enum SessionBatchUpdateSchemaResultStatusEnum {
+    INCOMPLETE = "INCOMPLETE",
+    FAIL = "FAIL",
+    PASS = "PASS"
+}
+export type GetRegionData = any;
+export type GetRegionError = ErrorResponse;
+export type CreateRegionData = any;
+export type CreateRegionError = ErrorResponse;
+export type UpdateRegionData = any;
+export type UpdateRegionError = ErrorResponse;
+export type DeleteRegionData = any;
+export type DeleteRegionError = ErrorResponse;
+export type ListRegionsData = any;
+export type ListRegionsError = ErrorResponse;
+export type GetCityData = any;
+export type GetCityError = ErrorResponse;
+export type CreateCityData = any;
+export type CreateCityError = ErrorResponse;
+export type UpdateCityData = any;
+export type UpdateCityError = ErrorResponse;
+export type DeleteCityData = any;
+export type DeleteCityError = ErrorResponse;
+export type ListCitiesData = any;
+export type ListCitiesError = ErrorResponse;
+export type GetVenueData = any;
+export type GetVenueError = ErrorResponse;
+export type CreateVenueData = any;
+export type CreateVenueError = ErrorResponse;
+export type UpdateVenueData = any;
+export type UpdateVenueError = ErrorResponse;
+export type DeleteVenueData = any;
+export type DeleteVenueError = ErrorResponse;
+export type ListVenuesData = any;
+export type ListVenuesError = ErrorResponse;
+export type GetInstructorData = any;
+export type GetInstructorError = ErrorResponse;
+export type CreateInstructorData = any;
+export type CreateInstructorError = ErrorResponse;
+export type UpdateInstructorData = any;
+export type UpdateInstructorError = ErrorResponse;
+export type DeleteInstructorData = any;
+export type DeleteInstructorError = ErrorResponse;
+export type ListInstructorsData = any;
+export type ListInstructorsError = ErrorResponse;
+export type GetCourseData = any;
+export type GetCourseError = ErrorResponse;
+export type CreateCourseData = any;
+export type CreateCourseError = ErrorResponse;
+export type GetRegionResult = any;
+export type GetRegionFail = ErrorResponse;
+export type CreateRegionResult = any;
+export type CreateRegionFail = ErrorResponse;
+export type ListEventsData = any;
+export type ListEventsError = ErrorResponse;
+export type GetAvailabilityEventData = any;
+export type GetAvailabilityEventError = ErrorResponse;
+export type CreateAvailabilityEventData = any;
+export type CreateAvailabilityEventError = ErrorResponse;
+export type UpdateAvailabilityEventData = any;
+export type UpdateAvailabilityEventError = ErrorResponse;
+export type DeleteAvailabilityEventData = any;
+export type DeleteAvailabilityEventError = ErrorResponse;
+export type GetCalendarSyncData = any;
+export type GetCalendarSyncError = ErrorResponse;
+export type CreateCalendarSyncData = any;
+export type CreateCalendarSyncError = ErrorResponse;
+export type UpdateCalendarSyncData = any;
+export type UpdateCalendarSyncError = ErrorResponse;
+export type DeleteCalendarSyncData = any;
+export type DeleteCalendarSyncError = ErrorResponse;
+export type GetCalendarSyncsData = any;
+export type GetCalendarSyncsError = ErrorResponse;
+export type GetCalendarData = any;
+export type GetCalendarError = ErrorResponse;
+export type UpdateCalendarData = any;
+export type UpdateCalendarError = ErrorResponse;
+export type GetCalendarSyncResult = any;
+export type GetCalendarSyncFail = ErrorResponse;
+export type CreateCalendarSyncResult = any;
+export type CreateCalendarSyncFail = ErrorResponse;
+export type UpdateCalendarSyncResult = any;
+export type UpdateCalendarSyncFail = ErrorResponse;
+export type DeleteCalendarSyncResult = any;
+export type DeleteCalendarSyncFail = ErrorResponse;
+export type ListCalendarSyncsData = any;
+export type ListCalendarSyncsError = ErrorResponse;
+export type GetStudentTicketData = any;
+export type GetStudentTicketError = ErrorResponse;
+export type CreateStudentTicketData = any;
+export type CreateStudentTicketError = ErrorResponse;
+export type DeleteStudentTicketData = any;
+export type DeleteStudentTicketError = ErrorResponse;
+export type GetTemplateData = any;
+export type GetTemplateError = ErrorResponse;
+export type CreateTemplateData = any;
+export type CreateTemplateError = ErrorResponse;
+export type UpdateTemplateData = any;
+export type UpdateTemplateError = ErrorResponse;
+export type DeleteTemplateData = any;
+export type DeleteTemplateError = ErrorResponse;
+export type ListTemplatesData = any;
+export type ListTemplatesError = ErrorResponse;
+export type ListCoursesData = any;
+export type ListCoursesError = ErrorResponse;
+export type ListLocationsData = any;
+export type ListLocationsError = ErrorResponse;
+export type ListSessionsIdsData = any;
+export type ListSessionsIdsError = ErrorResponse;
+export type GetSessionData = any;
+export type GetSessionError = ErrorResponse;
+export type CreateSessionData = any;
+export type CreateSessionError = ErrorResponse;
+export type UpdateSessionData = any;
+export type UpdateSessionError = ErrorResponse;
+export type DeleteSessionData = any;
+export type DeleteSessionError = ErrorResponse;
+export type CreateNextData = any;
+export type CreateNextError = ErrorResponse;
+export type CreateCancelData = any;
+export type CreateCancelError = ErrorResponse;
+export type CreateLockData = any;
+export type CreateLockError = ErrorResponse;
+export type CreateUnlockData = any;
+export type CreateUnlockError = ErrorResponse;
+export type CreatePublishData = any;
+export type CreatePublishError = ErrorResponse;
+export type CreateReleaseData = any;
+export type CreateReleaseError = ErrorResponse;
+export type CreateRefreshShippingData = any;
+export type CreateRefreshShippingError = ErrorResponse;
+export type CreateCourseMaterialData = any;
+export type CreateCourseMaterialError = ErrorResponse;
+export type CreateDuplicateData = any;
+export type CreateDuplicateError = ErrorResponse;
+export type CreateMoveStudentData = any;
+export type CreateMoveStudentError = ErrorResponse;
+export type GetAttendancesData = any;
+export type GetAttendancesError = ErrorResponse;
+export type GetEnrolmentsData = any;
+export type GetEnrolmentsError = ErrorResponse;
+export type GetResultsData = any;
+export type GetResultsError = ErrorResponse;
+export type GetInvitationsData = any;
+export type GetInvitationsError = ErrorResponse;
+export type GetChargesData = any;
+export type GetChargesError = ErrorResponse;
+export type GetAttendanceData = any;
+export type GetAttendanceError = ErrorResponse;
+export type CreateAttendanceData = any;
+export type CreateAttendanceError = ErrorResponse;
+export type UpdateAttendanceData = any;
+export type UpdateAttendanceError = ErrorResponse;
+export type DeleteAttendanceData = any;
+export type DeleteAttendanceError = ErrorResponse;
+export type GetEnrolmentData = any;
+export type GetEnrolmentError = ErrorResponse;
+export type CreateEnrolmentData = any;
+export type CreateEnrolmentError = ErrorResponse;
+export type UpdateEnrolmentData = any;
+export type UpdateEnrolmentError = ErrorResponse;
+export type DeleteEnrolmentData = any;
+export type DeleteEnrolmentError = ErrorResponse;
+export type GetEnrolment2Data = any;
+export type GetEnrolment2Error = ErrorResponse;
+export type CreateEnrolmentReleaseData = any;
+export type CreateEnrolmentReleaseError = ErrorResponse;
+export type CreateEnrolmentCancelData = any;
+export type CreateEnrolmentCancelError = ErrorResponse;
+export type CreateEnrolmentLaunchData = any;
+export type CreateEnrolmentLaunchError = ErrorResponse;
+export type CreateEnrolmentCheckResultData = any;
+export type CreateEnrolmentCheckResultError = ErrorResponse;
+export type CreateEnrolmentChargeData = any;
+export type CreateEnrolmentChargeError = ErrorResponse;
+export type GetResultData = any;
+export type GetResultError = ErrorResponse;
+export type CreateResultData = any;
+export type CreateResultError = ErrorResponse;
+export type UpdateResultData = any;
+export type UpdateResultError = ErrorResponse;
+export type DeleteResultData = any;
+export type DeleteResultError = ErrorResponse;
+export type CreateResultPublishData = any;
+export type CreateResultPublishError = ErrorResponse;
+export type GetInstructorResult = any;
+export type GetInstructorFail = ErrorResponse;
+export type CreateInstructorResult = any;
+export type CreateInstructorFail = ErrorResponse;
+export type UpdateInstructorResult = any;
+export type UpdateInstructorFail = ErrorResponse;
+export type DeleteInstructorResult = any;
+export type DeleteInstructorFail = ErrorResponse;
+export type CreateInstructorOutput = any;
+export type CreateInstructorFails = ErrorResponse;
+export type GetInvitationData = any;
+export type GetInvitationError = ErrorResponse;
+export type CreateInvitationData = any;
+export type CreateInvitationError = ErrorResponse;
+export type UpdateInvitationData = any;
+export type UpdateInvitationError = ErrorResponse;
+export type DeleteInvitationData = any;
+export type DeleteInvitationError = ErrorResponse;
+export type GetInvitationValidateData = any;
+export type GetInvitationValidateError = ErrorResponse;
+export type GetChargeData = any;
+export type GetChargeError = ErrorResponse;
+export type GetDocumentFileSignData = any;
+export type GetDocumentFileSignError = ErrorResponse;
+export type CreateDocumentFileSignData = any;
+export type CreateDocumentFileSignError = ErrorResponse;
+export type DeleteDocumentFileSignData = any;
+export type DeleteDocumentFileSignError = ErrorResponse;
+export type CreateDocumentData = any;
+export type CreateDocumentError = ErrorResponse;
+export type DeleteDocumentData = any;
+export type DeleteDocumentError = ErrorResponse;
+export type CreateAttendancesResultsBatchUpsertData = any;
+export type CreateAttendancesResultsBatchUpsertError = ErrorResponse;
+export type GetUserDataData = any;
+export type GetUserDataError = ErrorResponse;
+export type ListEventsResult = any;
+export type ListEventsFail = ErrorResponse;
+export type ListEvents2Data = any;
+export type ListEvents2Error = ErrorResponse;
+export type ListSessionEventsData = any;
+export type ListSessionEventsError = ErrorResponse;
+export type CreateEnrolmentsPerPeriodData = any;
+export type CreateEnrolmentsPerPeriodError = ErrorResponse;
+export type ListSessionResultsAnalysisData = any;
+export type ListSessionResultsAnalysisError = ErrorResponse;
+export type CreateSessionResultsPreviewData = any;
+export type CreateSessionResultsPreviewError = ErrorResponse;
+export type ListSessionResultsData = any;
+export type ListSessionResultsError = ErrorResponse;
+export type CreateSessionListData = any;
+export type CreateSessionListError = ErrorResponse;
+export type ListSessionChargesData = any;
+export type ListSessionChargesError = ErrorResponse;
+export type CreateSessionShippingManifestData = any;
+export type CreateSessionShippingManifestError = ErrorResponse;
+import type { AxiosInstance, AxiosRequestConfig, ResponseType } from 'axios';
+export type QueryParamsType = Record<string | number, any>;
+export interface FullRequestParams extends Omit<AxiosRequestConfig, 'data' | 'params' | 'url' | 'responseType'> {
+    /** set parameter to `true` for call `securityWorker` for this request */
+    secure?: boolean;
+    /** request path */
+    path: string;
+    /** content type of request body */
+    type?: ContentType;
+    /** query params */
+    query?: QueryParamsType;
+    /** format of response (i.e. response.json() -> format: "json") */
+    format?: ResponseType;
+    /** request body */
+    body?: unknown;
+}
+export type RequestParams = Omit<FullRequestParams, 'body' | 'method' | 'query' | 'path'>;
+export interface ApiConfig<SecurityDataType = unknown> extends Omit<AxiosRequestConfig, 'data' | 'cancelToken'> {
+    securityWorker?: (securityData: SecurityDataType | null) => Promise<AxiosRequestConfig | void> | AxiosRequestConfig | void;
+    secure?: boolean;
+    format?: ResponseType;
+}
+export declare enum ContentType {
+    Json = "application/json",
+    FormData = "multipart/form-data",
+    UrlEncoded = "application/x-www-form-urlencoded",
+    Text = "text/plain"
+}
+export declare class HttpClient<SecurityDataType = unknown> {
+    instance: AxiosInstance;
+    private securityData;
+    private securityWorker?;
+    private secure?;
+    private format?;
+    constructor({ securityWorker, secure, format, ...axiosConfig }?: ApiConfig<SecurityDataType>);
+    setSecurityData: (data: SecurityDataType | null) => void;
+    protected mergeRequestParams(params1: AxiosRequestConfig, params2?: AxiosRequestConfig): AxiosRequestConfig;
+    protected stringifyFormItem(formItem: unknown): string;
+    protected createFormData(input: Record<string, unknown>): FormData;
+    request: <T = any, _E = any>({ secure, path, type, query, format, body, ...params }: FullRequestParams) => Promise<T>;
+}
+/**
+ * @title Classroom Module API
+ * @version 2.0.0
+ * @baseUrl http://localhost:8080
+ * @contact Ikon Integration <ikon@ikonintegration.com> (http://example.com)
+ */
+export declare class Api<SecurityDataType extends unknown> extends HttpClient<SecurityDataType> {
+    region: {
+        /**
+         * @description Retrieve a region by ID
+         *
+         * @tags Region
+         * @name GetRegion
+         * @summary Get Region
+         * @request GET:/region/{regionID}
+         * @secure
+         */
+        getRegion: (regionId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Create a new region
+         *
+         * @tags Region
+         * @name CreateRegion
+         * @summary Create Region
+         * @request POST:/region/{regionID}
+         * @secure
+         */
+        createRegion: (regionId: string, data: Input9Jxov33U7D, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Update an existing region
+         *
+         * @tags Region
+         * @name UpdateRegion
+         * @summary Update Region
+         * @request PUT:/region/{regionID}
+         * @secure
+         */
+        updateRegion: (regionId: string, data: InputUse5Vle8Ta, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Delete a region by ID
+         *
+         * @tags Region
+         * @name DeleteRegion
+         * @summary Delete Region
+         * @request DELETE:/region/{regionID}
+         * @secure
+         */
+        deleteRegion: (regionId: string, params?: RequestParams) => Promise<any>;
+    };
+    regions: {
+        /**
+         * @description Retrieve all regions for the current customer
+         *
+         * @tags Region
+         * @name ListRegions
+         * @summary Get All Regions
+         * @request GET:/regions
+         * @secure
+         */
+        listRegions: (params?: RequestParams) => Promise<any>;
+    };
+    city: {
+        /**
+         * @description Retrieve a city by ID
+         *
+         * @tags City
+         * @name GetCity
+         * @summary Get City
+         * @request GET:/city/{cityID}
+         * @secure
+         */
+        getCity: (cityId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Create a new city
+         *
+         * @tags City
+         * @name CreateCity
+         * @summary Create City
+         * @request POST:/city/{cityID}
+         * @secure
+         */
+        createCity: (cityId: string, data: CityCreateSchema, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Update an existing city
+         *
+         * @tags City
+         * @name UpdateCity
+         * @summary Update City
+         * @request PUT:/city/{cityID}
+         * @secure
+         */
+        updateCity: (cityId: string, data: CityUpdateSchema, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Delete a city by ID
+         *
+         * @tags City
+         * @name DeleteCity
+         * @summary Delete City
+         * @request DELETE:/city/{cityID}
+         * @secure
+         */
+        deleteCity: (cityId: string, params?: RequestParams) => Promise<any>;
+    };
+    cities: {
+        /**
+         * @description Retrieve all cities for the current customer
+         *
+         * @tags City
+         * @name ListCities
+         * @summary Get All Cities
+         * @request GET:/cities
+         * @secure
+         */
+        listCities: (params?: RequestParams) => Promise<any>;
+    };
+    venue: {
+        /**
+         * @description Retrieve a venue by ID
+         *
+         * @tags Venue
+         * @name GetVenue
+         * @summary Get Venue
+         * @request GET:/venue/{venueID}
+         * @secure
+         */
+        getVenue: (venueId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Create a new venue
+         *
+         * @tags Venue
+         * @name CreateVenue
+         * @summary Create Venue
+         * @request POST:/venue/{venueID}
+         * @secure
+         */
+        createVenue: (venueId: string, data: VenueCreateSchema, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Update an existing venue
+         *
+         * @tags Venue
+         * @name UpdateVenue
+         * @summary Update Venue
+         * @request PUT:/venue/{venueID}
+         * @secure
+         */
+        updateVenue: (venueId: string, data: VenueUpdateSchema, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Delete a venue by ID
+         *
+         * @tags Venue
+         * @name DeleteVenue
+         * @summary Delete Venue
+         * @request DELETE:/venue/{venueID}
+         * @secure
+         */
+        deleteVenue: (venueId: string, params?: RequestParams) => Promise<any>;
+    };
+    venues: {
+        /**
+         * @description Retrieve all venues for the current customer
+         *
+         * @tags Venue
+         * @name ListVenues
+         * @summary Get All Venues
+         * @request GET:/venues
+         * @secure
+         */
+        listVenues: (params?: RequestParams) => Promise<any>;
+    };
+    instructor: {
+        /**
+         * @description Retrieve an instructor by ID with expanded details
+         *
+         * @tags Instructor
+         * @name GetInstructor
+         * @summary Get Instructor
+         * @request GET:/instructor/{instructorID}
+         * @secure
+         */
+        getInstructor: (instructorId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Register a user as an instructor
+         *
+         * @tags Instructor
+         * @name CreateInstructor
+         * @summary Create Instructor
+         * @request POST:/instructor/{instructorID}
+         * @secure
+         */
+        createInstructor: (instructorId: string, data: InstructorCreateSchema, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Update an instructor
+         *
+         * @tags Instructor
+         * @name UpdateInstructor
+         * @summary Update Instructor
+         * @request PUT:/instructor/{instructorID}
+         * @secure
+         */
+        updateInstructor: (instructorId: string, data: InstructorUpdateSchema, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Remove an instructor
+         *
+         * @tags Instructor
+         * @name DeleteInstructor
+         * @summary Delete Instructor
+         * @request DELETE:/instructor/{instructorID}
+         * @secure
+         */
+        deleteInstructor: (instructorId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Retrieve courses assigned to an instructor
+         *
+         * @tags Instructor
+         * @name GetCourse
+         * @summary Get Instructor Courses
+         * @request GET:/instructor/{instructorID}/course
+         * @secure
+         */
+        getCourse: (instructorId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Smart update courses assigned to an instructor
+         *
+         * @tags Instructor
+         * @name CreateCourse
+         * @summary Update Instructor Courses
+         * @request POST:/instructor/{instructorID}/course
+         * @secure
+         */
+        createCourse: (instructorId: string, data: InstructorCourseUpdateSchema, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Retrieve regions assigned to an instructor
+         *
+         * @tags Instructor
+         * @name GetRegion
+         * @summary Get Instructor Regions
+         * @request GET:/instructor/{instructorID}/region
+         * @secure
+         */
+        getRegion: (instructorId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Smart update regions assigned to an instructor
+         *
+         * @tags Instructor
+         * @name CreateRegion
+         * @summary Update Instructor Regions
+         * @request POST:/instructor/{instructorID}/region
+         * @secure
+         */
+        createRegion: (instructorId: string, data: InstructorRegionUpdateSchema, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Retrieve instructor calendar events within a time range
+         *
+         * @tags Instructor
+         * @name ListEvents
+         * @summary Get Instructor Events
+         * @request POST:/instructor/{instructorID}/events
+         * @secure
+         */
+        listEvents: (instructorId: string, data: Input33N9Vgyjyy, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Retrieve an instructor availability event
+         *
+         * @tags InstructorCalendar
+         * @name GetAvailabilityEvent
+         * @summary Get Availability Event
+         * @request GET:/instructor/{instructorID}/availabilityEvent/{startTime}
+         * @secure
+         */
+        getAvailabilityEvent: (instructorId: string, startTime: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Create an instructor availability event
+         *
+         * @tags InstructorCalendar
+         * @name CreateAvailabilityEvent
+         * @summary Create Availability Event
+         * @request POST:/instructor/{instructorID}/availabilityEvent/{startTime}
+         * @secure
+         */
+        createAvailabilityEvent: (instructorId: string, startTime: string, data: Input56Hzg6Xiz2, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Update an instructor availability event (delete + recreate)
+         *
+         * @tags InstructorCalendar
+         * @name UpdateAvailabilityEvent
+         * @summary Update Availability Event
+         * @request PUT:/instructor/{instructorID}/availabilityEvent/{startTime}
+         * @secure
+         */
+        updateAvailabilityEvent: (instructorId: string, startTime: string, data: Input3Yilrlis7M, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Delete an instructor availability event
+         *
+         * @tags InstructorCalendar
+         * @name DeleteAvailabilityEvent
+         * @summary Delete Availability Event
+         * @request DELETE:/instructor/{instructorID}/availabilityEvent/{startTime}
+         * @secure
+         */
+        deleteAvailabilityEvent: (instructorId: string, startTime: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Retrieve a calendar sync configuration
+         *
+         * @tags InstructorCalendarSync
+         * @name GetCalendarSync
+         * @summary Get Instructor Calendar Sync
+         * @request GET:/instructor/{instructorID}/calendarSync/{providerID}
+         * @secure
+         */
+        getCalendarSync: (instructorId: string, providerId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Create a calendar sync configuration
+         *
+         * @tags InstructorCalendarSync
+         * @name CreateCalendarSync
+         * @summary Create Instructor Calendar Sync
+         * @request POST:/instructor/{instructorID}/calendarSync/{providerID}
+         * @secure
+         */
+        createCalendarSync: (instructorId: string, providerId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Update a calendar sync configuration
+         *
+         * @tags InstructorCalendarSync
+         * @name UpdateCalendarSync
+         * @summary Update Instructor Calendar Sync
+         * @request PUT:/instructor/{instructorID}/calendarSync/{providerID}
+         * @secure
+         */
+        updateCalendarSync: (instructorId: string, providerId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Delete a calendar sync configuration
+         *
+         * @tags InstructorCalendarSync
+         * @name DeleteCalendarSync
+         * @summary Delete Instructor Calendar Sync
+         * @request DELETE:/instructor/{instructorID}/calendarSync/{providerID}
+         * @secure
+         */
+        deleteCalendarSync: (instructorId: string, providerId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Retrieve all calendar sync configurations for an instructor
+         *
+         * @tags InstructorCalendarSync
+         * @name GetCalendarSyncs
+         * @summary Get All Instructor Calendar Syncs
+         * @request GET:/instructor/{instructorID}/calendarSyncs
+         * @secure
+         */
+        getCalendarSyncs: (instructorId: string, params?: RequestParams) => Promise<any>;
+    };
+    instructors: {
+        /**
+         * @description Retrieve all instructors for the current customer
+         *
+         * @tags Instructor
+         * @name ListInstructors
+         * @summary Get All Instructors
+         * @request GET:/instructors
+         * @secure
+         */
+        listInstructors: (params?: RequestParams) => Promise<any>;
+    };
+    course: {
+        /**
+         * @description Retrieve course calendar configuration
+         *
+         * @tags CourseCalendar
+         * @name GetCalendar
+         * @summary Get Course Calendar
+         * @request GET:/course/{courseID}/calendar
+         * @secure
+         */
+        getCalendar: (courseId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Upsert course calendar configuration
+         *
+         * @tags CourseCalendar
+         * @name UpdateCalendar
+         * @summary Update Course Calendar
+         * @request PUT:/course/{courseID}/calendar
+         * @secure
+         */
+        updateCalendar: (courseId: string, data: InputKi6Tbrci1R, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Retrieve a course enrolment ticket
+         *
+         * @tags CourseTicket
+         * @name GetStudentTicket
+         * @summary Get Course Ticket
+         * @request GET:/course/{courseID}/student/{userID}/ticket/{ticketID}
+         * @secure
+         */
+        getStudentTicket: (courseId: string, userId: string, ticketId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Generate a course enrolment ticket
+         *
+         * @tags CourseTicket
+         * @name CreateStudentTicket
+         * @summary Create Course Ticket
+         * @request POST:/course/{courseID}/student/{userID}/ticket/{ticketID}
+         * @secure
+         */
+        createStudentTicket: (courseId: string, userId: string, ticketId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Delete a course enrolment ticket
+         *
+         * @tags CourseTicket
+         * @name DeleteStudentTicket
+         * @summary Delete Course Ticket
+         * @request DELETE:/course/{courseID}/student/{userID}/ticket/{ticketID}
+         * @secure
+         */
+        deleteStudentTicket: (courseId: string, userId: string, ticketId: string, params?: RequestParams) => Promise<any>;
+    };
+    courses: {
+        /**
+         * @description Retrieve a course calendar sync configuration
+         *
+         * @tags CourseCalendarSync
+         * @name GetCalendarSync
+         * @summary Get Course Calendar Sync
+         * @request GET:/courses/calendarSync/{providerID}
+         * @secure
+         */
+        getCalendarSync: (providerId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Create a course calendar sync
+         *
+         * @tags CourseCalendarSync
+         * @name CreateCalendarSync
+         * @summary Create Course Calendar Sync
+         * @request POST:/courses/calendarSync/{providerID}
+         * @secure
+         */
+        createCalendarSync: (providerId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Update a course calendar sync
+         *
+         * @tags CourseCalendarSync
+         * @name UpdateCalendarSync
+         * @summary Update Course Calendar Sync
+         * @request PUT:/courses/calendarSync/{providerID}
+         * @secure
+         */
+        updateCalendarSync: (providerId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Delete a course calendar sync
+         *
+         * @tags CourseCalendarSync
+         * @name DeleteCalendarSync
+         * @summary Delete Course Calendar Sync
+         * @request DELETE:/courses/calendarSync/{providerID}
+         * @secure
+         */
+        deleteCalendarSync: (providerId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Retrieve all course calendar syncs for the customer
+         *
+         * @tags CourseCalendarSync
+         * @name ListCalendarSyncs
+         * @summary Get All Course Calendar Syncs
+         * @request GET:/courses/calendarSyncs
+         * @secure
+         */
+        listCalendarSyncs: (params?: RequestParams) => Promise<any>;
+        /**
+         * @description Retrieve all courses for the current tenant or customer
+         *
+         * @tags Course
+         * @name ListCourses
+         * @summary Get All Courses
+         * @request GET:/courses
+         * @secure
+         */
+        listCourses: (params?: RequestParams) => Promise<any>;
+    };
+    template: {
+        /**
+         * @description Retrieve a session course template by ID
+         *
+         * @tags Template
+         * @name GetTemplate
+         * @summary Get Template
+         * @request GET:/template/{templateID}
+         * @secure
+         */
+        getTemplate: (templateId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Create a new session course template
+         *
+         * @tags Template
+         * @name CreateTemplate
+         * @summary Create Template
+         * @request POST:/template/{templateID}
+         * @secure
+         */
+        createTemplate: (templateId: string, data: SessionCourseTemplateCreateSchema, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Update an existing session course template
+         *
+         * @tags Template
+         * @name UpdateTemplate
+         * @summary Update Template
+         * @request PUT:/template/{templateID}
+         * @secure
+         */
+        updateTemplate: (templateId: string, data: SessionCourseTemplateUpdateSchema, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Delete a session course template
+         *
+         * @tags Template
+         * @name DeleteTemplate
+         * @summary Delete Template
+         * @request DELETE:/template/{templateID}
+         * @secure
+         */
+        deleteTemplate: (templateId: string, params?: RequestParams) => Promise<any>;
+    };
+    templates: {
+        /**
+         * @description Retrieve all session course templates
+         *
+         * @tags Template
+         * @name ListTemplates
+         * @summary Get All Templates
+         * @request GET:/templates
+         * @secure
+         */
+        listTemplates: (params?: RequestParams) => Promise<any>;
+    };
+    locations: {
+        /**
+         * @description Retrieve all locations (regions, cities, venues map)
+         *
+         * @tags Location
+         * @name ListLocations
+         * @summary Get Locations
+         * @request GET:/locations
+         * @secure
+         */
+        listLocations: (params?: RequestParams) => Promise<any>;
+    };
+    search: {
+        /**
+         * @description Search for sessions by an array of IDs
+         *
+         * @tags Search
+         * @name ListSessionsIds
+         * @summary Search Sessions by IDs
+         * @request POST:/search/sessions/ids
+         * @secure
+         */
+        listSessionsIds: (data: SearchSessionsByIDsSchema, params?: RequestParams) => Promise<any>;
+    };
+    session: {
+        /**
+         * @description Retrieve a session by ID
+         *
+         * @tags Session
+         * @name GetSession
+         * @summary Get Session
+         * @request GET:/session/{sessionID}
+         * @secure
+         */
+        getSession: (sessionId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Create a new session
+         *
+         * @tags Session
+         * @name CreateSession
+         * @summary Create Session
+         * @request POST:/session/{sessionID}
+         * @secure
+         */
+        createSession: (sessionId: string, data: SessionCreateSchema, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Update an existing session
+         *
+         * @tags Session
+         * @name UpdateSession
+         * @summary Update Session
+         * @request PUT:/session/{sessionID}
+         * @secure
+         */
+        updateSession: (sessionId: string, data: SessionUpdateSchema, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Delete a session
+         *
+         * @tags Session
+         * @name DeleteSession
+         * @summary Delete Session
+         * @request DELETE:/session/{sessionID}
+         * @secure
+         */
+        deleteSession: (sessionId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Transition session to next state
+         *
+         * @tags Session
+         * @name CreateNext
+         * @summary Advance Session State
+         * @request POST:/session/{sessionID}/next
+         * @secure
+         */
+        createNext: (sessionId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Cancel a session
+         *
+         * @tags Session
+         * @name CreateCancel
+         * @summary Cancel Session
+         * @request POST:/session/{sessionID}/cancel
+         * @secure
+         */
+        createCancel: (sessionId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Lock a session
+         *
+         * @tags Session
+         * @name CreateLock
+         * @summary Lock Session
+         * @request POST:/session/{sessionID}/lock
+         * @secure
+         */
+        createLock: (sessionId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Unlock a locked session
+         *
+         * @tags Session
+         * @name CreateUnlock
+         * @summary Unlock Session
+         * @request POST:/session/{sessionID}/unlock
+         * @secure
+         */
+        createUnlock: (sessionId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Publish or unpublish session calendar events
+         *
+         * @tags Session
+         * @name CreatePublish
+         * @summary Publish Session
+         * @request POST:/session/{sessionID}/publish
+         * @secure
+         */
+        createPublish: (sessionId: string, data: SessionPublishSchema, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Release session access to students
+         *
+         * @tags Session
+         * @name CreateRelease
+         * @summary Release Session
+         * @request POST:/session/{sessionID}/release
+         * @secure
+         */
+        createRelease: (sessionId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Refresh material shipping info for session
+         *
+         * @tags Session
+         * @name CreateRefreshShipping
+         * @summary Refresh Shipping
+         * @request POST:/session/{sessionID}/refreshShipping
+         * @secure
+         */
+        createRefreshShipping: (sessionId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Update material shipped status for a session
+         *
+         * @tags Session
+         * @name CreateCourseMaterial
+         * @summary Update Course Material Status
+         * @request POST:/session/{sessionID}/courseMaterial
+         * @secure
+         */
+        createCourseMaterial: (sessionId: string, data: SessionShipStatusSchema, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Duplicate a session to new dates
+         *
+         * @tags Session
+         * @name CreateDuplicate
+         * @summary Duplicate Session
+         * @request POST:/session/{sessionID}/duplicate
+         * @secure
+         */
+        createDuplicate: (sessionId: string, data: SessionDuplicateSchema, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Move a student between sessions of the same course
+         *
+         * @tags Session
+         * @name CreateMoveStudent
+         * @summary Move Student
+         * @request POST:/session/{sessionID}/moveStudent/{userID}/{newSessionID}
+         * @secure
+         */
+        createMoveStudent: (sessionId: string, userId: string, newSessionId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Retrieve all attendances for a session
+         *
+         * @tags Session Attendance
+         * @name GetAttendances
+         * @summary Get Session Attendances
+         * @request GET:/session/{sessionID}/attendances
+         * @secure
+         */
+        getAttendances: (sessionId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Retrieve all enrolments for a session
+         *
+         * @tags Session Enrolment
+         * @name GetEnrolments
+         * @summary Get Session Enrolments
+         * @request GET:/session/{sessionID}/enrolments
+         * @secure
+         */
+        getEnrolments: (sessionId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Retrieve all results for a session
+         *
+         * @tags Session Result
+         * @name GetResults
+         * @summary Get Session Results
+         * @request GET:/session/{sessionID}/results
+         * @secure
+         */
+        getResults: (sessionId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Retrieve all enrolment invitations for a session
+         *
+         * @tags Session Invitation
+         * @name GetInvitations
+         * @summary Get Session Invitations
+         * @request GET:/session/{sessionID}/invitations
+         * @secure
+         */
+        getInvitations: (sessionId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Retrieve financial charges for a user in a session
+         *
+         * @tags Session Financial Charge
+         * @name GetCharges
+         * @summary Get Session Charges
+         * @request GET:/session/{sessionID}/charges/{userID}
+         * @secure
+         */
+        getCharges: (sessionId: string, userId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Retrieve a specific attendance record
+         *
+         * @tags Session Attendance
+         * @name GetAttendance
+         * @summary Get Session Attendance
+         * @request GET:/session/{sessionID}/attendance/{attendanceID}/{externalID}
+         * @secure
+         */
+        getAttendance: (sessionId: string, attendanceId: string, externalId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Create a new attendance record
+         *
+         * @tags Session Attendance
+         * @name CreateAttendance
+         * @summary Create Session Attendance
+         * @request POST:/session/{sessionID}/attendance/{attendanceID}/{externalID}
+         * @secure
+         */
+        createAttendance: (sessionId: string, attendanceId: string, externalId: string, data: InputQ59Gbvuj7G, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Update an existing attendance record
+         *
+         * @tags Session Attendance
+         * @name UpdateAttendance
+         * @summary Update Session Attendance
+         * @request PUT:/session/{sessionID}/attendance/{attendanceID}/{externalID}
+         * @secure
+         */
+        updateAttendance: (sessionId: string, attendanceId: string, externalId: string, data: Input5S9Qlxsfdw, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Delete an attendance record
+         *
+         * @tags Session Attendance
+         * @name DeleteAttendance
+         * @summary Delete Session Attendance
+         * @request DELETE:/session/{sessionID}/attendance/{attendanceID}/{externalID}
+         * @secure
+         */
+        deleteAttendance: (sessionId: string, attendanceId: string, externalId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Retrieve a specific enrolment record
+         *
+         * @tags Session Enrolment
+         * @name GetEnrolment
+         * @summary Get Session Enrolment
+         * @request GET:/session/{sessionID}/enrolment/{enrolmentID}/{externalID}
+         * @secure
+         */
+        getEnrolment: (sessionId: string, enrolmentId: string, externalId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Create a new session enrolment
+         *
+         * @tags Session Enrolment
+         * @name CreateEnrolment
+         * @summary Create Session Enrolment
+         * @request POST:/session/{sessionID}/enrolment/{enrolmentID}/{externalID}
+         * @secure
+         */
+        createEnrolment: (sessionId: string, enrolmentId: string, externalId: string, data: InputKdcf6Vev2F, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Update an existing session enrolment
+         *
+         * @tags Session Enrolment
+         * @name UpdateEnrolment
+         * @summary Update Session Enrolment
+         * @request PUT:/session/{sessionID}/enrolment/{enrolmentID}/{externalID}
+         * @secure
+         */
+        updateEnrolment: (sessionId: string, enrolmentId: string, externalId: string, data: InputPcoc6Mas3J, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Delete a session enrolment
+         *
+         * @tags Session Enrolment
+         * @name DeleteEnrolment
+         * @summary Delete Session Enrolment
+         * @request DELETE:/session/{sessionID}/enrolment/{enrolmentID}/{externalID}
+         * @secure
+         */
+        deleteEnrolment: (sessionId: string, enrolmentId: string, externalId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Retrieve an enrolment by session and user
+         *
+         * @tags Session Enrolment
+         * @name GetEnrolment2
+         * @summary Get Session Enrolment By User
+         * @request GET:/session/{sessionID}/enrolment/{enrolmentID}
+         * @originalName getEnrolment
+         * @duplicate
+         * @secure
+         */
+        getEnrolment2: (sessionId: string, enrolmentId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Release a session enrolment
+         *
+         * @tags Session Enrolment
+         * @name CreateEnrolmentRelease
+         * @summary Release Session Enrolment
+         * @request POST:/session/{sessionID}/enrolment/{enrolmentID}/{externalID}/release
+         * @secure
+         */
+        createEnrolmentRelease: (sessionId: string, enrolmentId: string, externalId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Cancel a session enrolment
+         *
+         * @tags Session Enrolment
+         * @name CreateEnrolmentCancel
+         * @summary Cancel Session Enrolment
+         * @request POST:/session/{sessionID}/enrolment/{enrolmentID}/{externalID}/cancel
+         * @secure
+         */
+        createEnrolmentCancel: (sessionId: string, enrolmentId: string, externalId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Generate SSO launch link for an online session enrolment
+         *
+         * @tags Session Enrolment
+         * @name CreateEnrolmentLaunch
+         * @summary Launch Session Enrolment SSO
+         * @request POST:/session/{sessionID}/enrolment/{enrolmentID}/{externalID}/launch
+         * @secure
+         */
+        createEnrolmentLaunch: (sessionId: string, enrolmentId: string, externalId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Check the result for an online session enrolment
+         *
+         * @tags Session Enrolment
+         * @name CreateEnrolmentCheckResult
+         * @summary Check Enrolment Result
+         * @request POST:/session/{sessionID}/enrolment/{enrolmentID}/{externalID}/checkResult
+         * @secure
+         */
+        createEnrolmentCheckResult: (sessionId: string, enrolmentId: string, externalId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Create a financial charge for an enrolment
+         *
+         * @tags Session Enrolment
+         * @name CreateEnrolmentCharge
+         * @summary Create Enrolment Charge
+         * @request POST:/session/{sessionID}/enrolment/{enrolmentID}/{externalID}/charge
+         * @secure
+         */
+        createEnrolmentCharge: (sessionId: string, enrolmentId: string, externalId: string, data: Input56A08Qop2C, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Retrieve a specific session result
+         *
+         * @tags Session Result
+         * @name GetResult
+         * @summary Get Session Result
+         * @request GET:/session/{sessionID}/result/{resultID}/{externalID}
+         * @secure
+         */
+        getResult: (sessionId: string, resultId: string, externalId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Create a new session result
+         *
+         * @tags Session Result
+         * @name CreateResult
+         * @summary Create Session Result
+         * @request POST:/session/{sessionID}/result/{resultID}/{externalID}
+         * @secure
+         */
+        createResult: (sessionId: string, resultId: string, externalId: string, data: InputHuw5M2U5Gx, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Update an existing session result
+         *
+         * @tags Session Result
+         * @name UpdateResult
+         * @summary Update Session Result
+         * @request PUT:/session/{sessionID}/result/{resultID}/{externalID}
+         * @secure
+         */
+        updateResult: (sessionId: string, resultId: string, externalId: string, data: InputXxwuna2Nn, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Delete a session result
+         *
+         * @tags Session Result
+         * @name DeleteResult
+         * @summary Delete Session Result
+         * @request DELETE:/session/{sessionID}/result/{resultID}/{externalID}
+         * @secure
+         */
+        deleteResult: (sessionId: string, resultId: string, externalId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Publish a session result
+         *
+         * @tags Session Result
+         * @name CreateResultPublish
+         * @summary Publish Session Result
+         * @request POST:/session/{sessionID}/result/{resultID}/{externalID}/publish
+         * @secure
+         */
+        createResultPublish: (sessionId: string, resultId: string, externalId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Retrieve a session instructor assignment
+         *
+         * @tags Session Instructor
+         * @name GetInstructor
+         * @summary Get Session Instructor
+         * @request GET:/session/{sessionID}/instructor/{instructorID}
+         * @secure
+         */
+        getInstructor: (sessionId: string, instructorId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Assign an instructor to a session
+         *
+         * @tags Session Instructor
+         * @name CreateInstructor
+         * @summary Assign Session Instructor
+         * @request POST:/session/{sessionID}/instructor/{instructorID}
+         * @secure
+         */
+        createInstructor: (sessionId: string, instructorId: string, data: SessionInstructorSchema, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Update a session instructor assignment
+         *
+         * @tags Session Instructor
+         * @name UpdateInstructor
+         * @summary Update Session Instructor
+         * @request PUT:/session/{sessionID}/instructor/{instructorID}
+         * @secure
+         */
+        updateInstructor: (sessionId: string, instructorId: string, data: SessionInstructorSchema, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Remove an instructor from a session
+         *
+         * @tags Session Instructor
+         * @name DeleteInstructor
+         * @summary Unassign Session Instructor
+         * @request DELETE:/session/{sessionID}/instructor/{instructorID}
+         * @secure
+         */
+        deleteInstructor: (sessionId: string, instructorId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Retrieve a session invitation
+         *
+         * @tags Session Invitation
+         * @name GetInvitation
+         * @summary Get Session Invitation
+         * @request GET:/session/{sessionID}/invitation/{invitationID}
+         * @secure
+         */
+        getInvitation: (sessionId: string, invitationId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Create a new session invitation
+         *
+         * @tags Session Invitation
+         * @name CreateInvitation
+         * @summary Create Session Invitation
+         * @request POST:/session/{sessionID}/invitation/{invitationID}
+         * @secure
+         */
+        createInvitation: (sessionId: string, invitationId: string, data: InputW0Gt14Iief, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Update an existing session invitation
+         *
+         * @tags Session Invitation
+         * @name UpdateInvitation
+         * @summary Update Session Invitation
+         * @request PUT:/session/{sessionID}/invitation/{invitationID}
+         * @secure
+         */
+        updateInvitation: (sessionId: string, invitationId: string, data: InputF61Tonm0Be, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Delete a session invitation
+         *
+         * @tags Session Invitation
+         * @name DeleteInvitation
+         * @summary Delete Session Invitation
+         * @request DELETE:/session/{sessionID}/invitation/{invitationID}
+         * @secure
+         */
+        deleteInvitation: (sessionId: string, invitationId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Validate a session invitation code
+         *
+         * @tags Session Invitation
+         * @name GetInvitationValidate
+         * @summary Validate Session Invitation
+         * @request GET:/session/invitation/validate/{invitationCode}
+         * @secure
+         */
+        getInvitationValidate: (invitationCode: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Retrieve a specific financial charge
+         *
+         * @tags Session Financial Charge
+         * @name GetCharge
+         * @summary Get Session Financial Charge
+         * @request GET:/session/{sessionID}/charge/{userID}/{timestamp}
+         * @secure
+         */
+        getCharge: (sessionId: string, userId: string, timestamp: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Get a signed URL to download a session document
+         *
+         * @tags Session Document
+         * @name GetDocumentFileSign
+         * @summary Get Session Document Signed URL
+         * @request GET:/session/{sessionID}/document/fileSign/{fileID}
+         * @secure
+         */
+        getDocumentFileSign: (sessionId: string, fileId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Get a signed URL to upload a session document
+         *
+         * @tags Session Document
+         * @name CreateDocumentFileSign
+         * @summary Get Session Document Upload URL
+         * @request POST:/session/{sessionID}/document/fileSign/{fileID}
+         * @secure
+         */
+        createDocumentFileSign: (sessionId: string, fileId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Get a signed URL to delete a session document
+         *
+         * @tags Session Document
+         * @name DeleteDocumentFileSign
+         * @summary Delete Session Document
+         * @request DELETE:/session/{sessionID}/document/fileSign/{fileID}
+         * @secure
+         */
+        deleteDocumentFileSign: (sessionId: string, fileId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Add a document to a session
+         *
+         * @tags Session Document
+         * @name CreateDocument
+         * @summary Add Session Document
+         * @request POST:/session/{sessionID}/document
+         * @secure
+         */
+        createDocument: (sessionId: string, data: SessionDocumentSchema, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Remove a document from a session
+         *
+         * @tags Session Document
+         * @name DeleteDocument
+         * @summary Delete Session Document
+         * @request DELETE:/session/{sessionID}/document/{fileID}
+         * @secure
+         */
+        deleteDocument: (sessionId: string, fileId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Batch create or update attendances and results for a session
+         *
+         * @tags Session Attendance, Session Result
+         * @name CreateAttendancesResultsBatchUpsert
+         * @summary Batch Upsert Attendances and Results
+         * @request POST:/session/{sessionID}/attendances/results/batchUpsert
+         * @secure
+         */
+        createAttendancesResultsBatchUpsert: (sessionId: string, data: SessionBatchUpdateSchema, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Retrieve user data for a session
+         *
+         * @tags Session
+         * @name GetUserData
+         * @summary Get Session User Data
+         * @request GET:/session/{sessionID}/userData/{userID}/{externalID}
+         * @secure
+         */
+        getUserData: (sessionId: string, userId: string, externalId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description List session events within a time range
+         *
+         * @tags Session
+         * @name ListEvents
+         * @summary List Session Events
+         * @request POST:/session/events/{startTime}/{endTime}
+         * @secure
+         */
+        listEvents: (startTime: string, endTime: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description List session events within a time range filtered by course
+         *
+         * @tags Session
+         * @name ListEvents2
+         * @summary List Session Events By Course
+         * @request POST:/session/events/{startTime}/{endTime}/{courseID}
+         * @originalName listEvents
+         * @duplicate
+         * @secure
+         */
+        listEvents2: (startTime: string, endTime: string, courseId: string, params?: RequestParams) => Promise<any>;
+    };
+    sessions: {
+        /**
+         * @description Assign an instructor to multiple sessions
+         *
+         * @tags Session Instructor
+         * @name CreateInstructor
+         * @summary Set Instructor On Sessions
+         * @request POST:/sessions/instructor/{instructorID}
+         * @secure
+         */
+        createInstructor: (instructorId: string, data: SessionsInstructorSetSchema, params?: RequestParams) => Promise<any>;
+    };
+    customer: {
+        /**
+         * @description List customer-wide session events within a time range
+         *
+         * @tags Session
+         * @name ListSessionEvents
+         * @summary List Customer Session Events
+         * @request POST:/customer/session/events/{startTime}/{endTime}
+         * @secure
+         */
+        listSessionEvents: (startTime: string, endTime: string, params?: RequestParams) => Promise<any>;
+    };
+    reports: {
+        /**
+         * @description Generate enrolments per period report with optional course filter
+         *
+         * @tags Reports
+         * @name CreateEnrolmentsPerPeriod
+         * @summary Enrolments Per Period Report
+         * @request POST:/reports/enrolmentsPerPeriod
+         * @secure
+         */
+        createEnrolmentsPerPeriod: (data: EnrolmentsPerPeriodReportSchema, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Generate session results analysis aggregation report
+         *
+         * @tags Reports
+         * @name ListSessionResultsAnalysis
+         * @summary Session Results Analysis Report
+         * @request POST:/reports/sessionResultsAnalysis
+         * @secure
+         */
+        listSessionResultsAnalysis: (data: SessionResultReportSchema, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Preview session results report without row limit
+         *
+         * @tags Reports
+         * @name CreateSessionResultsPreview
+         * @summary Session Results Preview
+         * @request POST:/reports/sessionResults/preview
+         * @secure
+         */
+        createSessionResultsPreview: (data: SessionResultsReportSchema, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Generate session results report with max rows limit
+         *
+         * @tags Reports
+         * @name ListSessionResults
+         * @summary Session Results Report
+         * @request POST:/reports/sessionResults
+         * @secure
+         */
+        listSessionResults: (data: SessionResultsReportSchema, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Generate session list report
+         *
+         * @tags Reports
+         * @name CreateSessionList
+         * @summary Session List Report
+         * @request POST:/reports/sessionList
+         * @secure
+         */
+        createSessionList: (data: SessionListReportSchema, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Generate Excel charges report for a session
+         *
+         * @tags Reports
+         * @name ListSessionCharges
+         * @summary Session Charges Report
+         * @request POST:/reports/sessionCharges/{sessionID}
+         * @secure
+         */
+        listSessionCharges: (sessionId: string, params?: RequestParams) => Promise<any>;
+        /**
+         * @description Generate Excel shipping manifest report for a session
+         *
+         * @tags Reports
+         * @name CreateSessionShippingManifest
+         * @summary Session Shipping Manifest Report
+         * @request POST:/reports/sessionShippingManifest/{sessionID}
+         * @secure
+         */
+        createSessionShippingManifest: (sessionId: string, params?: RequestParams) => Promise<any>;
+    };
+}