"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
const child_process_1 = require("child_process");
const fs = __importStar(require("fs"));
const path = __importStar(require("path"));
const util = __importStar(require("util"));
const version_1 = require("./version");
// Promisify the exec function to use with async/await
const execPromise = util.promisify(child_process_1.exec);
const buildType = process.argv[2];
const version = process.argv[3];
// Validate build type
if (!buildType) {
    console.error('No build type provided');
    process.exit(1);
}
// Validate version if provided
if (version && !(0, version_1.validateVersion)(version)) {
    console.error(`Invalid version. Must be one of: ${version_1.versions.join(', ')}`);
    process.exit(1);
}
const removeFoldersInDirectory = (directoryPath) => {
    try {
        // Read all items in the directory
        const items = fs.readdirSync(directoryPath);
        items.forEach((item) => {
            const itemPath = path.join(directoryPath, item);
            // Check if the item is a directory
            if (fs.statSync(itemPath).isDirectory()) {
                // Recursively remove the directory
                fs.rmSync(itemPath, { recursive: true, force: true });
                console.log(`Removed folder: ${itemPath}`);
            }
        });
        console.log('All folders removed!');
    }
    catch (error) {
        console.error('Error removing folders:', error);
    }
};
// removes all js files in types/fmschema
const removeJsFilesInTypesFmschema = () => {
    console.log('Removing js files in types/fmschema...');
    const jsFiles = fs.readdirSync('types/fmschema').filter((file) => file.endsWith('.js'));
    jsFiles.forEach((file) => {
        fs.unlinkSync(`types/fmschema/${file}`);
    });
};
const commands = {
    pretty: () => `npx prettier ./types/fmschema/ -w`,
    generateOpenApiFile: (ver) => `node snippets/scripts/generateOpenApiFile.js ${ver}/api-reference/openapi.yml ${ver}`,
    scrape: (ver) => `mintlify-scrape openapi-file ${ver}/api-reference/openapi.yml -o ${ver}/api-reference/`,
    updateMint: (ver) => `node snippets/scripts/updatemint.js ${ver}`,
};
const runCommand = async (command) => {
    try {
        console.log(`Executing: ${command}`);
        const { stdout, stderr } = await execPromise(command);
        if (stderr) {
            console.error(`Command stderr: ${stderr}`);
        }
        console.log(`Command output: ${stdout}`);
    }
    catch (error) {
        console.error(`Failed to execute command: ${command}`, error);
        throw error; // Re-throw to allow caller to handle
    }
};
// Modify buildAll to be async
const buildAll = async (ver) => {
    console.log(`Building all for version ${ver}...`);
    removeFoldersInDirectory(`${ver}/api-reference/`);
    // Use await to ensure sequential execution
    await runCommand(commands.generateOpenApiFile(ver));
    await runCommand(commands.scrape(ver));
    console.log('Scrape complete! Updating mint.json...');
    await runCommand(commands.updateMint(ver));
};
// Main function needs to be async
const main = async () => {
    console.log('Running prettier on fmschema...');
    await runCommand(commands.pretty());
    // Execute the specified build type
    if (buildType === 'all') {
        console.log('🚀 ~ buildType:', buildType);
        if (version) {
            await buildAll(version);
        }
        else {
            console.log('Building all versions...', version_1.versions);
            // Use sequential execution for versions
            for (const ver of version_1.versions) {
                await buildAll(ver);
            }
        }
    }
    else {
        const command = commands[buildType];
        if (command) {
            if (version) {
                console.log(`Running ${buildType} for ${version}...`);
                await runCommand(command(version));
            }
            else {
                // Run for all versions sequentially
                for (const ver of version_1.versions) {
                    console.log(`Running ${buildType} for ${ver}...`);
                    await runCommand(command(ver));
                }
            }
        }
        else {
            console.error(`Unknown build type: ${buildType}`);
            removeJsFilesInTypesFmschema();
            process.exit(1);
        }
    }
    removeJsFilesInTypesFmschema();
};
// Call the main function and handle any unhandled errors
main().catch((error) => {
    console.error('Unhandled error:', error);
    process.exit(1);
});


"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.schemaMapping = void 0;
const Applicant_1 = require("../../types/fmschema/Applicant");
const FeatureSet_1 = require("../../types/fmschema/FeatureSet");
const HsVendor_1 = require("../../types/fmschema/HsVendor");
const Invoice_1 = require("../../types/fmschema/Invoice");
const Order_1 = require("../../types/fmschema/Order");
const OrderItem_1 = require("../../types/fmschema/OrderItem");
const Org_1 = require("../../types/fmschema/Org");
const OrgMonth_1 = require("../../types/fmschema/OrgMonth");
const Payment_1 = require("../../types/fmschema/Payment");
const Person_1 = require("../../types/fmschema/Person");
const Product_1 = require("../../types/fmschema/Product");
const Role_1 = require("../../types/fmschema/Role");
const Staff_1 = require("../../types/fmschema/Staff");
const Tenant_1 = require("../../types/fmschema/Tenant");
const User_1 = require("../../types/fmschema/User");
// Now define your schema mappings with required and optional fields
exports.schemaMapping = {
    Applicant: {
        List: Applicant_1.ZApplicantList,
        Get: Applicant_1.ZApplicantGet,
        Create: Applicant_1.ZApplicantCreate,
        Update: Applicant_1.ZApplicantUpdate,
        Delete: true,
    },
    FeatureSet: {
        List: FeatureSet_1.ZFeatureSetList,
        Get: FeatureSet_1.ZFeatureSetGet,
    },
    HsVendor: {
        List: HsVendor_1.ZHsVendorList,
        Get: HsVendor_1.ZHsVendorGet,
    },
    Invoice: {
        List: Invoice_1.ZInvoiceList,
        Get: Invoice_1.ZInvoiceGet,
        Post: Invoice_1.ZInvoiceQuery,
    },
    Order: {
        List: Order_1.ZOrderList,
        Get: Order_1.ZOrderGet,
        Create: Order_1.ZOrderCreate,
    },
    OrderItem: {
        List: OrderItem_1.ZOrderItemList,
        Get: OrderItem_1.ZOrderItemGet,
    },
    Org: {
        List: Org_1.ZOrgList,
        Get: Org_1.ZOrgGet,
        Create: Org_1.ZOrgCreate,
        Update: Org_1.ZOrgUpdate,
        Delete: true,
    },
    OrgMonth: {
        List: OrgMonth_1.ZOrgMonthList,
        Get: OrgMonth_1.ZOrgMonthGet,
    },
    Payment: {
        List: Payment_1.ZPaymentList,
        Get: Payment_1.ZPaymentGet,
        Create: Payment_1.ZPaymentCreate,
    },
    Person: {
        List: Person_1.ZPersonList,
        Get: Person_1.ZPersonGet,
        Create: Person_1.ZPersonCreate,
        Update: Person_1.ZPersonUpdate,
        Delete: true,
    },
    Product: {
        List: Product_1.ZProductList,
        Get: Product_1.ZProductGet,
    },
    Staff: {
        List: Staff_1.ZStaffList,
        Get: Staff_1.ZStaffGet,
        Create: Staff_1.ZStaffCreate,
        Update: Staff_1.ZStaffUpdate,
        Delete: true,
    },
    Role: {
        List: Role_1.ZRoleList,
        Get: Role_1.ZRoleGet,
    },
    Tenant: {
        List: Tenant_1.ZTenantList,
        Get: Tenant_1.ZTenantGet,
    },
    User: {
        List: User_1.ZUserList,
        Get: User_1.ZUserGet,
        Create: User_1.ZUserCreate,
        Update: User_1.ZUserUpdate,
        Delete: true,
    },
};


"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const zod_to_openapi_1 = require("@asteasolutions/zod-to-openapi");
const fs_1 = require("fs");
const path_1 = __importDefault(require("path"));
const yaml_1 = require("yaml");
const zod_1 = require("zod");
const entities_1 = require("./entities");
(0, zod_to_openapi_1.extendZodWithOpenApi)(zod_1.z);
const args = process.argv.slice(2);
console.log('🚀 ~ args:', args);
const dir = args[0];
const version = args[1]?.split('/')[0] || 'vLatest';
if (!dir) {
    process.exit(1);
}
const registry = new zod_to_openapi_1.OpenAPIRegistry();
// Register definitions here
const idParam = registry.registerParameter('id', zod_1.z.number().openapi('id', {
    param: {
        name: 'id',
        in: 'path',
    },
    description: 'The ID of the entity for this request.',
    example: 5,
}));
// const jwt = registry.registerParameter(
//     'Authorization',
//     z.string().openapi('Authorization', {
//         param: {
//             name: 'Authorization',
//             in: 'header',
//         },
//         description:
//             'Bearer token for authentication. See [Authentication](/v1/api-reference/authentication) for more information.',
//         example: 'Bearer user_2aYj3md8Mmfeh8',
//     }),
// );
const returnFieldsParam = registry.registerParameter('return', zod_1.z
    .string()
    .optional()
    .openapi('return', {
    param: {
        name: 'return',
        in: 'query',
    },
    description: 'Comma-separated list of specific fields to return/append in the response. See `isAdditionalData` for more details.',
    example: 'id,nameFirst,nameLast',
}));
const isAdditionalDataParam = registry.registerParameter('isAdditionalData', zod_1.z
    .boolean()
    .optional()
    .openapi('isAdditionalData', {
    param: {
        name: 'isAdditionalData',
        in: 'query',
    },
    description: 'Set to `true` to merge requested fields with default response, or false/omit to return only requested fields plus `ID`.',
    example: true,
}));
const ZAdvancedFilterItemSchema = zod_1.z
    .object({
    columnField: zod_1.z.string().openapi({
        description: 'Field name to filter by',
        example: 'nameFirst',
    }),
    operatorValue: zod_1.z
        .enum([
        'contains',
        'endsWith',
        'equals',
        'greaterThan',
        'greaterThanOrEqualTo',
        'isEmpty',
        'isFalse',
        'isNotEmpty',
        'isTrue',
        'lessThan',
        'lessThanOrEqualTo',
        'listContains',
        'notEquals',
        'startsWith',
    ])
        .openapi({
        description: 'Operator to use for the filter condition.',
    }),
    value: zod_1.z.string().openapi({
        description: 'Value to filter by.',
        example: 'John',
    }),
})
    .strict();
const ZAdvancedFilterSchema = zod_1.z
    .object({
    linkOperator: zod_1.z.enum(['AND', 'OR']).openapi({
        description: 'Logical operator for combining multiple `items`. Using `AND` will require all conditions to be true. Using `OR` will require at least one condition to be true.',
    }),
    items: ZAdvancedFilterItemSchema.array().openapi({
        description: 'Array of conditions to filter by.',
    }),
})
    .strict();
const QuerySchema = zod_1.z
    .object({
    advancedFilter: ZAdvancedFilterSchema.optional().openapi({
        description: 'Complex filter configuration allowing for multiple conditions with AND/OR operators.',
    }),
    return: zod_1.z
        .array(zod_1.z.string())
        .optional()
        .openapi({
        description: 'Array of field names to return in the response.',
        example: ['id', 'firstName', 'lastName'],
    }),
    isAdditionalData: zod_1.z.boolean().optional().default(false).openapi({
        description: 'Set to `true` to merge requested fields with default response, or false/omit to return only requested fields plus `ID`.',
    }),
    page: zod_1.z.number().optional().openapi({
        description: 'Page number for pagination.',
        example: 1,
        default: 1,
    }),
    pageSize: zod_1.z.number().optional().openapi({
        description: 'Number of items per page. Defaults to 500.',
        example: 20,
        default: 500,
    }),
    sortBy: zod_1.z.string().optional().openapi({
        description: 'Field name to sort by.',
        example: 'createdAt',
    }),
    sortDirection: zod_1.z.enum(['asc', 'desc']).optional().openapi({
        description: 'Sort direction: ascending (asc) or descending (desc).',
        example: 'desc',
        default: 'desc',
    }),
})
    .catchall(zod_1.z.string().openapi({
    description: 'Additional key-value pairs for simple filtering. Any field from the entity can be used as a filter key. E.g., `field=value` will return all records where that field matches the specified value.',
    example: 'status=active',
}));
// Define the full request body schema
const RequestBodySchema = 'RequestBodySchema';
registry.register('RequestBodySchema', QuerySchema.openapi({
    title: 'Query',
    description: 'Multiple query options are supported. You can build a complex query filling out the `advancedFilter` section. We also support "simple" queries which used by putting the key you want to filter by in the `query` section along with the value you want it to filter for. E.g., `nameFirst=John` will return all persons with a first name of John.',
}));
// Add Bearer Authentication Schema
const bearerAuth = registry.registerComponent('securitySchemes', 'bearerAuth', {
    type: 'http',
    scheme: 'bearer',
    bearerFormat: 'JWT',
    description: 'JWT Authorization header using the Bearer scheme. Enter your token in the format "Bearer {token}".',
});
// Loop over each entity and register paths based on available actions
Object.entries(entities_1.schemaMapping).forEach(([entityName, schemas]) => {
    const entityPath = `/glasscore/${entityName.toLowerCase()}`;
    const idPath = `${entityPath}/{id}`;
    // Register LIST path (required)
    registry.registerPath({
        method: 'get',
        tags: [entityName],
        operationId: `List${entityName}`,
        path: `/${version}/action${entityPath}`,
        summary: `List ${entityName}`,
        description: `Retrieve a list of ${entityName}s`,
        // security: [{ bearerAuth: [] }],
        request: {
            query: zod_1.z.object({ return: returnFieldsParam, isAdditionalData: isAdditionalDataParam }),
        },
        responses: {
            200: {
                description: `A list of ${entityName}s`,
                content: {
                    'application/json': { schema: schemas.List },
                },
            },
        },
    });
    // Register QUERY route for complex queries
    if (schemas.List) {
        registry.registerPath({
            method: 'post',
            tags: [entityName],
            operationId: `Query${entityName}`,
            path: `/${version}/query${entityPath}`,
            summary: `Query ${entityName}`,
            description: `Retrieve a list of ${entityName}s with a complex or simple query.`,
            // security: [{ bearerAuth: [] }],
            request: {
                body: {
                    content: {
                        'application/json': {
                            schema: {
                                $ref: `#/components/schemas/${RequestBodySchema}`,
                            },
                        },
                    },
                },
            },
            responses: {
                200: {
                    description: `A list of ${entityName}s`,
                    content: { 'application/json': { schema: schemas.List } },
                },
            },
        });
    }
    // Register GET path (required)
    registry.registerPath({
        method: 'get',
        tags: [entityName],
        operationId: `Get${entityName}`,
        path: `/${version}/action${idPath}`,
        summary: `Get ${entityName}`,
        description: `Retrieve a ${entityName} by ID`,
        // security: [{ bearerAuth: [] }],
        request: {
            params: zod_1.z.object({ id: idParam }),
            query: zod_1.z.object({ return: returnFieldsParam, isAdditionalData: isAdditionalDataParam }),
        },
        responses: {
            200: {
                description: entityName,
                content: {
                    'application/json': { schema: schemas.Get },
                },
            },
        },
    });
    // Register CREATE path (optional)
    if (schemas.Create) {
        registry.registerPath({
            method: 'post',
            tags: [entityName],
            operationId: `Create${entityName}`,
            path: `/${version}/action${entityPath}`,
            summary: `Create ${entityName}`,
            description: `Create a new ${entityName}`,
            // security: [{ bearerAuth: [] }],
            request: {
                body: {
                    content: {
                        'application/json': { schema: schemas.Create },
                    },
                },
            },
            responses: { 200: { description: entityName } },
        });
    }
    // Register UPDATE path (optional)
    if (schemas.Update) {
        registry.registerPath({
            method: 'patch',
            tags: [entityName],
            operationId: `Update${entityName}`,
            path: `/${version}/action${idPath}`,
            summary: `Update ${entityName}`,
            description: `Update an existing ${entityName}`,
            // security: [{ bearerAuth: [] }],
            request: {
                params: zod_1.z.object({ id: idParam }),
                body: {
                    content: {
                        'application/json': { schema: schemas.Update },
                    },
                },
            },
            responses: {
                200: {
                    description: `Updated ${entityName}`,
                    content: {
                        'application/json': { schema: schemas.Get },
                    },
                },
            },
        });
    }
    // Register DELETE path (optional)
    if (schemas.Delete) {
        registry.registerPath({
            method: 'delete',
            tags: [entityName],
            operationId: `Delete${entityName}`,
            path: `/${version}/action${idPath}`,
            summary: `Delete ${entityName}`,
            description: `Permanently delete a ${entityName} from your account`,
            // security: [{ bearerAuth: [] }],
            request: {
                params: zod_1.z.object({ id: idParam }),
            },
            responses: { 200: { description: 'Ok' } },
        });
    }
});
function getOpenApiDocumentation(version) {
    const generator = new zod_to_openapi_1.OpenApiGeneratorV3(registry.definitions);
    return generator.generateDocument({
        openapi: '3.1.0',
        info: {
            version: '2.0.0',
            title: 'Health Street API',
            description: 'The Health Street API provides secure and reliable endpoints to manage drug tests, background checks, DNA checks, and occupational health tests.',
        },
        servers: [{ url: `https://api.glass.fm` }],
    });
}
function writeDocumentation() {
    // OpenAPI JSON
    const docs = getOpenApiDocumentation(version);
    // YAML equivalent
    const fileContent = (0, yaml_1.stringify)(docs);
    if (!dir) {
        throw new Error('No directory provided');
    }
    const dirPath = path_1.default.dirname(dir);
    (0, fs_1.mkdirSync)(dirPath, { recursive: true });
    (0, fs_1.writeFileSync)(dir, fileContent, {
        encoding: 'utf-8',
    });
}
writeDocumentation();


"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    var desc = Object.getOwnPropertyDescriptor(m, k);
    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
      desc = { enumerable: true, get: function() { return m[k]; } };
    }
    Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
    if (k2 === undefined) k2 = k;
    o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
    Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
    o["default"] = v;
});
var __importStar = (this && this.__importStar) || function (mod) {
    if (mod && mod.__esModule) return mod;
    var result = {};
    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
    __setModuleDefault(result, mod);
    return result;
};
Object.defineProperty(exports, "__esModule", { value: true });
const fs = __importStar(require("fs"));
const path = __importStar(require("path"));
// Get version from command line args (e.g., "v1" or "vLatest")
const version = process.argv[2];
if (!version) {
    console.error('No version provided');
    process.exit(1);
}
const apiReferencePath = path.join(process.cwd(), version, 'api-reference');
const mintJsonPath = path.join(process.cwd(), 'mint.json');
/**
 * Scans the api-reference directory and creates a navigation structure
 * Returns an array of groups, where each group represents a folder (Invoice, Order, etc.)
 * with its associated MDX files as pages
 */
const getNavigationStructure = (dir) => {
    // Get all directories (each represents an API group like Invoice, Order, etc.)
    const folders = fs.readdirSync(dir).filter((file) => {
        return fs.statSync(path.join(dir, file)).isDirectory();
    });
    const folderToCamelCase = (folder) => {
        switch (folder.toLowerCase()) {
            case 'applicant':
                return 'Applicant';
            case 'featureset':
                return 'FeatureSet';
            case 'hsvendor':
                return 'HsVendor';
            case 'invoice':
                return 'Invoice';
            case 'order':
                return 'Order';
            case 'orderitem':
                return 'OrderItem';
            case 'org':
                return 'Org';
            case 'org':
                return 'Org';
            case 'orgmonth':
                return 'OrgMonth';
            case 'payment':
                return 'Payment';
            case 'person':
                return 'Person';
            case 'product':
                return 'Product';
            case 'role':
                return 'Role';
            case 'staff':
                return 'Staff';
            case 'tenant':
                return 'Tenant';
            case 'user':
                return 'User';
        }
    };
    return folders.map((folder) => {
        const folderPath = path.join(dir, folder);
        // Get all MDX files within each folder
        const files = fs.readdirSync(folderPath).filter((file) => {
            return fs.statSync(path.join(folderPath, file)).isFile() && path.extname(file) === '.mdx';
        });
        // Convert file paths to the format expected by mint.json
        const pages = files.map((file) => `/${path
            .relative(process.cwd(), path.join(folderPath, file))
            .replace(/\\/g, '/')
            .replace('.mdx', '')}`);
        // Create a group object with version tag for proper versioning support
        return {
            group: folderToCamelCase(folder),
            version: version,
            pages: pages,
        };
    });
};
const updateMintJson = () => {
    const mintJson = JSON.parse(fs.readFileSync(mintJsonPath, 'utf8'));
    const apiPages = getNavigationStructure(apiReferencePath);
    if (apiPages.length > 0) {
        // Find the "API Endpoints" section with matching version
        const navigationIndex = mintJson.navigation.findIndex((section) => section.group === 'API Endpoints' && section.version === version);
        if (navigationIndex !== -1) {
            // Update existing versioned API Endpoints section
            mintJson.navigation[navigationIndex].pages = apiPages;
        }
        else {
            // Create new versioned API Endpoints section
            mintJson.navigation.push({
                group: 'API Endpoints',
                version: version,
                pages: apiPages,
            });
        }
    }
    fs.writeFileSync(mintJsonPath, JSON.stringify(mintJson, null, 4));
    console.log(`mint.json navigation updated successfully for version ${version}.`);
};
// Run the script
updateMintJson();


"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.validateVersion = exports.versions = void 0;
exports.versions = ['vLatest', 'v2'];
const validateVersion = (version) => {
    return exports.versions.includes(version);
};
exports.validateVersion = validateVersion;


List FeatureSet

Health Street Documentation

Web App

Blog

Introduction

API Reference

Support

Changelog

App Dashboard

Contact Support

vLatest

Discover the Health Street API designed for seamless integration, high performance, and scalability. Get started with comprehensive documentation, authentication details, and best practices for building with our API.

Stay up to date with the latest updates, improvements, and fixes to our API. Check out our changelog for new features, enhancements, and important changes that keep our API efficient and developer-friendly.

Frequently Asked Questions

Need help or have questions? Contact our support team for API assistance, technical inquiries, and integration support. Get fast and reliable help to ensure seamless API implementation.

Contact Us

Learn how to access our API with secure authentication methods, API keys, and best practices. Get started quickly with step-by-step guidance on authentication, rate limits, and request handling.

Accessing the API

Learn best practices for managing authentication, securing requests, and maintaining seamless API access for your integration.

Using the API

API Endpoints

List FeatureSet

Query Parameters

Response