@osdk/generator 1.3.0 → 1.4.0

package/build/js/index.mjs

@@ -139,6 +139,8 @@ function getTypeScriptTypeFromDataType(actionParameter, importedObjects) {
       return `number`;
     case "timestamp":
       return `Timestamp`;
+    case "marking":
+      return "string";
     default:
       throw new Error(`Unsupported action parameter type: ${actionParameter}`);
   }
@@ -533,6 +535,54 @@ async function generateBackCompatDeprecatedExports(fs, outDir, importExt = "") {
   await generateOntologyRuntimeDistDir(outDir, fs, importExt);
   await generateOAuthClientDistDir(outDir, fs, importExt);
 }
+async function generateBulkActions(ontology, fs, outDir, importExt = "") {
+  const importedObjects = /* @__PURE__ */ new Set();
+  let actionSignatures = [];
+  for (const action of Object.values(ontology.actionTypes)) {
+    const entries = Object.entries(action.parameters);
+    const modifiedEntityTypes = getModifiedEntityTypes(action);
+    const addedObjects = Array.from(modifiedEntityTypes.addedObjects);
+    const modifiedObjects = Array.from(modifiedEntityTypes.modifiedObjects);
+    addedObjects.forEach(importedObjects.add, importedObjects);
+    modifiedObjects.forEach(importedObjects.add, importedObjects);
+    let jsDocBlock = ["/**"];
+    if (action.description) {
+      jsDocBlock.push(`* ${action.description}`);
+    }
+    let parameterBlock = "";
+    if (entries.length > 0) {
+      parameterBlock = `params: { 
+`;
+      for (const [parameterName, parameterData] of entries) {
+        parameterBlock += `"${parameterName}"`;
+        parameterBlock += parameterData.required ? ": " : "?: ";
+        const typeScriptType = getTypeScriptTypeFromDataType(parameterData.dataType, importedObjects);
+        parameterBlock += `${typeScriptType};
+`;
+        jsDocBlock.push(`* @param {${typeScriptType}} params.${parameterName}`);
+      }
+      parameterBlock += "}[], ";
+    } else {
+      parameterBlock = `params: Record<string,never>[], `;
+    }
+    jsDocBlock.push(`*/`);
+    actionSignatures.push(`
+      ${jsDocBlock.join("\n")}
+      ${action.apiName}<O extends BulkActionExecutionOptions>(${parameterBlock}options?: O): 
+        Promise<Result<BulkActionResponseFromOptions<O, Edits<${addedObjects.length > 0 ? addedObjects.join(" | ") : "void"}, ${modifiedObjects.length > 0 ? modifiedObjects.join(" | ") : "void"}>>, ActionError>>;
+      `);
+  }
+  await fs.mkdir(outDir, {
+    recursive: true
+  });
+  await fs.writeFile(path15__default.join(outDir, "BulkActions.ts"), await formatTs(`
+    import type { ObjectSet, LocalDate, Timestamp, Attachment, Edits, ActionExecutionOptions, BulkActionExecutionOptions, ActionError, Result, ActionResponseFromOptions, BulkActionResponseFromOptions } from "@osdk/legacy-client";
+    ${Array.from(importedObjects).map((importedObject) => `import type { ${importedObject} } from "../objects/${importedObject}${importExt}";`).join("\n")}
+    export interface BulkActions {
+    ${actionSignatures.join("\n")}
+    }
+  `));
+}
 async function generateFoundryClientFile(fs, outDir, importExt = "") {
   await fs.writeFile(path15__default.join(outDir, "FoundryClient.ts"), await formatTs(`
     import { BaseFoundryClient } from "@osdk/legacy-client";
@@ -610,6 +660,7 @@ async function generateMetadataFile(ontology, userAgent, fs, outDir, importExt =
   import type { Objects } from "./ontology/objects/Objects${importExt}";
   import type { Actions } from "./ontology/actions/Actions${importExt}";
   import type { Queries } from "./ontology/queries/Queries${importExt}";
+  import type { BulkActions } from "./ontology/actions/BulkActions${importExt}";
   ${objectNames.map((name) => `import {${name}} from "./ontology/objects/${name}${importExt}";`).join("\n")}
   ${actionNames.map((name) => `import {${getImportClause(name, actionAltNames)}} from "./ontology/actions/${name}${importExt}";`).join("\n")}
   ${queryNames.map((name) => `import {${getImportClause(name, queryAltNames)}} from "./ontology/queries/${name}${importExt}";`).join("\n")}
@@ -652,6 +703,7 @@ async function generateMetadataFile(ontology, userAgent, fs, outDir, importExt =
 export interface Ontology extends ClientOntology<typeof Ontology> {
     objects: Objects;
     actions: Actions;
+    bulkActions: BulkActions;
     queries: Queries;
 }`));
 }
@@ -719,6 +771,7 @@ async function generateOntologyIndexFile(fs, outDir) {
 function wireActionTypeV2ToSdkActionDefinition(input) {
   const modifiedEntityTypes = getModifiedEntityTypes(input);
   return {
+    type: "action",
     apiName: input.apiName,
     parameters: Object.fromEntries(Object.entries(input.parameters).map(([key, value]) => [key, wireActionParameterV2ToSdkParameterDefinition(value)])),
     displayName: input.displayName,
@@ -738,6 +791,7 @@ function wireActionParameterV2ToSdkParameterDefinition(value) {
     case "long":
     case "objectSet":
     case "timestamp":
+    case "marking":
       return {
         multiplicity: false,
         type: actionPropertyToSdkPropertyDefinition(value.dataType),
@@ -747,7 +801,7 @@ function wireActionParameterV2ToSdkParameterDefinition(value) {
     case "array":
       return {
         multiplicity: true,
-        type: actionPropertyToSdkPropertyDefinition(value.dataType),
+        type: actionPropertyToSdkPropertyDefinition(value.dataType.subType),
         nullable: value.required ? false : true,
         description: value.description
       };
@@ -762,6 +816,7 @@ function actionPropertyToSdkPropertyDefinition(parameterType) {
     case "integer":
     case "long":
     case "timestamp":
+    case "marking":
       return parameterType.type;
     case "date":
       return "datetime";
@@ -800,20 +855,192 @@ function createModifiedEntities(addedObjects, modifiedObjects) {
   return entities;
 }
 
+// src/util/deleteUndefineds.ts
+function deleteUndefineds(obj) {
+  return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== void 0));
+}
+
+// src/util/reservedKeywords.ts
+var reservedKeywords = /* @__PURE__ */ new Set(["break", "case", "catch", "class", "const", "continue", "debugger", "default", "delete", "do", "else", "enum", "export", "extends", "false", "finally", "for", "function", "if", "import", "in", "instanceof", "new", "null", "return", "super", "switch", "this", "throw", "true", "try", "typeof", "var", "void", "while", "with", "implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"]);
+function isReservedKeyword(name) {
+  return reservedKeywords.has(name);
+}
+
+// src/v1.1/wireObjectTypeV2ToV1ObjectInterfaceString.ts
+function wireObjectTypeV2ToObjectInterfaceStringV1(objectTypeWithLinks, importExt = "") {
+  const uniqueLinkTargets = new Set(objectTypeWithLinks.linkTypes.map((a) => a.objectTypeApiName).filter((a) => a !== objectTypeWithLinks.objectType.apiName));
+  return `import type { OntologyObject, LocalDate, Timestamp, GeoShape, GeoPoint, Attachment, TimeSeries, MultiLink, SingleLink } from "@osdk/legacy-client";
+${Array.from(uniqueLinkTargets).map((linkTarget) => `import type { ${linkTarget} } from "./${linkTarget}${importExt}";`).join("\n")}
+
+  ${getDescriptionIfPresent(objectTypeWithLinks.objectType.description)}
+  export interface ${objectTypeWithLinks.objectType.apiName} extends OntologyObject {
+  readonly __apiName: "${objectTypeWithLinks.objectType.apiName}";
+  readonly __primaryKey: ${wirePropertyTypeV2ToTypeScriptType(objectTypeWithLinks.objectType.properties[objectTypeWithLinks.objectType.primaryKey].dataType)};
+${Object.entries(objectTypeWithLinks.objectType.properties).sort((a, b) => a[0].localeCompare(b[0])).flatMap(([propertyName, propertyDefinition]) => {
+    const propertyType = wirePropertyTypeV2ToTypeScriptType(propertyDefinition.dataType);
+    const entries = [`${getDescriptionIfPresent(propertyDefinition.description, true)}readonly ${propertyName}: ${propertyType} | undefined`];
+    if (isReservedKeyword(propertyName)) {
+      entries.push(`/** @deprecated please migrate to '${propertyName}' instead */
+          readonly ${propertyName}_: ${propertyType} | undefined`);
+    }
+    return entries;
+  }).join(";\n")}
+${objectTypeWithLinks.linkTypes.flatMap((linkType) => {
+    const entries = [`readonly ${linkType.apiName}: ${linkType.cardinality === "MANY" ? "MultiLink" : "SingleLink"}<${linkType.objectTypeApiName}>`];
+    return entries;
+  }).join(";\n")}
+}
+  `;
+}
+function wirePropertyTypeV2ToTypeScriptType(property) {
+  switch (property.type) {
+    case "string":
+      return "string";
+    case "boolean":
+      return "boolean";
+    case "array":
+      return wirePropertyTypeV2ToTypeScriptType(property.subType) + "[]";
+    case "integer":
+      return "number";
+    case "attachment":
+      return "Attachment";
+    case "byte":
+      return "number";
+    case "date":
+      return "LocalDate";
+    case "decimal":
+      return "number";
+    case "double":
+      return "number";
+    case "float":
+      return "number";
+    case "geopoint":
+      return "GeoPoint";
+    case "geoshape":
+      return "GeoShape";
+    case "long":
+      return "number";
+    case "short":
+      return "number";
+    case "timestamp":
+      return "Timestamp";
+    case "timeseries":
+      return property.itemType.type === "string" ? `TimeSeries<string>` : `TimeSeries<number>`;
+    case "marking":
+      return "string";
+    default:
+      throw new Error(`Unknown property type ${property}`);
+  }
+}
+function getDescriptionIfPresent(description, includeNewline) {
+  if (description) {
+    return `/**
+ * ${description}
+ */${includeNewline ? "\n" : ""}`;
+  }
+  return "";
+}
+
 // src/v1.1/generatePerActionDataFiles.ts
-async function generatePerActionDataFiles(ontology, fs, outDir, importExt = "") {
+function stringifyWithoutOuterBraces(obj) {
+  return JSON.stringify(obj, null, 2).replace(/^\{\n/, "").replace(/\n\}$/, "");
+}
+async function generatePerActionDataFiles(ontology, fs, outDir, importExt, v2) {
   await fs.mkdir(outDir, {
     recursive: true
   });
   await Promise.all(Object.values(ontology.actionTypes).map(async (action) => {
     const uniqueApiNames = new Set(extractReferencedObjectsFromAction(action));
+    const uniqueApiNamesString = uniqueApiNames.size > 0 ? [...uniqueApiNames].map((apiName) => `"${apiName}"`).join("|") : "never";
+    const fullActionDef = deleteUndefineds(wireActionTypeV2ToSdkActionDefinition(action));
+    const {
+      parameters,
+      ...actionDefSansParameters
+    } = fullActionDef;
+    const actionDefIdentifier = `ActionDef$${action.apiName}`;
+    const paramsDefIdentifier = `${actionDefIdentifier}$Params`;
+    const paramsIdentifier = `${action.apiName}$Params`;
+    function createParamsDef() {
+      const entries = Object.entries(parameters);
+      if (entries.length === 0) {
+        return `// Represents the definition of the parameters for the action
+          export type ${paramsDefIdentifier} = Record<string, never>;`;
+      }
+      return `// Represents the definition of the parameters for the action
+        export type ${paramsDefIdentifier} = {
+          ${Object.entries(parameters).map(([key, value]) => {
+        const {
+          type,
+          ...remain
+        } = value;
+        let q;
+        if (typeof type === "string") {
+          q = JSON.stringify(type);
+        } else if (type.type === "object") {
+          q = `ObjectActionDataType<"${type.object}", ${type.object}Def>`;
+        } else if (type.type === "objectSet") {
+          q = `ObjectSetActionDataType<"${type.objectSet}", ${type.objectSet}Def>`;
+        }
+        return `"${key}": {
+              type: ${q};
+              ${stringifyWithoutOuterBraces(remain)}
+            }
+            `;
+      }).join(";\n")}
+        }`;
+    }
+    function createV2Types() {
+      return `
+        
+          ${createParamsDef()}
+          
+
+          // Represents the runtime arguments for the action
+          export type ${paramsIdentifier} = NOOP<OsdkActionParameters<${paramsDefIdentifier}>>;
+
+          
+          // Represents a fqn of the action
+          export interface ${action.apiName} {
+            ${getDescriptionIfPresent(action.description)}
+             <OP extends ApplyActionOptions>(args: ${paramsIdentifier}, options?: OP): Promise<ActionReturnTypeForOptions<OP>>;
+          }
+
+          
+          // Represents the definition of the action
+          export interface ${actionDefIdentifier} extends ActionDefinition<"${action.apiName}", ${uniqueApiNamesString}, ${action.apiName}>{
+          ${Object.entries(actionDefSansParameters).map(([key, value]) => {
+        return `${key}: ${JSON.stringify(value)};`;
+      }).join("\n")}
+          parameters: ${paramsDefIdentifier}
+        }`;
+    }
+    function createV2Object() {
+      return `  export const ${action.apiName}: ${actionDefIdentifier} = ${JSON.stringify(fullActionDef, null, 2)} `;
+    }
+    function createV1Object() {
+      return `  export const ${action.apiName} = ${JSON.stringify(fullActionDef, null, 2)} satisfies ActionDefinition<"${action.apiName}", ${uniqueApiNamesString}>;`;
+    }
+    const referencedObjectDefs = /* @__PURE__ */ new Set();
+    for (const p of Object.values(action.parameters)) {
+      if (p.dataType.type === "object" || p.dataType.type === "objectSet") {
+        referencedObjectDefs.add(p.dataType.objectApiName + "Def");
+        referencedObjectDefs.add(p.dataType.objectTypeApiName + "Def");
+      }
+    }
+    const importObjects = referencedObjectDefs.size > 0 ? `import type {${[...referencedObjectDefs].join(",")}} from "../objects${importExt}";` : "";
     await fs.writeFile(path15__default.join(outDir, `${action.apiName}.ts`), await formatTs(`
-          import { ActionDefinition } from "@osdk/api";
-  
-           export const ${action.apiName} = ${JSON.stringify(wireActionTypeV2ToSdkActionDefinition(action), null, 2)} satisfies ActionDefinition<"${action.apiName}", ${uniqueApiNames.size > 0 ? [...uniqueApiNames].map((apiName) => `"${apiName}"`).join("|") : "never"}>;`));
+          import type { ActionDefinition, ObjectActionDataType, ObjectSetActionDataType } from "@osdk/api";
+          import type { ActionSignature, ApplyActionOptions, OsdkActionParameters,ActionReturnTypeForOptions, NOOP } from '@osdk/client';
+          ${importObjects}
+
+        
+          ${v2 ? createV2Types() : ""}
+
+          ${v2 ? createV2Object() : createV1Object()}
+        `));
   }));
   await fs.writeFile(path15__default.join(outDir, `index.ts`), await formatTs(`
-      ${Object.values(ontology.actionTypes).map((action) => `export * from "./${action.apiName}${importExt}";`).join("\n")}
+      ${Object.values(ontology.actionTypes).map((action) => `export {${action.apiName}} from "./${action.apiName}${importExt}";`).join("\n")}
       `));
 }
 function extractReferencedObjectsFromAction(actionType) {
@@ -881,6 +1108,7 @@ function wirePropertyV2ToSdkPrimaryKeyTypeDefinition(input) {
     }
     case "timeseries":
     case "array":
+    case "marking":
       throw new Error(`Type not supported for primaryKey: ${input.dataType.type}`);
     default:
       input.dataType;
@@ -906,6 +1134,7 @@ function wirePropertyV2ToSdkPropertyDefinition(input, isNullable = true) {
     case "geoshape":
     case "timestamp":
     case "timeseries":
+    case "marking":
       return {
         multiplicity: false,
         description: input.description,
@@ -940,6 +1169,7 @@ function objectPropertyTypeToSdkPropertyDefinition(propertyType) {
     case "geopoint":
     case "geoshape":
     case "timestamp":
+    case "marking":
       return propertyType.type;
     case "date":
       return "datetime";
@@ -961,6 +1191,7 @@ function wireObjectTypeV2ToSdkObjectDefinition(objectTypeWithLink, v2) {
     throw new Error(`Primary key ${objectTypeWithLink.objectType.primaryKey} not found in ${objectTypeWithLink.objectType.apiName}`);
   }
   return {
+    type: "object",
     apiName: objectTypeWithLink.objectType.apiName,
     description: objectTypeWithLink.objectType.description,
     primaryKeyType: wirePropertyV2ToSdkPrimaryKeyTypeDefinition(objectTypeWithLink.objectType.properties[objectTypeWithLink.objectType.primaryKey]),
@@ -975,89 +1206,30 @@ function wireObjectTypeV2ToSdkObjectDefinition(objectTypeWithLink, v2) {
 }
 
 // src/shared/wireObjectTypeV2ToSdkObjectConst.ts
-function wireObjectTypeV2ToSdkObjectConst(object, v2 = false) {
+function wireObjectTypeV2ToSdkObjectConst(object, importExt, v2 = false) {
   const uniqueLinkTargetTypes = new Set(object.linkTypes.map((a) => a.objectTypeApiName));
+  const definition = wireObjectTypeV2ToSdkObjectDefinition(object, v2);
+  const imports = Array.from(uniqueLinkTargetTypes).filter((type) => type !== definition.apiName).map((type) => `import type { ${type}Def } from "./${type}${importExt}";`);
   return `
-    export const ${object.objectType.apiName} = ${JSON.stringify(wireObjectTypeV2ToSdkObjectDefinition(object, v2), null, 2)} satisfies ObjectTypeDefinition<"${object.objectType.apiName}", ${uniqueLinkTargetTypes.size > 0 ? [...uniqueLinkTargetTypes].map((apiName) => `"${apiName}"`).join("|") : "never"}>;`;
-}
-
-// src/util/reservedKeywords.ts
-var reservedKeywords = /* @__PURE__ */ new Set(["break", "case", "catch", "class", "const", "continue", "debugger", "default", "delete", "do", "else", "enum", "export", "extends", "false", "finally", "for", "function", "if", "import", "in", "instanceof", "new", "null", "return", "super", "switch", "this", "throw", "true", "try", "typeof", "var", "void", "while", "with", "implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"]);
-function isReservedKeyword(name) {
-  return reservedKeywords.has(name);
-}
-
-// src/v1.1/wireObjectTypeV2ToV1ObjectInterfaceString.ts
-function wireObjectTypeV2ToObjectInterfaceStringV1(objectTypeWithLinks, importExt = "") {
-  const uniqueLinkTargets = new Set(objectTypeWithLinks.linkTypes.map((a) => a.objectTypeApiName).filter((a) => a !== objectTypeWithLinks.objectType.apiName));
-  return `import type { OntologyObject, LocalDate, Timestamp, GeoShape, GeoPoint, Attachment, TimeSeries, MultiLink, SingleLink } from "@osdk/legacy-client";
-${Array.from(uniqueLinkTargets).map((linkTarget) => `import type { ${linkTarget} } from "./${linkTarget}${importExt}";`).join("\n")}
-
-  ${getDescriptionIfPresent(objectTypeWithLinks.objectType.description)}export interface ${objectTypeWithLinks.objectType.apiName} extends OntologyObject {
-  readonly __apiName: "${objectTypeWithLinks.objectType.apiName}";
-  readonly __primaryKey: ${wirePropertyTypeV2ToTypeScriptType(objectTypeWithLinks.objectType.properties[objectTypeWithLinks.objectType.primaryKey].dataType)};
-${Object.entries(objectTypeWithLinks.objectType.properties).sort((a, b) => a[0].localeCompare(b[0])).flatMap(([propertyName, propertyDefinition]) => {
-    const propertyType = wirePropertyTypeV2ToTypeScriptType(propertyDefinition.dataType);
-    const entries = [`${getDescriptionIfPresent(propertyDefinition.description)}readonly ${propertyName}: ${propertyType} | undefined`];
-    if (isReservedKeyword(propertyName)) {
-      entries.push(`/** @deprecated please migrate to '${propertyName}' instead */
-          readonly ${propertyName}_: ${propertyType} | undefined`);
+  ${imports.join("\n")}
+    export interface ${object.objectType.apiName}Def extends ObjectTypeDefinition<"${object.objectType.apiName}"> {
+      type: "${definition.type}",
+      apiName: "${definition.apiName}",
+      ${definition.description != null ? `description: ${JSON.stringify(definition.description)},` : ""}
+      primaryKeyType: ${JSON.stringify(definition.primaryKeyType)},
+      links: {${Object.entries(definition.links).map(([linkApiName, definition2]) => `${linkApiName}: ObjectTypeLinkDefinition<${definition2.targetType}Def, ${definition2.multiplicity}>`).join(",\n")}
+  },
+      properties: ${JSON.stringify(definition.properties, null, 2)},
     }
-    return entries;
-  }).join(";\n")}
-${objectTypeWithLinks.linkTypes.flatMap((linkType) => {
-    const entries = [`readonly ${linkType.apiName}: ${linkType.cardinality === "MANY" ? "MultiLink" : "SingleLink"}<${linkType.objectTypeApiName}>`];
-    return entries;
-  }).join(";\n")}
-}
-  `;
-}
-function wirePropertyTypeV2ToTypeScriptType(property) {
-  switch (property.type) {
-    case "string":
-      return "string";
-    case "boolean":
-      return "boolean";
-    case "array":
-      return wirePropertyTypeV2ToTypeScriptType(property.subType) + "[]";
-    case "integer":
-      return "number";
-    case "attachment":
-      return "Attachment";
-    case "byte":
-      return "number";
-    case "date":
-      return "LocalDate";
-    case "decimal":
-      return "number";
-    case "double":
-      return "number";
-    case "float":
-      return "number";
-    case "geopoint":
-      return "GeoPoint";
-    case "geoshape":
-      return "GeoShape";
-    case "long":
-      return "number";
-    case "short":
-      return "number";
-    case "timestamp":
-      return "Timestamp";
-    case "timeseries":
-      return property.itemType.type === "string" ? `TimeSeries<string>` : `TimeSeries<number>`;
-    default:
-      throw new Error(`Unknown property type ${property}`);
-  }
-}
-function getDescriptionIfPresent(description) {
-  if (description) {
-    return `/**
- * ${description}
- */
-`;
-  }
-  return "";
+
+    export const ${object.objectType.apiName}: ${object.objectType.apiName}Def = {
+      type: "${definition.type}",
+      apiName: "${definition.apiName}",
+      ${definition.description != null ? `description: ${JSON.stringify(definition.description)},` : ""}
+      primaryKeyType: ${JSON.stringify(definition.primaryKeyType)},
+      links: ${JSON.stringify(definition.links, null, 2)},
+      properties: ${JSON.stringify(definition.properties, null, 2)},
+    };`;
 }
 
 // src/v1.1/generatePerObjectInterfaceAndDataFiles.ts
@@ -1068,10 +1240,10 @@ async function generatePerObjectInterfaceAndDataFiles(ontology, fs, outDir, impo
   await Promise.all(Object.values(ontology.objectTypes).map(async (object) => {
     object.linkTypes;
     await fs.writeFile(path15__default.join(outDir, `${object.objectType.apiName}.ts`), await formatTs(`
-        import type { ObjectTypeDefinition } from "@osdk/api";
+        import type { ObjectTypeDefinition, ObjectTypeLinkDefinition } from "@osdk/api";
         ${wireObjectTypeV2ToObjectInterfaceStringV1(object, importExt)}
 
-        ${wireObjectTypeV2ToSdkObjectConst(object)}
+        ${wireObjectTypeV2ToSdkObjectConst(object, importExt)}
         `));
   }));
   await fs.writeFile(path15__default.join(outDir, "index.ts"), await formatTs(`
@@ -1134,7 +1306,7 @@ function wireQueryDataTypeToQueryDataTypeDefinition(input) {
     case "union":
       const allowNulls = isNullableQueryDataType(input);
       if (allowNulls && input.unionTypes.length === 2) {
-        const nonnull = input.unionTypes.find((t) => t.type !== null);
+        const nonnull = input.unionTypes.find((t) => t.type != null);
         if (nonnull) {
           return {
             ...wireQueryDataTypeToQueryDataTypeDefinition(nonnull),
@@ -1217,6 +1389,7 @@ function guardInvalidKeyTypes(key) {
 // src/shared/wireQueryTypeV2ToSdkQueryDefinition.ts
 function wireQueryTypeV2ToSdkQueryDefinition(input) {
   return {
+    type: "query",
     apiName: input.apiName,
     description: input.description,
     displayName: input.displayName,
@@ -1447,6 +1620,9 @@ async function generateClientSdkVersionOneDotOne(ontology, userAgent, fs, outDir
   const actionsDir = path15.join(outDir, "ontology", "actions");
   const queriesDir = path15.join(outDir, "ontology", "queries");
   await verifyOutdir(outDir, fs);
+  await fs.mkdir(outDir, {
+    recursive: true
+  });
   const sanitizedOntology = sanitizeMetadata(ontology);
   await generateFoundryClientFile(fs, outDir, importExt);
   await generateMetadataFile(sanitizedOntology, userAgent, fs, outDir, importExt);
@@ -1455,7 +1631,8 @@ async function generateClientSdkVersionOneDotOne(ontology, userAgent, fs, outDir
   await generateObjectsInterfaceSupportFiles(sanitizedOntology, fs, path15.join(objectsDir, "objects-api"), importExt);
   await generatePerObjectInterfaceAndDataFiles(sanitizedOntology, fs, objectsDir, importExt);
   await generateActions(sanitizedOntology, fs, actionsDir, importExt);
-  await generatePerActionDataFiles(sanitizedOntology, fs, actionsDir, importExt);
+  await generateBulkActions(sanitizedOntology, fs, actionsDir, importExt);
+  await generatePerActionDataFiles(sanitizedOntology, fs, actionsDir, importExt, false);
   await generateQueries(sanitizedOntology, fs, queriesDir, importExt);
   await generatePerQueryDataFiles(sanitizedOntology, fs, queriesDir, importExt);
   await generateIndexFile(fs, outDir, importExt);
@@ -1469,11 +1646,13 @@ function __UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst(interfaceType, v2 = fals
 }
 function wireInterfaceTypeV2ToSdkObjectDefinition(interfaceType, v2) {
   return {
+    type: "interface",
     apiName: interfaceType.apiName,
     description: interfaceType.description,
     properties: Object.fromEntries(Object.entries(interfaceType.properties).map(([key, value]) => {
       return [key, wirePropertyV2ToSdkPropertyDefinition(value, true)];
-    }))
+    })),
+    links: {}
   };
 }
 async function generateOntologyMetadataFile(ontology, userAgent, fs, outDir) {
@@ -1543,9 +1722,9 @@ async function generateClientSdkVersionTwoPointZero(ontology, userAgent, fs, out
     const obj = ontology.objectTypes[name];
     await fs.writeFile(path15__default.join(outDir, "ontology", `objects`, `${name}.ts`), await formatTs(`
     
-      import type { ObjectTypeDefinition } from "@osdk/api";
+      import type { ObjectTypeDefinition, ObjectTypeLinkDefinition } from "@osdk/api";
 
-      ${wireObjectTypeV2ToSdkObjectConst(obj, true)}
+      ${wireObjectTypeV2ToSdkObjectConst(obj, importExt, true)}
 
       ${/* TODO: FIXME
     //   wireObjectTypeV2ToObjectDefinitionInterfaceString(
@@ -1560,7 +1739,7 @@ async function generateClientSdkVersionTwoPointZero(ontology, userAgent, fs, out
   await fs.mkdir(actionsDir, {
     recursive: true
   });
-  await generatePerActionDataFiles(sanitizedOntology, fs, actionsDir, importExt);
+  await generatePerActionDataFiles(sanitizedOntology, fs, actionsDir, importExt, true);
   await fs.writeFile(path15__default.join(outDir, "ontology", "objects.ts"), await formatTs(`
     ${Object.keys(ontology.objectTypes).map((apiName) => `export * from "./objects/${apiName}${importExt}";`).join("\n")}
     `));