quickbase-js 0.1.0-beta.7

package/tools/log-gen.yaml

@@ -0,0 +1,3826 @@
+project: >-
+  quickbase-js
+date: >-
+  3/16/2025
+root: >-
+  /home/drew/Projects/quickbase-js
+goals:
+  - >-
+    A
+    library
+    for
+    interacting
+    with
+    the
+    QuickBase
+    RESTful
+    API.
+  - >-
+    Use
+    OpenAPI
+    to
+    generate
+    types
+    and
+    methods
+    using
+    a
+    proxy.
+    Validate
+    with
+    tests.
+  - >-
+    Provide
+    robust
+    and
+    intuitive
+    temporary
+    token
+    support
+    for
+    browser
+    environments.
+  - >-
+    User
+    Tokens
+    support
+    both
+    Node.js
+    and
+    browser
+    environments.
+  - >-
+    Use
+    case:
+    JS
+    frameworks
+    like
+    React,
+    Vue,
+    and
+    Angular
+    hosted
+    in
+    QuickBase
+    code
+    pages.
+  - >-
+    Enable
+    a
+    flexible
+    or
+    native
+    fetch
+    in
+    the
+    browser.
+  - >-
+    Enable
+    a
+    flexible
+    fetch
+    framework
+    in
+    Node.js.
+  - >-
+    #
+  - >-
+    No
+    manual
+    updating
+    methods
+    when
+    the
+    QuickBase
+    API
+    changes.
+  - >-
+    The
+    proxy
+    magic
+    dynamically
+    maps
+    generated
+    methods
+    and
+    types.
+  - >-
+    #
+  - >-
+    TokenCache
+    is
+    defined
+    per
+    quickbaseClient
+    call,
+    so
+    each
+    instance
+    has
+    its
+    own
+    isolated
+    TokenCache.
+  - >-
+    Each
+    quickbase
+    client
+    instance
+    has
+    an
+    isolated
+    and
+    individual
+    token
+    cache.
+pipelineOverview:
+  - >-
+    What
+    I’m
+    Trying
+    to
+    Do
+  - >-
+    My
+    approach
+    is
+    to
+    ensure
+    AppsApi.ts
+    is
+    generated
+    with
+    getAppById
+    so
+    QuickbaseClient.ts
+    can
+    map
+    it
+    to
+    client.getApp.
+    Steps
+    include:
+  - >-
+    Fix
+    fix-spec.ts:
+  - >-
+    Add
+    tags:
+    ["Apps"]
+    to
+    /apps/*
+    endpoints
+    to
+    group
+    them
+    into
+    AppsApi.ts.
+  - >-
+    Ensure
+    all
+    endpoints
+    and
+    models
+    are
+    correctly
+    defined
+    and
+    typed.
+  - >-
+    Debug
+    regenerate-client.ts:
+  - >-
+    Enhance
+    logging
+    to
+    catch
+    why
+    AppsApi.ts
+    isn’t
+    generated.
+  - >-
+    Test
+    if
+    getAppById
+    appears
+    in
+    another
+    file
+    (e.g.,
+    DefaultApi.ts).
+  - >-
+    Update
+    QuickbaseClient.ts:
+  - >-
+    Adjust
+    imports
+    to
+    use
+    the
+    correct
+    API
+    class
+    once
+    generated.
+  - >-
+    Test
+    and
+    Iterate:
+  - >-
+    Run
+    npm
+    run
+    fix-spec,
+    npm
+    run
+    regenerate,
+    and
+    npm
+    run
+    test
+    to
+    verify
+    AppsApi.ts
+    exists
+    and
+    test.ts
+    works.
+  - >-
+    The
+    latest
+    fix-spec.ts
+    with
+    tags
+    aims
+    to
+    force
+    the
+    generator
+    to
+    create
+    AppsApi.ts,
+    addressing
+    the
+    missing
+    file
+    issue.
+  - >-
+    Relevant
+    Project
+    Files
+  - >-
+    Here’s
+    a
+    list
+    of
+    files
+    that
+    would
+    help
+    understand
+    and
+    resolve
+    this
+    problem,
+    along
+    with
+    their
+    roles:
+  - >-
+    src/code-generation/fix-spec.ts:
+  - >-
+    Role:
+    Modifies
+    the
+    original
+    QuickBase
+    spec
+    (e.g.,
+    QuickBase_RESTful_*.json)
+    to
+    create
+    quickbase-fixed.json
+    with
+    required
+    endpoints
+    (e.g.,
+    /apps/{appId}).
+  - >-
+    Relevance:
+    Defines
+    the
+    spec
+    fed
+    to
+    the
+    generator;
+    errors
+    here
+    affect
+    generation.
+  - >-
+    src/code-generation/quickbase-fixed.json:
+  - >-
+    Role:
+    The
+    processed
+    OpenAPI
+    spec
+    used
+    by
+    regenerate-client.ts
+    to
+    generate
+    code.
+  - >-
+    Relevance:
+    Confirms
+    if
+    /apps/{appId}
+    is
+    correctly
+    structured
+    with
+    operationId:
+    "getAppById".
+  - >-
+    src/code-generation/regenerate-client.ts:
+  - >-
+    Role:
+    Runs
+    OpenAPI
+    Generator
+    to
+    produce
+    src/generated/
+    files
+    (APIs
+    and
+    models)
+    and
+    fixes
+    .ts
+    extensions
+    with
+    ts-morph.
+  - >-
+    Relevance:
+    Controls
+    the
+    generation
+    process;
+    logs
+    reveal
+    why
+    AppsApi.ts
+    is
+    missing.
+  - >-
+    src/generated/apis/AppsApi.ts
+    (if
+    exists):
+  - >-
+    Role:
+    Should
+    contain
+    getAppById
+    method
+    for
+    /apps/{appId}
+    GET.
+  - >-
+    Relevance:
+    Missing
+    file
+    is
+    the
+    core
+    issue;
+    its
+    absence
+    breaks
+    QuickbaseClient.ts.
+  - >-
+    src/generated/apis/DefaultApi.ts:
+  - >-
+    Role:
+    Default
+    API
+    class
+    for
+    untagged
+    operations.
+  - >-
+    Relevance:
+    Might
+    contain
+    getAppById
+    if
+    tags
+    are
+    misconfigured.
+  - >-
+    src/QuickbaseClient.ts:
+  - >-
+    Role:
+    Wraps
+    generated
+    API
+    classes
+    (e.g.,
+    AppsApi)
+    in
+    a
+    Proxy
+    for
+    ergonomic
+    calls
+    (e.g.,
+    client.getApp).
+  - >-
+    Relevance:
+    Fails
+    to
+    import
+    AppsApi.ts,
+    causing
+    the
+    runtime
+    error.
+  - >-
+    src/test.ts:
+  - >-
+    Role:
+    Test
+    script
+    calling
+    client.getApp({
+    appId
+    }).
+  - >-
+    Relevance:
+    Final
+    validation
+    point;
+    shows
+    if
+    the
+    fix
+    works.
+  - >-
+    .env.development:
+  - >-
+    Role:
+    Stores
+    QB_REALM,
+    QB_USER_TOKEN,
+    QB_APP_ID
+    for
+    API
+    authentication.
+  - >-
+    Relevance:
+    Ensures
+    the
+    API
+    call
+    has
+    valid
+    credentials
+    (not
+    the
+    current
+    issue,
+    but
+    critical
+    for
+    success).
+  - >-
+    src/specs/QuickBase_RESTful_API_2025-03-04T06_22_39.725Z.json
+    (or
+    similar):
+  - >-
+    Role:
+    Original
+    QuickBase
+    API
+    spec
+    before
+    fix-spec.ts
+    processing.
+  - >-
+    Relevance:
+    Shows
+    how
+    /apps/{appId}
+    was
+    originally
+    defined,
+    helping
+    identify
+    conflicts.
+  - >-
+    package.json:
+  - >-
+    Role:
+    Defines
+    scripts
+    (fix-spec,
+    regenerate,
+    test)
+    and
+    dependencies
+    (e.g.,
+    ts-node,
+    openapi-generator-cli).
+  - >-
+    Relevance:
+    Confirms
+    script
+    commands
+    and
+    versions
+    align
+    with
+    our
+    process.
+  - >-
+    What
+    We
+    Achieved
+  - >-
+    Goal
+    Met:
+    You
+    can
+    now
+    call
+    client.getApp({
+    appId:
+    "buwai2zpe"
+    })
+    and
+    get
+    the
+    app
+    details
+    {
+    id:
+    'buwai2zpe',
+    name:
+    'qb-copy'
+    }.
+  - >-
+    Fixes
+    Applied:
+  - >-
+    Added
+    tags:
+    ["Apps"]
+    in
+    fix-spec.ts
+    to
+    ensure
+    AppsApi.ts
+    is
+    generated
+    with
+    getAppById.
+  - >-
+    Updated
+    QuickbaseClient.ts
+    to:
+  - >-
+    Use
+    prototype
+    methods
+    via
+    Object.getOwnPropertyNames.
+  - >-
+    Bind
+    methods
+    to
+    preserve
+    context
+    with
+    .bind(api).
+  - >-
+    Handle
+    getAppById’s
+    direct
+    JSON
+    return
+    instead
+    of
+    a
+    Response
+    object.
+  - >-
+    Result:
+    The
+    ergonomic
+    API
+    you
+    wanted
+    (client.getApp)
+    works
+    seamlessly
+    with
+    the
+    generated
+    AppsApi.ts.
+  - >-
+    Why
+    It
+    Works
+    Now
+  - >-
+    fix-spec.ts:
+  - >-
+    Correctly
+    defined
+    /apps/{appId}
+    with
+    operationId:
+    "getAppById"
+    and
+    tags:
+    ["Apps"],
+    ensuring
+    AppsApi.ts
+    generation.
+  - >-
+    regenerate-client.ts:
+  - >-
+    Successfully
+    ran
+    OpenAPI
+    Generator
+    to
+    produce
+    AppsApi.ts
+    with
+    getAppById.
+  - >-
+    QuickbaseClient.ts:
+  - >-
+    buildMethodMap
+    now
+    captures
+    getAppById
+    and
+    maps
+    it
+    to
+    getApp.
+  - >-
+    invokeMethod
+    passes
+    {
+    appId:
+    'buwai2zpe'
+    }
+    as
+    requestParameters
+    and
+    handles
+    the
+    JSON
+    response
+    directly.
+  - >-
+    test.ts:
+  - >-
+    Calls
+    client.getApp
+    and
+    logs
+    the
+    result,
+    proving
+    the
+    end-to-end
+    flow.
+tree:
+  name: >-
+    .
+  type: >-
+    directory
+  children:
+    - name: >-
+        .env
+      type: >-
+        file
+    - name: >-
+        .gitignore
+      type: >-
+        file
+    - name: >-
+        CHANGELOG.md
+      type: >-
+        file
+    - name: >-
+        LICENSE
+      type: >-
+        file
+    - name: >-
+        README.md
+      type: >-
+        file
+    - name: >-
+        build-common.js
+      type: >-
+        file
+    - name: >-
+        build-esm.js
+      type: >-
+        file
+    - name: >-
+        build-umd.js
+      type: >-
+        file
+    - name: >-
+        debug.log
+      type: >-
+        file
+    - name: >-
+        dist
+      type: >-
+        directory
+      children:
+        - name: >-
+            esm
+          type: >-
+            directory
+          children:
+            - name: >-
+                quickbase.d.ts
+              type: >-
+                file
+            - name: >-
+                quickbase.js
+              type: >-
+                file
+            - name: >-
+                quickbase.js.map
+              type: >-
+                file
+            - name: >-
+                quickbase.min.js
+              type: >-
+                file
+            - name: >-
+                quickbase.min.js.map
+              type: >-
+                file
+        - name: >-
+            umd
+          type: >-
+            directory
+          children:
+            - name: >-
+                quickbase.umd.js
+              type: >-
+                file
+            - name: >-
+                quickbase.umd.js.map
+              type: >-
+                file
+            - name: >-
+                quickbase.umd.min.js
+              type: >-
+                file
+            - name: >-
+                quickbase.umd.min.js.map
+              type: >-
+                file
+    - name: >-
+        examples
+      type: >-
+        directory
+      children:
+        - name: >-
+            quicbase-jsCDN.html
+          type: >-
+            file
+        - name: >-
+            react.js
+          type: >-
+            file
+        - name: >-
+            vanillajs.html
+          type: >-
+            file
+    - name: >-
+        gen-no-overrides.log
+      type: >-
+        file
+    - name: >-
+        notes.txt
+      type: >-
+        file
+    - name: >-
+        open-api
+      type: >-
+        directory
+      children:
+        - name: >-
+            fix-spec-main.ts
+          type: >-
+            file
+          contents: >
+            #!/usr/bin/env
+            node
+
+
+            import
+            {
+            promises
+            as
+            fs
+            }
+            from
+            "fs";
+
+            import
+            path
+            from
+            "path";
+
+            import
+            {
+            fileURLToPath
+            }
+            from
+            "url";
+
+            import
+            *
+            as
+            glob
+            from
+            "glob";
+
+            import
+            {
+            enhanceTags
+            }
+            from
+            "./schema/tags/index.ts";
+
+            import
+            {
+            enhanceGeneral
+            }
+            from
+            "./schema/enhance-general.ts";
+
+            import
+            {
+            fixArrays
+            }
+            from
+            "./schema/fix-arrays.ts";
+
+            import
+            {
+            Spec
+            }
+            from
+            "./types/spec.ts";
+
+            import
+            {
+            toCamelCase
+            }
+            from
+            "./utils/naming.ts";
+
+
+            //
+            Removed
+            FixSpecConfig
+            since
+            applyOverrides
+            is
+            no
+            longer
+            needed
+
+            async
+            function
+            fixQuickBaseSpec():
+            Promise<void>
+            {
+              try {
+                const CODEGEN_DIR = path.dirname(fileURLToPath(import.meta.url));
+                const SPECS_DIR = path.join(CODEGEN_DIR, "..", "specs");
+                const OUTPUT_DIR = path.join(CODEGEN_DIR, "output");
+                console.log("Finding latest QuickBase RESTful API spec...");
+                const specFiles = glob.sync(
+                  path.join(SPECS_DIR, "QuickBase_RESTful_*.json")
+                );
+                if (specFiles.length === 0) {
+                  throw new Error(
+                    "No QuickBase_RESTful_*.json files found in specs/ folder."
+                  );
+                }
+                const inputFile = specFiles.sort().pop() as string;
+                const outputFile = path.join(OUTPUT_DIR, "quickbase-fixed.json");
+
+                console.log(`Reading ${path.basename(inputFile)} from specs/...`);
+                const specContent = await fs.readFile(inputFile, "utf8");
+                const spec: Spec = JSON.parse(specContent);
+
+                console.log("Fixing parameters...");
+                for (const pathKey in spec.paths) {
+                  for (const method in spec.paths[pathKey]) {
+                    const operation = spec.paths[pathKey][method];
+                    if (operation.parameters) {
+                      operation.parameters = operation.parameters
+                        .filter(
+                          (param) =>
+                            !["QB-Realm-Hostname", "Authorization", "User-Agent"].includes(
+                              param.name
+                            )
+                        )
+                        .map((param) => {
+                          param.name = toCamelCase(param.name);
+                          if ("example" in param) delete param.example;
+                          if ("schema" in param && param.in !== "body") delete param.schema;
+                          if (!param.type && param.in !== "body") {
+                            param.type = param.name.includes("Id") ? "string" : "string";
+                            console.log(
+                              `Set default type 'string' for ${pathKey}(${method}).${param.name} in initial pass`
+                            );
+                          }
+                          return param;
+                        });
+                    }
+                  }
+                }
+
+                // Removed applyOverrides conditional logic
+                console.log("Enhancing raw spec with tags...");
+                enhanceTags(spec);
+                console.log("Enhancing raw spec with general enhancements...");
+                enhanceGeneral(spec);
+
+                console.log("Fixing array schemas...");
+                fixArrays(spec);
+
+                console.log("Removing unexpected top-level attributes...");
+                delete spec.operations;
+                delete spec.groups;
+                delete spec.components;
+
+                console.log(`Writing fixed spec to ${path.basename(outputFile)}...`);
+                await fs.mkdir(OUTPUT_DIR, { recursive: true });
+                await fs.writeFile(outputFile, JSON.stringify(spec, null, 2), "utf8");
+                console.log("Spec fixed successfully! Output written to:", outputFile);
+              } catch (error) {
+                console.error("Failed to fix spec:", error);
+                process.exit(1);
+              }
+            }
+
+
+            async
+            function
+            main()
+            {
+              try {
+                await fixQuickBaseSpec();
+              } catch (error) {
+                console.error("Fatal error in script execution:", error);
+                process.exit(1);
+              }
+            }
+
+
+            main();
+        - name: >-
+            generate-unified-interface.ts
+          type: >-
+            file
+          contents: >
+            //
+            open-api/generate-unified-interface.ts
+
+
+            import
+            {
+              readFileSync,
+              writeFileSync,
+              mkdirSync,
+              existsSync,
+              readdirSync,
+            }
+            from
+            "fs";
+
+            import
+            {
+            join,
+            dirname
+            }
+            from
+            "path";
+
+            import
+            {
+            fileURLToPath
+            }
+            from
+            "url";
+
+            import
+            {
+            OpenAPIV2
+            }
+            from
+            "openapi-types";
+
+            import
+            {
+            simplifyName
+            }
+            from
+            "../src/utils.ts";
+
+
+            const
+            __dirname
+            =
+            dirname(fileURLToPath(import.meta.url));
+
+            const
+            SPEC_FILE
+            =
+            join(__dirname,
+            "output",
+            "quickbase-fixed.json");
+
+            const
+            OUTPUT_DIR
+            =
+            join(__dirname,
+            "..",
+            "src",
+            "generated-unified");
+
+            const
+            OUTPUT_FILE
+            =
+            join(OUTPUT_DIR,
+            "QuickbaseClient.ts");
+
+            const
+            MODELS_DIR
+            =
+            join(__dirname,
+            "..",
+            "src",
+            "generated",
+            "models");
+
+
+            function
+            mapOpenApiTypeToTs(
+              openApiType: string | string[] | undefined
+            ):
+            string
+            {
+              const type = Array.isArray(openApiType)
+                ? openApiType[0]
+                : openApiType || "any";
+              switch (type.toLowerCase()) {
+                case "integer":
+                case "int":
+                case "number":
+                  return "number";
+                case "string":
+                  return "string";
+                case "boolean":
+                  return "boolean";
+                default:
+                  return "any";
+              }
+            }
+
+
+            function
+            mapRefToType(
+              schema: OpenAPIV2.SchemaObject | OpenAPIV2.ReferenceObject | undefined,
+              modelImports: Set<string>,
+              spec: OpenAPIV2.Document,
+              depth: number = 0,
+              availableModels: string[],
+              missingTypes: Set<string>
+            ):
+            string
+            {
+              if (!schema) return "any";
+
+              if ("$ref" in schema && schema.$ref) {
+                const refParts = schema.$ref.split("/");
+                const model = refParts[refParts.length - 1];
+                const pascalModel = model.charAt(0).toUpperCase() + model.slice(1);
+                const camelModel = model.charAt(0).toLowerCase() + model.slice(1);
+                if (availableModels.includes(pascalModel)) {
+                  modelImports.add(pascalModel);
+                  return pascalModel;
+                } else if (availableModels.includes(camelModel)) {
+                  modelImports.add(camelModel);
+                  return camelModel;
+                }
+                missingTypes.add(pascalModel);
+                console.warn(
+                  `Type ${pascalModel} not found in /generated/models, defaulting to 'any'`
+                );
+                return "any";
+              }
+
+              if ("type" in schema) {
+                if (schema.type === "object" && schema.properties) {
+                  const props = schema.properties;
+                  if (props.data && props.data.format === "binary") {
+                    return "ArrayBuffer"; // Map binary object to ArrayBuffer
+                  }
+                  if (props.content && props.content.format === "yaml") {
+                    return "string"; // Map YAML object to string
+                  }
+                  const propTypes = Object.entries(props).map(([key, prop]) => {
+                    const propSchema = prop as OpenAPIV2.SchemaObject;
+                    const propType = mapRefToType(
+                      propSchema,
+                      modelImports,
+                      spec,
+                      depth + 1,
+                      availableModels,
+                      missingTypes
+                    );
+                    return `${key}${propSchema.required ? "" : "?"}: ${propType}`;
+                  });
+                  return `{ ${propTypes.join("; ")} }`;
+                }
+                if (schema.type === "array" && schema.items) {
+                  const items = schema.items as
+                    | OpenAPIV2.SchemaObject
+                    | OpenAPIV2.ReferenceObject;
+                  const itemType = mapRefToType(
+                    items,
+                    modelImports,
+                    spec,
+                    depth + 1,
+                    availableModels,
+                    missingTypes
+                  );
+                  return `${itemType}[]`;
+                }
+                if (schema.type === "object" && schema.additionalProperties) {
+                  const additionalProps = schema.additionalProperties as
+                    | OpenAPIV2.SchemaObject
+                    | OpenAPIV2.ReferenceObject
+                    | boolean;
+                  if (typeof additionalProps === "boolean") {
+                    return "{ [key: string]: any }";
+                  }
+                  const valueType = mapRefToType(
+                    additionalProps,
+                    modelImports,
+                    spec,
+                    depth + 1,
+                    availableModels,
+                    missingTypes
+                  );
+                  return `{ [key: string]: ${valueType} }`;
+                }
+                return mapOpenApiTypeToTs(schema.type);
+              }
+
+              return "any";
+            }
+
+
+            function
+            generateInterface()
+            {
+              if (!existsSync(SPEC_FILE)) {
+                console.error(
+                  `Spec file ${SPEC_FILE} not found. Run 'npm run fix-spec' first.`
+                );
+                process.exit(1);
+              }
+
+              console.log("Generating unified QuickbaseClient interface...");
+              const spec = JSON.parse(
+                readFileSync(SPEC_FILE, "utf8")
+              ) as OpenAPIV2.Document;
+              const { paths } = spec;
+
+              const availableModels = readdirSync(MODELS_DIR)
+                .filter((file) => file.endsWith(".ts") && !file.startsWith("index"))
+                .map((file) => file.replace(".ts", ""));
+              console.log("Available models:", availableModels);
+
+              const modelImports = new Set<string>();
+              const missingTypes = new Set<string>();
+              const methods: string[] = [];
+
+              for (const [path, methodsObj] of Object.entries(
+                paths as OpenAPIV2.PathsObject
+              )) {
+                if (!methodsObj) continue;
+
+                for (const [method, operation] of Object.entries(
+                  methodsObj as OpenAPIV2.PathItemObject
+                )) {
+                  const op = operation as OpenAPIV2.OperationObject | undefined;
+                  if (!op || !op.operationId) continue;
+
+                  const opId = simplifyName(op.operationId);
+                  const summary = op.summary || "No description available.";
+                  const params = (op.parameters || [])
+                    .filter((p) => {
+                      const param = p as OpenAPIV2.Parameter;
+                      return !["QB-Realm-Hostname", "Authorization", "User-Agent"].includes(
+                        "name" in param ? param.name : ""
+                      );
+                    })
+                    .map((param: OpenAPIV2.Parameter) => {
+                      if (!("name" in param)) return "";
+                      let type: string;
+                      if ("schema" in param && param.schema) {
+                        type = mapRefToType(
+                          param.schema,
+                          modelImports,
+                          spec,
+                          1,
+                          availableModels,
+                          missingTypes
+                        );
+                      } else if ("type" in param && param.type) {
+                        type = mapOpenApiTypeToTs(param.type);
+                      } else {
+                        console.warn(
+                          `Parameter ${param.name} in ${opId} has no type or schema, defaulting to 'any'`
+                        );
+                        type = "any";
+                      }
+                      const paramName = param.in === "body" ? "body" : param.name;
+                      return `${paramName}${param.required ? "" : "?"}: ${type}`;
+                    })
+                    .filter((param) => param !== "")
+                    .join("; ");
+
+                  const successResponses = ["200", "207"]
+                    .map((code) => ({
+                      code,
+                      response: op.responses?.[code] as
+                        | OpenAPIV2.ResponseObject
+                        | undefined,
+                    }))
+                    .filter(({ response }) => response?.schema);
+                  const returnTypes = successResponses.map(({ response }) =>
+                    mapRefToType(
+                      response!.schema,
+                      modelImports,
+                      spec,
+                      1,
+                      availableModels,
+                      missingTypes
+                    )
+                  );
+                  const uniqueReturnTypes = [...new Set(returnTypes)];
+                  const returnType =
+                    uniqueReturnTypes.length > 1
+                      ? uniqueReturnTypes.join(" | ")
+                      : uniqueReturnTypes[0] || "void";
+
+                  const jsDoc = [
+                    `  /**`,
+                    `   * ${summary}`,
+                    `   * @param params - Parameters for the ${opId} operation`,
+                    `   * @returns A promise resolving to the ${opId} response`,
+                    `   */`,
+                  ].join("\n");
+
+                  methods.push(
+                    `${jsDoc}\n  ${opId}: (params: { ${params} }) => Promise<${returnType}>;`
+                  );
+                }
+              }
+
+              // Always write the missing-types-report.json to reflect the current state
+              if (missingTypes.size > 0) {
+                console.log(
+                  "Missing types detected (defaulted to 'any'):",
+                  Array.from(missingTypes)
+                );
+              } else {
+                console.log("No missing types detected.");
+              }
+              writeFileSync(
+                join(OUTPUT_DIR, "missing-types-report.json"),
+                JSON.stringify({ missingTypes: Array.from(missingTypes) }, null, 2)
+              );
+              console.log("Missing types report saved to missing-types-report.json");
+
+              const importStatement =
+                modelImports.size > 0
+                  ? `import { ${Array.from(modelImports)
+                      .sort()
+                      .join(", ")} } from "../generated/models";`
+                  : "";
+              console.log(`Imports: ${Array.from(modelImports).join(", ")}`);
+
+              const interfaceContent = `// Generated on ${new Date().toISOString()}\n${importStatement}\n\nexport interface QuickbaseClient {\n${methods.join(
+                "\n"
+              )}\n}\n`;
+
+              if (!existsSync(OUTPUT_DIR)) {
+                mkdirSync(OUTPUT_DIR, { recursive: true });
+              }
+              writeFileSync(OUTPUT_FILE, interfaceContent, "utf8");
+              console.log(`Generated ${OUTPUT_FILE}`);
+            }
+
+
+            try
+            {
+              generateInterface();
+            }
+            catch
+            (error)
+            {
+              console.error("Generation failed:", error);
+              process.exit(1);
+            }
+        - name: >-
+            regenerate-client.ts
+          type: >-
+            file
+          contents: >
+            #!/usr/bin/env
+            node
+
+            import
+            {
+            execSync
+            }
+            from
+            "child_process";
+
+            import
+            {
+            existsSync
+            }
+            from
+            "fs";
+
+            import
+            {
+            join
+            }
+            from
+            "path";
+
+            import
+            {
+            fileURLToPath
+            }
+            from
+            "url";
+
+            import
+            fetch
+            from
+            "node-fetch";
+
+            import
+            readline
+            from
+            "readline";
+
+
+            const
+            CURRENT_JAR_VERSION
+            =
+            "7.12.0";
+
+            const
+            MAVEN_METADATA_URL
+            =
+              "https://repo1.maven.org/maven2/org/openapitools/openapi-generator-cli/maven-metadata.xml";
+            const
+            CODEGEN_DIR
+            =
+            join(fileURLToPath(import.meta.url),
+            "..");
+            //
+            open-api/
+
+            const
+            JARS_DIR
+            =
+            join(CODEGEN_DIR,
+            "..",
+            "tools",
+            "openapi-jars");
+            //
+            Updated
+            to
+            tools/openapi-jars/
+
+            const
+            SPEC_INPUT
+            =
+            join(CODEGEN_DIR,
+            "output",
+            "quickbase-fixed.json");
+            //
+            Relative
+            to
+            open-api/
+
+            const
+            OUTPUT_DIR
+            =
+            join(CODEGEN_DIR,
+            "..",
+            "src",
+            "generated");
+            //
+            Up
+            to
+            root,
+            then
+            into
+            src/generated/
+
+
+            async
+            function
+            getLatestVersion():
+            Promise<string>
+            {
+              const response = await fetch(MAVEN_METADATA_URL);
+              if (!response.ok)
+                throw new Error(`Failed to fetch Maven metadata: ${response.statusText}`);
+              const text = await response.text();
+              const match = text.match(/<latest>(.*?)<\/latest>/);
+              if (!match)
+                throw new Error("Couldn’t parse latest version from Maven metadata");
+              return match[1];
+            }
+
+
+            async
+            function
+            checkAndPromptForUpdate(messages:
+            string[]):
+            Promise<string>
+            {
+              const latestVersion = await getLatestVersion();
+              if (latestVersion === CURRENT_JAR_VERSION) {
+                messages.push(`Current version (${CURRENT_JAR_VERSION}) is the latest.`);
+                return CURRENT_JAR_VERSION;
+              }
+
+              messages.push(
+                `Newer version available: ${latestVersion} (current: ${CURRENT_JAR_VERSION})`
+              );
+              const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+              });
+
+              return new Promise((resolve) => {
+                const prompt = "Do you want to update to the latest version? (y/n): ";
+                messages.push(prompt);
+                rl.question(prompt, (answer) => {
+                  rl.close();
+                  if (answer.toLowerCase() === "y" || answer.toLowerCase() === "yes") {
+                    messages.push(`Switching to version ${latestVersion}...`);
+                    resolve(latestVersion);
+                  } else {
+                    messages.push(`Sticking with version ${CURRENT_JAR_VERSION}.`);
+                    resolve(CURRENT_JAR_VERSION);
+                  }
+                });
+              });
+            }
+
+
+            async
+            function
+            ensureJarExists(
+              version: string,
+              messages: string[]
+            ):
+            Promise<string>
+            {
+              const jarPath = join(JARS_DIR, `openapi-generator-cli-${version}.jar`);
+              const jarUrl = `https://repo1.maven.org/maven2/org/openapitools/openapi-generator-cli/${version}/openapi-generator-cli-${version}.jar`;
+
+              if (!existsSync(jarPath)) {
+                messages.push(`Downloading OpenAPI Generator CLI v${version}...`);
+                try {
+                  execSync(`curl -L -o ${jarPath} ${jarUrl}`, { stdio: "inherit" });
+                  messages.push(`Downloaded ${jarPath}`);
+                } catch (error) {
+                  messages.push("Failed to download JAR.");
+                  throw error;
+                }
+              } else {
+                messages.push(`Using existing ${jarPath}`);
+              }
+              return jarPath;
+            }
+
+
+            function
+            regenerateClient(jarPath:
+            string,
+            messages:
+            string[])
+            {
+              messages.push("Regenerating client from spec...");
+              const command = `java -jar ${jarPath} generate -i ${SPEC_INPUT} -g typescript-fetch -o ${OUTPUT_DIR} --additional-properties=generateAliasAsModel=true`;
+              try {
+                execSync(command, { stdio: "inherit" });
+                messages.push("Client regeneration complete.");
+              } catch (error) {
+                messages.push("Regeneration failed.");
+                throw error;
+              }
+            }
+
+
+            async
+            function
+            main()
+            {
+              const messages: string[] = [];
+              try {
+                if (!existsSync(SPEC_INPUT)) {
+                  console.error(
+                    `Spec file ${SPEC_INPUT} does not exist. Run 'npm run fix-spec' first.`
+                  );
+                  process.exit(1);
+                }
+                const versionToUse = await checkAndPromptForUpdate(messages);
+                const jarPath = await ensureJarExists(versionToUse, messages);
+                regenerateClient(jarPath, messages);
+              } catch (error) {
+                console.error("Error occurred during process:", error);
+              } finally {
+                console.log("\n--- Key Messages ---");
+                messages.forEach((msg) => console.log(msg));
+              }
+            }
+
+
+            main().catch((error)
+            =>
+            {
+              console.error("Error in regeneration process:", error);
+              process.exit(1);
+            });
+        - name: >-
+            schema
+          type: >-
+            directory
+          children:
+            - name: >-
+                enhance-general.ts
+              type: >-
+                file
+              contents: >
+                //
+                schema/enhance-general.ts
+
+                import
+                {
+                Operation,
+                Parameter,
+                Spec
+                }
+                from
+                "../types/spec.ts";
+
+                import
+                {
+                inferSchema
+                }
+                from
+                "../utils/infer-schema.ts";
+
+
+                export
+                function
+                enhanceGeneral(spec:
+                Spec):
+                void
+                {
+                  spec.definitions = spec.definitions || {};
+
+                  if (!spec.definitions["Record"]) {
+                    spec.definitions["Record"] = {
+                      type: "object",
+                      additionalProperties: {
+                        type: "object",
+                        properties: { value: { type: "string" } },
+                        required: ["value"],
+                      },
+                      description: "A generic QuickBase record with field ID-value pairs",
+                    };
+                    console.log("Added Record to definitions");
+                  }
+
+                  if (!spec.definitions["Permission"]) {
+                    spec.definitions["Permission"] = {
+                      type: "object",
+                      properties: {
+                        role: { type: "string", description: "The role name" },
+                        permissionType: {
+                          type: "string",
+                          description: "Permission type (e.g., View, Modify)",
+                        },
+                        roleId: { type: "integer", description: "The role identifier" },
+                      },
+                      required: ["role", "permissionType", "roleId"],
+                      description: "A single permission entry for a field",
+                    };
+                    console.log("Added Permission to definitions");
+                  }
+
+                  for (const pathKey in spec.paths) {
+                    for (const method in spec.paths[pathKey]) {
+                      const operation: Operation = spec.paths[pathKey][method];
+                      const opId =
+                        operation.operationId || `${method}${pathKey.replace(/\W/g, "")}`;
+
+                      if (operation.parameters) {
+                        operation.parameters.forEach((param: Parameter) => {
+                          if (param.in !== "body" && !param.type && !param.schema) {
+                            param.type = param.name.includes("Id") ? "string" : "string";
+                            console.log(
+                              `Set default type 'string' for ${pathKey}(${method}).${param.name}`
+                            );
+                          }
+                        });
+                      }
+
+                      if (operation.responses) {
+                        for (const status in operation.responses) {
+                          const response = operation.responses[status];
+                          if (response.schema) {
+                            const cleanStatus = status.replace("/", "_");
+                            const responseName = `${opId}${cleanStatus}Response`;
+                            if (!spec.definitions[responseName]) {
+                              console.log(
+                                `Adding ${responseName} to definitions for ${pathKey}(${method})`
+                              );
+                              if (!response.schema.type && response["x-amf-mediaType"]) {
+                                const mediaType = response["x-amf-mediaType"];
+                                if (mediaType === "application/octet-stream") {
+                                  response.schema = {
+                                    type: "object",
+                                    properties: { data: { type: "string", format: "binary" } },
+                                    description:
+                                      response.schema?.description || "Binary file content",
+                                  };
+                                } else if (mediaType === "application/x-yaml") {
+                                  response.schema = {
+                                    type: "object",
+                                    properties: { content: { type: "string", format: "yaml" } },
+                                    description: "YAML-formatted data",
+                                  };
+                                } else if (
+                                  mediaType === "application/json" &&
+                                  response.schema.example
+                                ) {
+                                  response.schema = inferSchema(
+                                    response.schema.example,
+                                    responseName
+                                  );
+                                  response.schema.description =
+                                    response.description || `Response for ${opId}`;
+                                }
+                              }
+                              spec.definitions[responseName] = response.schema;
+                            }
+                            response.schema = { $ref: `#/definitions/${responseName}` };
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+            - name: >-
+                fix-arrays.ts
+              type: >-
+                file
+              contents: >
+                //
+                schema/fix-arrays.ts
+
+                import
+                {
+                Parameter,
+                Spec
+                }
+                from
+                "../types/spec.ts";
+
+
+                export
+                function
+                fixArrays(spec:
+                Spec):
+                void
+                {
+                  for (const pathKey in spec.paths) {
+                    for (const method in spec.paths[pathKey]) {
+                      const operation = spec.paths[pathKey][method];
+                      if (operation.parameters) {
+                        operation.parameters.forEach((param: Parameter) => {
+                          if (param.schema?.type === "array" && !param.schema.items) {
+                            console.log(
+                              `Fixing array schema for ${pathKey}(${method}).${param.name}`
+                            );
+                            param.schema.items = { type: "string" };
+                          }
+                          if (param.schema?.properties) {
+                            for (const propKey in param.schema.properties) {
+                              const prop = param.schema.properties[propKey];
+                              if (prop.type === "array" && !prop.items) {
+                                console.log(
+                                  `Fixing nested array for ${pathKey}(${method}).${param.name}.${propKey}`
+                                );
+                                prop.items = { type: "string" };
+                              }
+                            }
+                          }
+                        });
+                      }
+                      if (operation.responses) {
+                        for (const status in operation.responses) {
+                          const response = operation.responses[status];
+                          if (response.schema?.type === "array" && !response.schema.items) {
+                            console.log(
+                              `Fixing array schema for ${pathKey}(${method}).responses.${status}`
+                            );
+                            response.schema.items = { type: "string" };
+                          }
+                          if (response.schema?.properties) {
+                            for (const propKey in response.schema.properties) {
+                              // Fixed: Changed param to response
+                              const prop = response.schema.properties[propKey];
+                              if (prop.type === "array" && !prop.items) {
+                                console.log(
+                                  `Fixing nested array for ${pathKey}(${method}).responses.${status}.${propKey}`
+                                );
+                                prop.items = { type: "string" };
+                              }
+                            }
+                          }
+                        }
+                      }
+                    }
+                  }
+
+                  console.log("Fixing array schemas in definitions...");
+                  const definitions = spec.definitions || {};
+                  for (const defKey in definitions) {
+                    const def = definitions[defKey];
+                    if (def.properties) {
+                      for (const propKey in def.properties) {
+                        const prop = def.properties[propKey];
+                        if (prop.type === "array" && !prop.items) {
+                          console.log(`Fixing missing items in ${defKey}.${propKey}`);
+                          prop.items = { type: "string" };
+                        }
+                      }
+                    }
+                  }
+                }
+            - name: >-
+                tags
+              type: >-
+                directory
+              children:
+                - name: >-
+                    apps.ts
+                  type: >-
+                    file
+                  contents: >
+                    //
+                    schema/tags/apps.ts
+
+                    import
+                    {
+                    Operation,
+                    Parameter,
+                    Spec
+                    }
+                    from
+                    "../../types/spec.ts";
+
+                    import
+                    {
+                    normalizeDefinitionName
+                    }
+                    from
+                    "../../utils/naming.ts";
+
+
+                    export
+                    function
+                    enhanceApps(
+                      spec: Spec,
+                      pathKey: string,
+                      method: string,
+                      operation: Operation
+                    ):
+                    void
+                    {
+                      const opId =
+                        operation.operationId || `${method}${pathKey.replace(/\W/g, "")}`;
+                      if (operation.parameters && operation.tags?.includes("Apps")) {
+                        operation.parameters.forEach((param: Parameter) => {
+                          if (param.in === "body") {
+                            if (!param.schema) param.schema = {};
+                            let requestName =
+                              param.schema.$ref?.split("/").pop() || `${opId}Request`;
+                            requestName = normalizeDefinitionName(requestName);
+
+                            if (
+                              !spec.definitions[requestName] ||
+                              !spec.definitions[requestName].type ||
+                              Object.keys(spec.definitions[requestName]?.properties || {})
+                                .length === 0
+                            ) {
+                              console.log(
+                                `Defining schema for ${requestName} in ${pathKey}(${method})`
+                              );
+                              let properties;
+                              if (pathKey.includes("/copy") && method === "post") {
+                                properties = {
+                                  name: { type: "string", description: "The name of the new app." },
+                                  description: {
+                                    type: "string",
+                                    description: "A description for the new app.",
+                                  },
+                                  properties: {
+                                    type: "object",
+                                    properties: {
+                                      keepData: {
+                                        type: "boolean",
+                                        description: "Whether to copy data.",
+                                      },
+                                      excludeFiles: {
+                                        type: "boolean",
+                                        description: "Whether to exclude files.",
+                                      },
+                                      usersAndRoles: {
+                                        type: "boolean",
+                                        description: "Whether to copy users and roles.",
+                                      },
+                                      assignUserToken: {
+                                        type: "boolean",
+                                        description: "Whether to assign the user token.",
+                                      },
+                                    },
+                                    description: "Options for customizing the app copy process.",
+                                  },
+                                };
+                              } else {
+                                properties = {
+                                  name: { type: "string", description: "The name of the app." },
+                                  description: {
+                                    type: "string",
+                                    description: "A description for the app.",
+                                  },
+                                  assignToken: {
+                                    type: "boolean",
+                                    description: "Whether to assign the user token.",
+                                  },
+                                };
+                              }
+                              spec.definitions[requestName] = {
+                                type: "object",
+                                properties,
+                                required: Object.keys(properties).filter(
+                                  (key) => key !== "description" && key !== "properties"
+                                ),
+                                description: operation.summary || `Request body for ${opId}`,
+                              };
+                            }
+                            param.schema = { $ref: `#/definitions/${requestName}` };
+                            console.log(
+                              `Ensured ${requestName} in definitions for ${pathKey}(${method})`
+                            );
+                          }
+                        });
+                      }
+                    }
+                - name: >-
+                    fields.ts
+                  type: >-
+                    file
+                  contents: >
+                    //
+                    schema/tags/fields.ts
+
+                    import
+                    {
+                    Operation,
+                    Parameter,
+                    Spec
+                    }
+                    from
+                    "../../types/spec.ts";
+
+                    import
+                    {
+                    normalizeDefinitionName
+                    }
+                    from
+                    "../../utils/naming.ts";
+
+
+                    export
+                    function
+                    enhanceFields(
+                      spec: Spec,
+                      pathKey: string,
+                      method: string,
+                      operation: Operation
+                    ):
+                    void
+                    {
+                      const opId =
+                        operation.operationId || `${method}${pathKey.replace(/\W/g, "")}`;
+                      if (operation.parameters && operation.tags?.includes("Fields")) {
+                        operation.parameters.forEach((param: Parameter) => {
+                          if (param.in === "body") {
+                            if (!param.schema) param.schema = {};
+                            let requestName =
+                              param.schema.$ref?.split("/").pop() || `${opId}Request`;
+                            requestName = normalizeDefinitionName(requestName);
+
+                            if (
+                              !spec.definitions[requestName] ||
+                              !spec.definitions[requestName].type ||
+                              Object.keys(spec.definitions[requestName]?.properties || {})
+                                .length === 0
+                            ) {
+                              console.log(
+                                `Defining schema for ${requestName} in ${pathKey}(${method})`
+                              );
+                              let properties;
+                              if (method === "delete") {
+                                properties = {
+                                  fieldIds: { type: "array", items: { type: "integer" } },
+                                };
+                              } else {
+                                properties = {
+                                  label: { type: "string", description: "The label of the field" },
+                                  fieldType: {
+                                    type: "string",
+                                    description: "The type of the field",
+                                    enum: [
+                                      "text",
+                                      "text-multiple-choice",
+                                      "text-multi-line",
+                                      "rich-text",
+                                      "numeric",
+                                      "currency",
+                                      "percent",
+                                      "rating",
+                                      "date",
+                                      "date-time",
+                                      "time-of-day",
+                                      "duration",
+                                      "checkbox",
+                                      "user",
+                                      "multi-user",
+                                      "address",
+                                      "email",
+                                      "phone",
+                                      "url",
+                                      "file",
+                                      "record-id",
+                                    ],
+                                  },
+                                  fieldHelp: {
+                                    type: "string",
+                                    description: "Help text for the field",
+                                    nullable: true,
+                                  },
+                                  addToForms: {
+                                    type: "boolean",
+                                    description: "Whether to add the field to forms",
+                                    nullable: true,
+                                  },
+                                  permissions: {
+                                    anyOf: [
+                                      {
+                                        type: "array",
+                                        items: { $ref: "#/definitions/Permission" },
+                                      },
+                                      { type: "null" },
+                                    ],
+                                    description: "Custom permissions for the field",
+                                  },
+                                  required: {
+                                    type: "boolean",
+                                    description: "Whether the field is required",
+                                    nullable: true,
+                                  },
+                                  unique: {
+                                    type: "boolean",
+                                    description: "Whether the field must have unique values",
+                                    nullable: true,
+                                  },
+                                  noWrap: {
+                                    type: "boolean",
+                                    description: "Whether text wrapping is disabled",
+                                    nullable: true,
+                                  },
+                                  bold: {
+                                    type: "boolean",
+                                    description: "Whether the field is bolded",
+                                    nullable: true,
+                                  },
+                                  appearsByDefault: {
+                                    type: "boolean",
+                                    description: "Whether the field appears by default in reports",
+                                    nullable: true,
+                                  },
+                                  findEnabled: {
+                                    type: "boolean",
+                                    description: "Whether the field is searchable",
+                                    nullable: true,
+                                  },
+                                  doesDataCopy: {
+                                    type: "boolean",
+                                    description: "Whether the field copies data",
+                                    nullable: true,
+                                  },
+                                  audited: {
+                                    type: "boolean",
+                                    description: "Whether changes to the field are audited",
+                                    nullable: true,
+                                  },
+                                };
+                              }
+                              spec.definitions[requestName] = {
+                                type: "object",
+                                properties,
+                                required: Object.keys(properties).filter(
+                                  (key) =>
+                                    ![
+                                      "fieldHelp",
+                                      "addToForms",
+                                      "permissions",
+                                      "required",
+                                      "unique",
+                                      "noWrap",
+                                      "bold",
+                                      "appearsByDefault",
+                                      "findEnabled",
+                                      "doesDataCopy",
+                                      "audited",
+                                    ].includes(key)
+                                ),
+                                description: operation.summary || `Request body for ${opId}`,
+                              };
+                            }
+                            param.schema = { $ref: `#/definitions/${requestName}` };
+                            console.log(
+                              `Ensured ${requestName} in definitions for ${pathKey}(${method})`
+                            );
+                          }
+                        });
+                      }
+                    }
+                - name: >-
+                    groups.ts
+                  type: >-
+                    file
+                  contents: >
+                    //
+                    schema/tags/groups.ts
+
+                    import
+                    {
+                    Operation,
+                    Parameter,
+                    Spec
+                    }
+                    from
+                    "../../types/spec.ts";
+
+                    import
+                    {
+                    normalizeDefinitionName
+                    }
+                    from
+                    "../../utils/naming.ts";
+
+
+                    export
+                    function
+                    enhanceGroups(
+                      spec: Spec,
+                      pathKey: string,
+                      method: string,
+                      operation: Operation
+                    ):
+                    void
+                    {
+                      const opId =
+                        operation.operationId || `${method}${pathKey.replace(/\W/g, "")}`;
+                      if (
+                        operation.parameters &&
+                        operation.tags?.includes("Groups") &&
+                        operation.summary?.toLowerCase().includes("subgroup")
+                      ) {
+                        operation.parameters.forEach((param: Parameter) => {
+                          if (param.in === "body") {
+                            if (!param.schema) param.schema = {};
+                            let requestName =
+                              param.schema.$ref?.split("/").pop() || `${opId}Request`;
+                            requestName = normalizeDefinitionName(requestName);
+
+                            if (
+                              !spec.definitions[requestName] ||
+                              !spec.definitions[requestName].type ||
+                              Object.keys(spec.definitions[requestName]?.properties || {})
+                                .length === 0
+                            ) {
+                              console.log(
+                                `Defining schema for ${requestName} in ${pathKey}(${method})`
+                              );
+                              const properties = {
+                                groupIds: { type: "array", items: { type: "string" } },
+                              };
+                              spec.definitions[requestName] = {
+                                type: "object",
+                                properties,
+                                required: Object.keys(properties),
+                                description: operation.summary || `Request body for ${opId}`,
+                              };
+                            }
+                            param.schema = { $ref: `#/definitions/${requestName}` };
+                            console.log(
+                              `Ensured ${requestName} in definitions for ${pathKey}(${method})`
+                            );
+                          }
+                        });
+                      }
+                    }
+                - name: >-
+                    index.ts
+                  type: >-
+                    file
+                  contents: >
+                    //
+                    schema/tags/index.ts
+
+                    import
+                    {
+                    Operation,
+                    Parameter,
+                    Spec
+                    }
+                    from
+                    "../../types/spec.ts";
+
+                    import
+                    {
+                    normalizeDefinitionName
+                    }
+                    from
+                    "../../utils/naming.ts";
+
+                    import
+                    {
+                    enhanceUsers
+                    }
+                    from
+                    "./users.ts";
+
+                    import
+                    {
+                    enhanceGroups
+                    }
+                    from
+                    "./groups.ts";
+
+                    import
+                    {
+                    enhanceRecords
+                    }
+                    from
+                    "./records.ts";
+
+                    import
+                    {
+                    enhanceApps
+                    }
+                    from
+                    "./apps.ts";
+
+                    import
+                    {
+                    enhanceFields
+                    }
+                    from
+                    "./fields.ts";
+
+                    import
+                    {
+                    enhanceTables
+                    }
+                    from
+                    "./tables.ts";
+
+
+                    export
+                    function
+                    enhanceTags(spec:
+                    Spec):
+                    void
+                    {
+                      spec.definitions = spec.definitions || {};
+
+                      for (const pathKey in spec.paths) {
+                        for (const method in spec.paths[pathKey]) {
+                          const operation: Operation = spec.paths[pathKey][method];
+                          const opId =
+                            operation.operationId || `${method}${pathKey.replace(/\W/g, "")}`;
+
+                          // Handle array schemas
+                          if (operation.parameters) {
+                            operation.parameters.forEach((param: Parameter) => {
+                              if (param.in === "body") {
+                                if (!param.schema) param.schema = {};
+                                let requestName =
+                                  param.schema.$ref?.split("/").pop() || `${opId}Request`;
+                                requestName = normalizeDefinitionName(requestName);
+
+                                if (spec.definitions[requestName]?.type === "array") {
+                                  console.log(
+                                    `Wrapping array schema for ${requestName} in ${pathKey}(${method})`
+                                  );
+                                  const arraySchema = spec.definitions[requestName];
+                                  let wrapperPropName = operation.tags?.includes("Users")
+                                    ? "userIds"
+                                    : "items";
+                                  if (
+                                    operation.tags?.includes("Groups") &&
+                                    operation.summary?.toLowerCase().includes("subgroup")
+                                  ) {
+                                    wrapperPropName = "groupIds";
+                                  }
+                                  spec.definitions[requestName] = {
+                                    type: "object",
+                                    properties: { [wrapperPropName]: arraySchema },
+                                    required: arraySchema.minItems > 0 ? [wrapperPropName] : [],
+                                    description:
+                                      arraySchema.description || `Request body for ${opId}`,
+                                  };
+                                  param.schema = { $ref: `#/definitions/${requestName}` };
+                                  console.log(
+                                    `Ensured ${requestName} in definitions for ${pathKey}(${method})`
+                                  );
+                                }
+                              }
+                            });
+                          }
+
+                          // Apply tag-specific enhancements
+                          enhanceUsers(spec, pathKey, method, operation);
+                          enhanceGroups(spec, pathKey, method, operation);
+                          enhanceRecords(spec, pathKey, method, operation);
+                          enhanceApps(spec, pathKey, method, operation);
+                          enhanceFields(spec, pathKey, method, operation);
+                          enhanceTables(spec, pathKey, method, operation);
+                        }
+                      }
+                    }
+                - name: >-
+                    records.ts
+                  type: >-
+                    file
+                  contents: >
+                    //
+                    schema/tags/records.ts
+
+                    import
+                    {
+                    Operation,
+                    Parameter,
+                    Spec
+                    }
+                    from
+                    "../../types/spec.ts";
+
+                    import
+                    {
+                    normalizeDefinitionName
+                    }
+                    from
+                    "../../utils/naming.ts";
+
+
+                    export
+                    function
+                    enhanceRecords(
+                      spec: Spec,
+                      pathKey: string,
+                      method: string,
+                      operation: Operation
+                    ):
+                    void
+                    {
+                      const opId =
+                        operation.operationId || `${method}${pathKey.replace(/\W/g, "")}`;
+                      if (operation.parameters && operation.tags?.includes("Records")) {
+                        operation.parameters.forEach((param: Parameter) => {
+                          if (param.in === "body") {
+                            if (!param.schema) param.schema = {};
+                            let requestName =
+                              param.schema.$ref?.split("/").pop() || `${opId}Request`;
+                            requestName = normalizeDefinitionName(requestName);
+
+                            if (
+                              !spec.definitions[requestName] ||
+                              !spec.definitions[requestName].type ||
+                              Object.keys(spec.definitions[requestName]?.properties || {})
+                                .length === 0
+                            ) {
+                              console.log(
+                                `Defining schema for ${requestName} in ${pathKey}(${method})`
+                              );
+                              let properties;
+                              if (method === "post") {
+                                properties = {
+                                  data: { type: "array", items: { $ref: "#/definitions/Record" } },
+                                  to: { type: "string" },
+                                  fieldsToReturn: { type: "array", items: { type: "integer" } },
+                                };
+                              } else if (method === "delete") {
+                                properties = {
+                                  from: { type: "string" },
+                                  where: { type: "string" },
+                                };
+                              } else if (operation.summary?.toLowerCase().includes("query")) {
+                                properties = {
+                                  from: { type: "string" },
+                                  select: { type: "array", items: { type: "integer" } },
+                                  where: { type: "string" },
+                                };
+                              }
+                              if (properties) {
+                                spec.definitions[requestName] = {
+                                  type: "object",
+                                  properties,
+                                  required: Object.keys(properties).filter(
+                                    (key) => key !== "fieldsToReturn"
+                                  ),
+                                  description: operation.summary || `Request body for ${opId}`,
+                                };
+                              }
+                            }
+                            param.schema = { $ref: `#/definitions/${requestName}` };
+                            console.log(
+                              `Ensured ${requestName} in definitions for ${pathKey}(${method})`
+                            );
+                          }
+                        });
+                      }
+                    }
+                - name: >-
+                    tables.ts
+                  type: >-
+                    file
+                  contents: >
+                    //
+                    schema/tags/tables.ts
+
+                    import
+                    {
+                    Operation,
+                    Parameter,
+                    Spec
+                    }
+                    from
+                    "../../types/spec.ts";
+
+                    import
+                    {
+                    normalizeDefinitionName
+                    }
+                    from
+                    "../../utils/naming.ts";
+
+
+                    export
+                    function
+                    enhanceTables(
+                      spec: Spec,
+                      pathKey: string,
+                      method: string,
+                      operation: Operation
+                    ):
+                    void
+                    {
+                      const opId =
+                        operation.operationId || `${method}${pathKey.replace(/\W/g, "")}`;
+                      if (operation.parameters && operation.tags?.includes("Tables")) {
+                        operation.parameters.forEach((param: Parameter) => {
+                          if (param.in === "body") {
+                            if (!param.schema) param.schema = {};
+                            let requestName =
+                              param.schema.$ref?.split("/").pop() || `${opId}Request`;
+                            requestName = normalizeDefinitionName(requestName);
+
+                            if (
+                              !spec.definitions[requestName] ||
+                              !spec.definitions[requestName].type ||
+                              Object.keys(spec.definitions[requestName]?.properties || {})
+                                .length === 0
+                            ) {
+                              console.log(
+                                `Defining schema for ${requestName} in ${pathKey}(${method})`
+                              );
+                              const properties = {
+                                name: { type: "string" },
+                              };
+                              spec.definitions[requestName] = {
+                                type: "object",
+                                properties,
+                                required: Object.keys(properties),
+                                description: operation.summary || `Request body for ${opId}`,
+                              };
+                            }
+                            param.schema = { $ref: `#/definitions/${requestName}` };
+                            console.log(
+                              `Ensured ${requestName} in definitions for ${pathKey}(${method})`
+                            );
+                          }
+                        });
+                      }
+                    }
+                - name: >-
+                    users.ts
+                  type: >-
+                    file
+                  contents: >
+                    //
+                    schema/tags/users.ts
+
+                    import
+                    {
+                    Operation,
+                    Parameter,
+                    Spec
+                    }
+                    from
+                    "../../types/spec.ts";
+
+                    import
+                    {
+                    normalizeDefinitionName
+                    }
+                    from
+                    "../../utils/naming.ts";
+
+
+                    export
+                    function
+                    enhanceUsers(
+                      spec: Spec,
+                      pathKey: string,
+                      method: string,
+                      operation: Operation
+                    ):
+                    void
+                    {
+                      const opId =
+                        operation.operationId || `${method}${pathKey.replace(/\W/g, "")}`;
+                      if (operation.parameters && operation.tags?.includes("Users")) {
+                        operation.parameters.forEach((param: Parameter) => {
+                          if (param.in === "body") {
+                            if (!param.schema) param.schema = {};
+                            let requestName =
+                              param.schema.$ref?.split("/").pop() || `${opId}Request`;
+                            requestName = normalizeDefinitionName(requestName);
+
+                            if (
+                              !spec.definitions[requestName] ||
+                              !spec.definitions[requestName].type ||
+                              Object.keys(spec.definitions[requestName]?.properties || {})
+                                .length === 0
+                            ) {
+                              console.log(
+                                `Defining schema for ${requestName} in ${pathKey}(${method})`
+                              );
+                              const properties = {
+                                userIds: { type: "array", items: { type: "string" } },
+                              };
+                              spec.definitions[requestName] = {
+                                type: "object",
+                                properties,
+                                required: Object.keys(properties),
+                                description: operation.summary || `Request body for ${opId}`,
+                              };
+                            }
+                            param.schema = { $ref: `#/definitions/${requestName}` };
+                            console.log(
+                              `Ensured ${requestName} in definitions for ${pathKey}(${method})`
+                            );
+                          }
+                        });
+                      }
+                    }
+        - name: >-
+            types
+          type: >-
+            directory
+          children:
+            - name: >-
+                spec.ts
+              type: >-
+                file
+              contents: >
+                export
+                interface
+                Parameter
+                {
+                  name: string;
+                  in: string;
+                  required?: boolean;
+                  type?: string;
+                  schema?: {
+                    type?: string;
+                    items?: any;
+                    $ref?: string;
+                    properties?: any;
+                    example?: any;
+                  };
+                  example?: any;
+                }
+
+
+                export
+                interface
+                Operation
+                {
+                  parameters?: Parameter[];
+                  responses?: Record<
+                    string,
+                    { description: string; schema?: any; "x-amf-mediaType"?: string }
+                  >;
+                  operationId?: string;
+                  summary?: string;
+                  tags?: string[];
+                }
+
+
+                export
+                interface
+                Spec
+                {
+                  paths: Record<string, Record<string, Operation>>;
+                  definitions?: Record<string, any>;
+                  swagger: string;
+                  info: any;
+                  operations?: any;
+                  groups?: any;
+                  components?: any;
+                }
+
+
+                export
+                interface
+                FixSpecConfig
+                {
+                  applyOverrides?: boolean;
+                  overridePaths?: string[];
+                  overrideDefinitions?: string[];
+                }
+        - name: >-
+            utils
+          type: >-
+            directory
+          children:
+            - name: >-
+                infer-schema.ts
+              type: >-
+                file
+              contents: >
+                //
+                utils/infer-schema.ts
+
+                export
+                function
+                inferSchema(example:
+                any,
+                operationId?:
+                string):
+                any
+                {
+                  if (!example || typeof example !== "object") {
+                    return { type: "string" };
+                  }
+                  if (Array.isArray(example)) {
+                    return {
+                      type: "array",
+                      items:
+                        example.length > 0
+                          ? inferSchema(example[0], operationId)
+                          : { type: "string" },
+                    };
+                  }
+                  const properties: Record<string, any> = {};
+                  for (const [key, value] of Object.entries(example)) {
+                    if (Array.isArray(value)) {
+                      properties[key] = {
+                        type: "array",
+                        items:
+                          value.length > 0
+                            ? inferSchema(value[0], operationId)
+                            : { type: "string" },
+                      };
+                    } else if (typeof value === "object" && value !== null) {
+                      properties[key] = inferSchema(value, operationId);
+                    } else {
+                      properties[key] = {
+                        type:
+                          typeof value === "object" && value === null
+                            ? "object"
+                            : typeof value || "string",
+                      };
+                    }
+                  }
+                  if (operationId && operationId.endsWith("200Response")) {
+                    return { type: "array", items: { type: "object", properties } };
+                  }
+                  return { type: "object", properties };
+                }
+            - name: >-
+                naming.ts
+              type: >-
+                file
+              contents: >
+                //
+                utils/naming.ts
+
+                export
+                function
+                toCamelCase(str:
+                string):
+                string
+                {
+                  return str
+                    .replace(/[-_](.)/g, (_, char) => char.toUpperCase())
+                    .replace(/^./, (str) => str.toLowerCase());
+                }
+
+
+                export
+                function
+                normalizeDefinitionName(name:
+                string):
+                string
+                {
+                  return name.charAt(0).toUpperCase() + name.slice(1);
+                }
+    - name: >-
+        openapitools.json
+      type: >-
+        file
+    - name: >-
+        output.log
+      type: >-
+        file
+    - name: >-
+        package-lock.json
+      type: >-
+        file
+    - name: >-
+        package.json
+      type: >-
+        file
+    - name: >-
+        playwright.config.ts
+      type: >-
+        file
+    - name: >-
+        regenerate_output.log
+      type: >-
+        file
+    - name: >-
+        rollup.config.js
+      type: >-
+        file
+    - name: >-
+        src
+      type: >-
+        directory
+      children:
+        - name: >-
+            generated
+          type: >-
+            directory
+          children:
+            - name: >-
+                .openapi-generator
+              type: >-
+                directory
+              children:
+                - name: >-
+                    FILES
+                  type: >-
+                    file
+                - name: >-
+                    VERSION
+                  type: >-
+                    file
+            - name: >-
+                .openapi-generator-ignore
+              type: >-
+                file
+            - name: >-
+                apis
+              type: >-
+                directory
+              children:
+                - name: >-
+                    AppsApi.ts
+                  type: >-
+                    file
+                - name: >-
+                    AuditApi.ts
+                  type: >-
+                    file
+                - name: >-
+                    AuthApi.ts
+                  type: >-
+                    file
+                - name: >-
+                    DocumentTemplatesApi.ts
+                  type: >-
+                    file
+                - name: >-
+                    FieldsApi.ts
+                  type: >-
+                    file
+                - name: >-
+                    FilesApi.ts
+                  type: >-
+                    file
+                - name: >-
+                    FormulasApi.ts
+                  type: >-
+                    file
+                - name: >-
+                    PlatformAnalyticsApi.ts
+                  type: >-
+                    file
+                - name: >-
+                    RecordsApi.ts
+                  type: >-
+                    file
+                - name: >-
+                    ReportsApi.ts
+                  type: >-
+                    file
+                - name: >-
+                    SolutionsApi.ts
+                  type: >-
+                    file
+                - name: >-
+                    TablesApi.ts
+                  type: >-
+                    file
+                - name: >-
+                    UserTokenApi.ts
+                  type: >-
+                    file
+                - name: >-
+                    UsersApi.ts
+                  type: >-
+                    file
+                - name: >-
+                    index.ts
+                  type: >-
+                    file
+            - name: >-
+                index.ts
+              type: >-
+                file
+            - name: >-
+                models
+              type: >-
+                directory
+              children:
+                - name: >-
+                    AddManagersToGroup200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    AddManagersToGroupRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    AddMembersToGroup200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    AddMembersToGroupRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    AddSubgroupsToGroup200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    AddSubgroupsToGroupRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    Audit200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    Audit202Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    AuditRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    ChangesetSolution200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    ChangesetSolution200ResponseInner.ts
+                  type: >-
+                    file
+                - name: >-
+                    ChangesetSolution200ResponseInnerChangesInnerInner.ts
+                  type: >-
+                    file
+                - name: >-
+                    ChangesetSolution400Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    ChangesetSolution401403Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    ChangesetSolution404Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    ChangesetSolution4xx5xxResponse.ts
+                  type: >-
+                    file
+                - name: >-
+                    ChangesetSolutionFromRecord200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    ChangesetSolutionFromRecord400Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    ChangesetSolutionFromRecord401403Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    ChangesetSolutionFromRecord404Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    ChangesetSolutionFromRecord4xx5xxResponse.ts
+                  type: >-
+                    file
+                - name: >-
+                    CloneUserToken200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    CloneUserTokenRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    CopyApp200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    CopyAppRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    CopyAppRequestProperties.ts
+                  type: >-
+                    file
+                - name: >-
+                    CreateApp200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    CreateAppRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    CreateField200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    CreateFieldRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    CreateRelationship200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    CreateRelationshipRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    CreateSolution200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    CreateSolution400Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    CreateSolution401403Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    CreateSolution4xx5xxResponse.ts
+                  type: >-
+                    file
+                - name: >-
+                    CreateSolutionFromRecord200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    CreateSolutionFromRecord200ResponseInner.ts
+                  type: >-
+                    file
+                - name: >-
+                    CreateSolutionFromRecord200ResponseInnerCreatedResourcesInner.ts
+                  type: >-
+                    file
+                - name: >-
+                    CreateSolutionFromRecord200ResponseInnerCreatedResourcesInnerAppsInner.ts
+                  type: >-
+                    file
+                - name: >-
+                    CreateSolutionFromRecord400Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    CreateSolutionFromRecord401403Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    CreateSolutionFromRecord404Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    CreateSolutionFromRecord4xx5xxResponse.ts
+                  type: >-
+                    file
+                - name: >-
+                    CreateTable200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    CreateTableRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    DeactivateUserToken200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    DeleteApp200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    DeleteAppRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    DeleteFields200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    DeleteFieldsRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    DeleteFile200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    DeleteRecords200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    DeleteRecordsRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    DeleteRelationship200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    DeleteTable200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    DeleteUserToken200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    DenyUsers200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    DenyUsersAndGroups200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    DenyUsersAndGroupsRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    DenyUsersRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    DownloadFile200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    ExchangeSsoToken200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    ExchangeSsoTokenRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    ExportSolution200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    ExportSolution400Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    ExportSolution401403Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    ExportSolution404Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    ExportSolution4xx5xxResponse.ts
+                  type: >-
+                    file
+                - name: >-
+                    ExportSolutionToRecord200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    ExportSolutionToRecord200ResponseInner.ts
+                  type: >-
+                    file
+                - name: >-
+                    ExportSolutionToRecord400Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    ExportSolutionToRecord401403Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    ExportSolutionToRecord404Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    ExportSolutionToRecord4xx5xxResponse.ts
+                  type: >-
+                    file
+                - name: >-
+                    GenerateDocument200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    GetApp200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    GetAppEvents200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    GetAppTables200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    GetField200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    GetFieldUsage200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    GetFields200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    GetFieldsUsage200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    GetRelationships200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    GetReport200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    GetTable200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    GetTableReports200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    GetTempTokenDBID200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    GetUsers200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    GetUsersRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    Permission.ts
+                  type: >-
+                    file
+                - name: >-
+                    PlatformAnalyticEventSummaries200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    PlatformAnalyticEventSummaries200ResponseMetadata.ts
+                  type: >-
+                    file
+                - name: >-
+                    PlatformAnalyticEventSummaries200ResponseResultsInner.ts
+                  type: >-
+                    file
+                - name: >-
+                    PlatformAnalyticEventSummaries200ResponseResultsInnerEventTypesInner.ts
+                  type: >-
+                    file
+                - name: >-
+                    PlatformAnalyticEventSummaries200ResponseResultsInnerTotals.ts
+                  type: >-
+                    file
+                - name: >-
+                    PlatformAnalyticEventSummaries200ResponseTotals.ts
+                  type: >-
+                    file
+                - name: >-
+                    PlatformAnalyticEventSummaries200ResponseWhereInner.ts
+                  type: >-
+                    file
+                - name: >-
+                    PlatformAnalyticEventSummariesRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    PlatformAnalyticEventSummariesRequestWhereInner.ts
+                  type: >-
+                    file
+                - name: >-
+                    PlatformAnalyticReads200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    Record.ts
+                  type: >-
+                    file
+                - name: >-
+                    RecordValue.ts
+                  type: >-
+                    file
+                - name: >-
+                    RemoveManagersFromGroup200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    RemoveManagersFromGroupRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    RemoveMembersFromGroup200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    RemoveMembersFromGroupRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    RemoveSubgroupsFromGroup200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    RemoveSubgroupsFromGroupRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    RunFormula200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    RunFormulaRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    RunQuery200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    RunQueryRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    RunReport200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    TransferUserToken200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    TransferUserTokenRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    UndenyUsers200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    UndenyUsersRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    UpdateApp200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    UpdateAppRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    UpdateField200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    UpdateFieldRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    UpdateRelationship200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    UpdateRelationshipRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    UpdateSolution200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    UpdateSolution200ResponseInner.ts
+                  type: >-
+                    file
+                - name: >-
+                    UpdateSolution200ResponseInnerCreatedResourcesInner.ts
+                  type: >-
+                    file
+                - name: >-
+                    UpdateSolution400Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    UpdateSolution401403Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    UpdateSolution4xx5xxResponse.ts
+                  type: >-
+                    file
+                - name: >-
+                    UpdateSolutionToRecord200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    UpdateSolutionToRecord200ResponseInner.ts
+                  type: >-
+                    file
+                - name: >-
+                    UpdateSolutionToRecord400Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    UpdateSolutionToRecord401403Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    UpdateSolutionToRecord404Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    UpdateSolutionToRecord4xx5xxResponse.ts
+                  type: >-
+                    file
+                - name: >-
+                    UpdateTable200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    UpdateTableRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    Upsert200Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    Upsert207Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    Upsert400Response.ts
+                  type: >-
+                    file
+                - name: >-
+                    UpsertRequest.ts
+                  type: >-
+                    file
+                - name: >-
+                    index.ts
+                  type: >-
+                    file
+            - name: >-
+                runtime.ts
+              type: >-
+                file
+        - name: >-
+            generated-unified
+          type: >-
+            directory
+          children:
+            - name: >-
+                QuickbaseClient.ts
+              type: >-
+                file
+            - name: >-
+                missing-types-report.json
+              type: >-
+                file
+        - name: >-
+            index.ts
+          type: >-
+            file
+        - name: >-
+            quickbaseClient.ts
+          type: >-
+            file
+        - name: >-
+            tokenCache.ts
+          type: >-
+            file
+        - name: >-
+            utils.ts
+          type: >-
+            file
+    - name: >-
+        test-artifacts
+      type: >-
+        directory
+      children:
+        - name: >-
+            .last-run.json
+          type: >-
+            file
+        - name: >-
+            test-results.json
+          type: >-
+            file
+    - name: >-
+        test-esm.js
+      type: >-
+        file
+    - name: >-
+        test-results.json
+      type: >-
+        file
+    - name: >-
+        test-umd.js
+      type: >-
+        file
+    - name: >-
+        test.ts
+      type: >-
+        file
+    - name: >-
+        tests
+      type: >-
+        directory
+      children:
+        - name: >-
+            playwright
+          type: >-
+            directory
+          children:
+            - name: >-
+                qb
+              type: >-
+                directory
+              children:
+                - name: >-
+                    auth
+                  type: >-
+                    directory
+                  children:
+                    - name: >-
+                        cacheSwitching.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        fetchTempToken401.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        getAppWithTempToken.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        getAppWithUserToken.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        getTempToken.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        tokenPrefetch.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        tokenRenewal.test.ts
+                      type: >-
+                        file
+        - name: >-
+            setup.ts
+          type: >-
+            file
+        - name: >-
+            vitest
+          type: >-
+            directory
+          children:
+            - name: >-
+                qb
+              type: >-
+                directory
+              children:
+                - name: >-
+                    apps
+                  type: >-
+                    directory
+                  children:
+                    - name: >-
+                        copyApp.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        createApp.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        deleteApp.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        getApp.test.ts
+                      type: >-
+                        file
+                - name: >-
+                    fields
+                  type: >-
+                    directory
+                  children:
+                    - name: >-
+                        createField.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        deleteFields.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        getField.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        getFieldUsage.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        getFields.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        getFieldsUsage.test.ts
+                      type: >-
+                        file
+                - name: >-
+                    index.ts
+                  type: >-
+                    file
+                - name: >-
+                    records
+                  type: >-
+                    directory
+                  children:
+                    - name: >-
+                        deleteRecords.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        runQuery.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        upsert.test.ts
+                      type: >-
+                        file
+                - name: >-
+                    tables
+                  type: >-
+                    directory
+                  children:
+                    - name: >-
+                        createTable.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        deleteTable.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        getAppTables.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        getRelationships.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        getTable.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        updateTable.test.ts
+                      type: >-
+                        file
+            - name: >-
+                unit
+              type: >-
+                directory
+              children:
+                - name: >-
+                    apps
+                  type: >-
+                    directory
+                  children:
+                    - name: >-
+                        copyApp.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        createApp.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        deleteApp.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        getApp.test.ts
+                      type: >-
+                        file
+                - name: >-
+                    auth
+                  type: >-
+                    directory
+                  children:
+                    - name: >-
+                        fetchTempToken401.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        getTempToken.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        retryOn401.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        two401s.test.ts
+                      type: >-
+                        file
+                - name: >-
+                    fields
+                  type: >-
+                    directory
+                  children:
+                    - name: >-
+                        createField.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        deleteFields.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        getField.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        getFieldUsage.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        getFields.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        getFieldsUsage.test.ts
+                      type: >-
+                        file
+                - name: >-
+                    index.ts
+                  type: >-
+                    file
+                - name: >-
+                    records
+                  type: >-
+                    directory
+                  children:
+                    - name: >-
+                        deleteRecords.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        runQuery.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        upsert.test.ts
+                      type: >-
+                        file
+                - name: >-
+                    tables
+                  type: >-
+                    directory
+                  children:
+                    - name: >-
+                        createTable.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        deleteTable.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        getAppTables.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        getRelationships.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        getTable.test.ts
+                      type: >-
+                        file
+                    - name: >-
+                        updateTable.test.ts
+                      type: >-
+                        file
+                - name: >-
+                    umd.test.ts
+                  type: >-
+                    file
+    - name: >-
+        text.txt
+      type: >-
+        file
+    - name: >-
+        tools
+      type: >-
+        directory
+      children:
+        - name: >-
+            generate-types.ts
+          type: >-
+            file
+        - name: >-
+            log-gen.ts
+          type: >-
+            file
+        - name: >-
+            log-gen.yaml
+          type: >-
+            file
+        - name: >-
+            openapi-jars
+          type: >-
+            directory
+          children:
+            - name: >-
+                openapi-generator-cli-7.12.0.jar
+              type: >-
+                file
+        - name: >-
+            openapi-schema-validator.ts
+          type: >-
+            file
+        - name: >-
+            spec-analyzer.ts
+          type: >-
+            file
+        - name: >-
+            split-spec.ts
+          type: >-
+            file
+        - name: >-
+            test-import.ts
+          type: >-
+            file
+        - name: >-
+            validate-spec.ts
+          type: >-
+            file
+    - name: >-
+        tsconfig.build.json
+      type: >-
+        file
+    - name: >-
+        tsconfig.json
+      type: >-
+        file
+    - name: >-
+        versionrc.json
+      type: >-
+        file
+    - name: >-
+        vitest.config.ts
+      type: >-
+        file