@osdk/generator 1.0.3 → 1.1.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @osdk/generator
 
+## 1.1.0
+
+### Minor Changes
+
+- a0d5e431: Update build to ship packages compliant with @arethetypeswrong/cli
+
+### Patch Changes
+
+- Updated dependencies [a0d5e431]
+  - @osdk/gateway@1.1.0
+  - @osdk/api@1.1.0
+
+## 1.0.4
+
+### Patch Changes
+
+- Updated dependencies [25dd12ae]
+  - @osdk/gateway@1.0.2
+  - @osdk/api@1.0.2
+
 ## 1.0.3
 
 ### Patch Changes

package/build/{js → cjs}/index.cjs

@@ -181,37 +181,37 @@ function reexportConsts(typesToExport) {
 }
 
 // src/v1.1/backcompat/internal-foundry-oauth-dist/generateConfidentialClientDir.ts
-async function generateConfidentialClientDir(fs, oauthDistDir) {
+async function generateConfidentialClientDir(fs, oauthDistDir, importExt = "") {
   const confidentialClientDistDir = path15__namespace.default.join(oauthDistDir, "ConfidentialClient");
   await fs.mkdir(confidentialClientDistDir, {
     recursive: true
   });
   await fs.writeFile(path15__namespace.default.join(confidentialClientDistDir, "index.ts"), await formatTs(`
-    export * from "./ConfidentialClientAuth";
+    export * from "./ConfidentialClientAuth${importExt}";
   `));
   await fs.writeFile(path15__namespace.default.join(confidentialClientDistDir, "ConfidentialClientAuth.ts"), await formatTs(`
         ${reexportConsts(["ConfidentialClientAuth"])}
     `));
 }
-async function generatePublicClientDir(fs, oauthDistDir) {
+async function generatePublicClientDir(fs, oauthDistDir, importExt = "") {
   const publicClientDistDir = path15__namespace.default.join(oauthDistDir, "PublicClient");
   await fs.mkdir(publicClientDistDir, {
     recursive: true
   });
   await fs.writeFile(path15__namespace.default.join(publicClientDistDir, "index.ts"), await formatTs(`
-    export * from "./PublicClientAuth";
+    export * from "./PublicClientAuth${importExt}";
   `));
   await fs.writeFile(path15__namespace.default.join(publicClientDistDir, "PublicClientAuth.ts"), await formatTs(`
         ${reexportConsts(["PublicClientAuth"])}
     `));
 }
-async function generateUserTokenDir(fs, oauthDistDir) {
+async function generateUserTokenDir(fs, oauthDistDir, importExt = "") {
   const userTokenDistDir = path15__namespace.default.join(oauthDistDir, "UserToken");
   await fs.mkdir(userTokenDistDir, {
     recursive: true
   });
   await fs.writeFile(path15__namespace.default.join(userTokenDistDir, "index.ts"), await formatTs(`
-    export * from "./UserTokenAuth";
+    export * from "./UserTokenAuth${importExt}";
   `));
   await fs.writeFile(path15__namespace.default.join(userTokenDistDir, "UserTokenAuth.ts"), await formatTs(`
         ${reexportConsts(["UserTokenAuth"])}
@@ -241,46 +241,46 @@ function cleanup(s) {
 }
 
 // src/v1.1/backcompat/generateOAuthDistDir.ts
-async function generateOAuthClientDistDir(outDir, fs) {
+async function generateOAuthClientDistDir(outDir, fs, importExt = "") {
   const oauthDistDir = path15__namespace.join(outDir, "internal", "@foundry", "oauth-client", "dist");
   await fs.mkdir(oauthDistDir, {
     recursive: true
   });
   await fs.writeFile(path15__namespace.join(oauthDistDir, "index.ts"), await formatTs(`
-    export * from "./Auth";
-    export * from "./ConfidentialClient";
-    export * from "./OAuthClient";
-    export * from "./PublicClient";
-    export * from "./Token";
-    export * from "./UserToken";
+    export * from "./Auth${importExt}";
+    export * from "./ConfidentialClient/index${importExt}";
+    export * from "./OAuthClient${importExt}";
+    export * from "./PublicClient/index${importExt}";
+    export * from "./Token${importExt}";
+    export * from "./UserToken/index${importExt}";
 `));
   await fs.writeFile(path15__namespace.join(oauthDistDir, "Auth.ts"), await formatTs(reexportTypes(["Auth"])));
   await fs.writeFile(path15__namespace.join(oauthDistDir, "Token.ts"), await formatTs(reexportTypes(["Token", "TokenValue"])));
   await fs.writeFile(path15__namespace.join(oauthDistDir, "OAuthClient.ts"), await formatTs(reexportTypes(["AuthSubscription", "UnsubscribeFunction", "SignInResponse", "RefreshResponse", "SignOutResponse"])));
   await fs.writeFile(path15__namespace.join(oauthDistDir, "OAuthToken.ts"), await formatTs(reexportConsts(["OAuthToken"])));
   await fs.writeFile(path15__namespace.join(oauthDistDir, "Auth.ts"), await formatTs(reexportTypes(["Auth"])));
-  await generateConfidentialClientDir(fs, oauthDistDir);
-  await generatePublicClientDir(fs, oauthDistDir);
-  await generateUserTokenDir(fs, oauthDistDir);
+  await generateConfidentialClientDir(fs, oauthDistDir, importExt);
+  await generatePublicClientDir(fs, oauthDistDir, importExt);
+  await generateUserTokenDir(fs, oauthDistDir, importExt);
 }
 async function generateAggregationsAggregations(fs, aggregationsDir) {
   await fs.writeFile(path15__namespace.join(aggregationsDir, "Aggregations.ts"), await formatTs(`
       import { LocalDate, Timestamp } from "@osdk/legacy-client";
       ` + reexportTypes(["Double", "Rangeable", "MetricValue", "Date", "BucketKey", "BucketValue", "TimeUnit", "BucketGroup", "Metrics", "AggregatableProperties", "AggregationClause"]) + reexportTypes(["Range"], "<T extends Rangeable>", "<T>") + reexportTypes(["BaseGroupBy"], "<_T extends BucketValue = BucketValue>") + reexportTypes(["Duration"], "<_T extends Timestamp | LocalDate = Timestamp | LocalDate>") + reexportTypes(["AggregatableProperty", "MultipleAggregationsOperations"], "<_T extends MetricValue = MetricValue>") + reexportTypes(["AggregationGroup"], "<TMetrics extends Metrics | MetricValue, TBucketGroup extends BucketGroup>") + reexportTypes(["Bucketing"], "<_T extends string , _X extends BucketValue>") + reexportTypes(["AggregationResult"], "<TBucketGroup extends BucketGroup, TMetrics extends Metrics | MetricValue>") + reexportTypes(["BaseBucketing"], "<TBucketKey extends BucketKey, TBucketValue extends BucketValue, Kind extends string>") + reexportTypes(["ExactValueBucketing", "InternalBucketing"], `<TBucketKey extends BucketKey, TBucketValue extends BucketValue>`) + reexportTypes(["RangeBucketing", "FixedWidthBucketing"], `<TBucketKey extends BucketKey, TBucketValue extends Range<Rangeable>>`) + reexportTypes(["DurationBucketing"], `<TBucketKey extends BucketKey, TBucketValue extends Date>`) + reexportTypes(["InternalBucketingVisitor"], "<TBucketKey extends BucketKey, T extends BucketValue, R>") + reexportTypes(["AggregationBuilderResult"], "<T, TMultipleAggregationProperties>") + reexportTypes(["AggregatablePropertiesForResult", "AggregatablePropertyNamesForResult"], "<TAggregatableProperties, TResult extends MetricValue>") + reexportConsts(["assertBucketingInternal", "visitInternalBucketing"]) + reexportTypes(["AggregatableObjectSetStep"], "<TAggregatableProperties, TMultipleAggregationProperties, TBucketableProperties, TBucketGroup extends BucketGroup = {}>") + reexportTypes(["GroupedTerminalAggregationOperations"], "<TAggregatableProperties, TMultipleAggregationProperties, TBucketGroup extends BucketGroup = {}>")));
 }
-async function generateGroupBy(fs, aggregationsDir) {
+async function generateGroupBy(fs, aggregationsDir, importExt = "") {
   await fs.mkdir(path15__namespace.join(aggregationsDir, "groupBy"), {
     recursive: true
   });
   const groupBys = ["BooleanGroupBy", "LocalDateGroupBy", "NumericGroupBy", "StringGroupBy", "TimestampGroupBy"];
   const reexportFiles = [...groupBys, "GroupKeyType"];
   for (const key of reexportFiles) {
-    await fs.writeFile(path15__namespace.join(aggregationsDir, "groupBy", `${key}.ts`), await formatTs(`export {${key}} from "./index";`));
+    await fs.writeFile(path15__namespace.join(aggregationsDir, "groupBy", `${key}.ts`), await formatTs(`export {${key}} from "./index${importExt}";`));
   }
-  await fs.writeFile(path15__namespace.join(aggregationsDir, "groupBy", "index.ts"), await formatTs(`import { Bucketing, BucketKey, Duration, Range, Rangeable } from "../Aggregations";` + reexportConsts(groupBys) + reexportTypes(groupBys, "<T extends BucketKey>") + `export {GroupKeyType} from "@osdk/legacy-client";
+  await fs.writeFile(path15__namespace.join(aggregationsDir, "groupBy", "index.ts"), await formatTs(`import { Bucketing, BucketKey, Duration, Range, Rangeable } from "../Aggregations${importExt}";` + reexportConsts(groupBys) + reexportTypes(groupBys, "<T extends BucketKey>") + `export {GroupKeyType} from "@osdk/legacy-client";
           `));
 }
-async function generateMetrics(fs, aggregationsDir) {
+async function generateMetrics(fs, aggregationsDir, importExt = "") {
   const metricsDir = path15__namespace.join(aggregationsDir, "metrics");
   await fs.mkdir(metricsDir, {
     recursive: true
@@ -288,80 +288,80 @@ async function generateMetrics(fs, aggregationsDir) {
   await fs.writeFile(path15__namespace.join(metricsDir, "metrics.ts"), await formatTs(`export {MetricValueType} from "@osdk/legacy-client";`));
   await fs.writeFile(path15__namespace.join(metricsDir, "ApproximateDistinctCountAggregatableProperty.ts"), await formatTs(reexportConsts(["ApproximateDistinctCountAggregatableProperty"]) + reexportTypes(["ApproximateDistinctCountAggregatableProperty"])));
   await fs.writeFile(path15__namespace.join(metricsDir, "MultipleAggregatableProperty.ts"), await formatTs(`
-        import { Double, MetricValue, MultipleAggregationsOperations } from "../Aggregations";
-        import { MetricValueType } from "./metrics";
+        import { Double, MetricValue, MultipleAggregationsOperations } from "../Aggregations${importExt}";
+        import { MetricValueType } from "./metrics/index${importExt}";
       ` + reexportConsts(["MultipleAggregatableProperty"]) + reexportTypes(["MultipleAggregatableProperty"], "<TResult extends MetricValue = Double>")));
   for (const typeName of ["DefaultAggregatableProperty", "LocalDatePropertyMetric", "NumericPropertyMetric", "TimestampPropertyMetric"]) {
     await fs.writeFile(path15__namespace.join(metricsDir, `${typeName}.ts`), await formatTs(`
-          import { MultipleAggregatableProperty } from "./MultipleAggregatableProperty";
+          import { MultipleAggregatableProperty } from "./MultipleAggregatableProperty${importExt}";
         ` + reexportConsts([typeName])));
   }
   await fs.writeFile(path15__namespace.join(metricsDir, "index.ts"), await formatTs(`
-      export * from "./ApproximateDistinctCountAggregatableProperty";
-      export * from "./DefaultAggregatableProperty";
-      export * from "./LocalDatePropertyMetric";
-      export * from "./metrics";
-      export * from "./MultipleAggregatableProperty";
-      export * from "./NumericPropertyMetric";
-      export * from "./TimestampPropertyMetric";
+      export * from "./ApproximateDistinctCountAggregatableProperty${importExt}";
+      export * from "./DefaultAggregatableProperty${importExt}";
+      export * from "./LocalDatePropertyMetric${importExt}";
+      export * from "./metrics${importExt}";
+      export * from "./MultipleAggregatableProperty${importExt}";
+      export * from "./NumericPropertyMetric${importExt}";
+      export * from "./TimestampPropertyMetric${importExt}";
       `));
 }
 
 // src/v1.1/backcompat/internal-foundry-ontology-runtime-dist/generateAggregationsDir.ts
-async function generateAggregationsDir(fs, runtimeDistDir) {
+async function generateAggregationsDir(fs, runtimeDistDir, importExt = "") {
   const aggregationsDir = path15__namespace.join(runtimeDistDir, "aggregations");
   await fs.mkdir(aggregationsDir, {
     recursive: true
   });
-  await generateGroupBy(fs, aggregationsDir);
+  await generateGroupBy(fs, aggregationsDir, importExt);
   await generateAggregationsAggregations(fs, aggregationsDir);
-  await generateMetrics(fs, aggregationsDir);
+  await generateMetrics(fs, aggregationsDir, importExt);
   await fs.writeFile(path15__namespace.join(aggregationsDir, "index.ts"), await formatTs(`
     ${""}
     ${""}
     
-    export * from "./Aggregations";
-    export * from "./ComputeStep";
-    export * from "./CountOperation";
-    export * from "./groupBy";
-    export * from "./internalAggregationRequest";
-    export * from "./metrics";
+    export * from "./Aggregations${importExt}";
+    export * from "./ComputeStep${importExt}";
+    export * from "./CountOperation${importExt}";
+    export * from "./groupBy/index${importExt}";
+    export * from "./internalAggregationRequest${importExt}";
+    export * from "./metrics/index${importExt}";
   `));
   await fs.writeFile(path15__namespace.join(aggregationsDir, "ComputeStep.ts"), await formatTs(`
-      import { ObjectSetDefinition } from "../baseTypes";
-      import { FoundryClientOptions } from "../client";
-      import { AggregateObjectsError, OntologyMetadata, Result } from "../ontologyProvider";
-      import { AggregationClause, AggregationResult, BucketGroup, BucketValue, InternalBucketing, Metrics, MetricValue } from "./Aggregations";
+      import { ObjectSetDefinition } from "../baseTypes/index${importExt}";
+      import { FoundryClientOptions } from "../client/${importExt}";
+      import { AggregateObjectsError, OntologyMetadata, Result } from "../ontologyProvider/index${importExt}";
+      import { AggregationClause, AggregationResult, BucketGroup, BucketValue, InternalBucketing, Metrics, MetricValue } from "./Aggregations${importExt}";
       ` + reexportConsts(["ComputeStep"]) + reexportTypes(["ComputeStep"], "<TBucketGroup extends BucketGroup, TMetrics extends Metrics | MetricValue> ") + reexportTypes(["AggregationComputeStep"], "<TBucketGroup extends BucketGroup, TMetrics extends Metrics | MetricValue>") + `
     
     `));
   await fs.writeFile(path15__namespace.join(aggregationsDir, "CountOperation.ts"), await formatTs(`` + reexportConsts(["CountOperation", "isCountOperation"]) + reexportTypes(["CountOperation"])));
   await fs.writeFile(path15__namespace.join(aggregationsDir, "internalAggregationRequest.ts"), await formatTs(reexportTypes(["InternalAggregationRequest"])));
 }
-async function generateAttachmentsDir(attachmentsDir, fs) {
+async function generateAttachmentsDir(attachmentsDir, fs, importExt = "") {
   await fs.mkdir(attachmentsDir, {
     recursive: true
   });
-  await fs.writeFile(path15__namespace.default.join(attachmentsDir, "index.ts"), await formatTs(`export * from "./Attachment";
-       export * from "./Attachments";
+  await fs.writeFile(path15__namespace.default.join(attachmentsDir, "index.ts"), await formatTs(`export * from "./Attachment${importExt}";
+       export * from "./Attachments${importExt}";
     `));
   await fs.writeFile(path15__namespace.default.join(attachmentsDir, "Attachment.ts"), await formatTs(reexportTypes(["Attachment", "AttachmentMetadata"])));
   await fs.writeFile(path15__namespace.default.join(attachmentsDir, "Attachments.ts"), await formatTs(reexportTypes(["Attachments"])));
 }
-async function generateGeoshapesDir(runtimeDistDir, fs) {
+async function generateGeoshapesDir(runtimeDistDir, fs, importExt = "") {
   await fs.mkdir(runtimeDistDir, {
     recursive: true
   });
-  await fs.writeFile(path15__namespace.join(runtimeDistDir, "index.ts"), await formatTs(`export * from "./Distance";
-       export * from "./GeoJson";
-       export * from "./GeometryCollection";
-       export * from "./GeoPoint";
-       export * from "./GeoShape";
-       export * from "./LineString";
-       export * from "./MultiGeoPoint";
-       export * from "./MultiLineString";
-       export * from "./MultiPolygon";
-       export * from "./Polygon";`));
+  await fs.writeFile(path15__namespace.join(runtimeDistDir, "index.ts"), await formatTs(`export * from "./Distance${importExt}";
+       export * from "./GeoJson${importExt}";
+       export * from "./GeometryCollection${importExt}";
+       export * from "./GeoPoint${importExt}";
+       export * from "./GeoShape${importExt}";
+       export * from "./LineString${importExt}";
+       export * from "./MultiGeoPoint${importExt}";
+       export * from "./MultiLineString${importExt}";
+       export * from "./MultiPolygon${importExt}";
+       export * from "./Polygon${importExt}";`));
   await fs.writeFile(path15__namespace.join(runtimeDistDir, "Distance.ts"), await formatTs(`` + reexportConsts(["Distance", "DistanceUnit"]) + reexportTypes(["Distance", "DistanceUnit"])));
   await fs.writeFile(path15__namespace.join(runtimeDistDir, "GeoJson.ts"), await formatTs(reexportTypes(["GeoJsonPoint", "GeoJsonPolygon", "GeoJsonLineString", "GeoJsonMultiPoint", "GeoJsonMultiPolygon", "GeoJsonMultiLineString", "GeoJsonGeometryCollection", "GeoJsonGeometry", "GeoJson"])));
   await fs.writeFile(path15__namespace.join(runtimeDistDir, "GeometryCollection.ts"), await formatTs(reexportConsts(["GeometryCollection"])));
@@ -373,37 +373,37 @@ async function generateGeoshapesDir(runtimeDistDir, fs) {
   await fs.writeFile(path15__namespace.join(runtimeDistDir, "MultiPolygon.ts"), await formatTs(reexportConsts(["MultiPolygon"]) + reexportTypes(["MultiPolygon"])));
   await fs.writeFile(path15__namespace.join(runtimeDistDir, "Polygon.ts"), await formatTs(reexportConsts(["Polygon"]) + reexportTypes(["LinearRing", "Polygon"])));
 }
-async function generateObjectSetDir(objectSetDir, fs) {
+async function generateObjectSetDir(objectSetDir, fs, importExt = "") {
   await fs.mkdir(objectSetDir, {
     recursive: true
   });
   await fs.writeFile(path15__namespace.default.join(objectSetDir, "index.ts"), await formatTs(`
-    export * from "./ObjectSetDefinition";
-    export * from "./OntologyObjectSet";
+    export * from "./ObjectSetDefinition${importExt}";
+    export * from "./OntologyObjectSet${importExt}";
     `));
   await fs.writeFile(path15__namespace.default.join(objectSetDir, "ObjectSetDefinition.ts"), await formatTs(reexportTypes(["BaseObjectSetDefinition", "ReferenceObjectSetDefinition", "StaticObjectSetDefinition", "IntersectObjectSetDefinition", "SubtractObjectSetDefinition", "SearchAroundObjectSetDefinition", "FilterObjectSetDefinition", "ObjectSetDefinition"])));
   await fs.writeFile(path15__namespace.default.join(objectSetDir, "OntologyObjectSet.ts"), await formatTs(reexportTypes(["OntologyObjectSet"])));
 }
-async function generateSharedObjectCodeDir(sharedObjectCodeDir, fs) {
+async function generateSharedObjectCodeDir(sharedObjectCodeDir, fs, importExt = "") {
   await fs.mkdir(sharedObjectCodeDir, {
     recursive: true
   });
   await fs.writeFile(path15__namespace.default.join(sharedObjectCodeDir, "index.ts"), await formatTs(`
-    export * from "./FilteredPropertiesTerminalOperations";
+    export * from "./FilteredPropertiesTerminalOperations${importExt}";
     `));
-  await fs.writeFile(path15__namespace.default.join(sharedObjectCodeDir, "FilteredPropertiesTerminalOperations.ts"), await formatTs(`import { OntologyObject } from "../OntologyObject` + reexportTypes(["FilteredPropertiesTerminalOperations", "FilteredPropertiesTerminalOperationsWithGet"], "<T extends OntologyObject, V extends Array<keyof T>>")));
+  await fs.writeFile(path15__namespace.default.join(sharedObjectCodeDir, "FilteredPropertiesTerminalOperations.ts"), await formatTs(`import { OntologyObject } from "../OntologyObject${importExt}` + reexportTypes(["FilteredPropertiesTerminalOperations", "FilteredPropertiesTerminalOperationsWithGet"], "<T extends OntologyObject, V extends Array<keyof T>>")));
 }
-async function generateTimeSeriesDir(timeseriesDir, fs) {
+async function generateTimeSeriesDir(timeseriesDir, fs, importExt = "") {
   await fs.mkdir(timeseriesDir, {
     recursive: true
   });
   await fs.writeFile(path15__namespace.join(timeseriesDir, "index.ts"), await formatTs(`
-    export * from "./TimeSeries";
-    export * from "./TimeSeriesDuration";
-    export * from "./TimeSeriesPoint";
+    export * from "./TimeSeries${importExt}";
+    export * from "./TimeSeriesDuration${importExt}";
+    export * from "./TimeSeriesPoint${importExt}";
     ${""}
-    export * from "./TimeSeriesQuery";
-    export * from "./TimeSeriesTerminalOperations";
+    export * from "./TimeSeriesQuery${importExt}";
+    export * from "./TimeSeriesTerminalOperations${importExt}";
   `));
   await fs.writeFile(path15__namespace.join(timeseriesDir, "TimeSeries.ts"), await formatTs(reexportTypes(["TimeSeries"], `<T extends number | string>`)));
   await fs.writeFile(path15__namespace.join(timeseriesDir, "TimeSeriesDuration.ts"), await formatTs(reexportTypes([`WhenUnit`, `DurationUnit`, `TimeSeriesDuration`])));
@@ -413,67 +413,67 @@ async function generateTimeSeriesDir(timeseriesDir, fs) {
 }
 
 // src/v1.1/backcompat/internal-foundry-ontology-runtime-dist/generateBaseTypesDir.ts
-async function generateBaseTypesDir(runtimeDistDir, fs) {
+async function generateBaseTypesDir(runtimeDistDir, fs, importExt = "") {
   const baseTypesDir = path15__namespace.join(runtimeDistDir, "baseTypes");
   await fs.mkdir(baseTypesDir, {
     recursive: true
   });
-  await fs.writeFile(path15__namespace.join(baseTypesDir, "index.ts"), await formatTs(`export * from "./ActionType";
-      export * from "./attachments";
-      export * from "./geoshapes";
-      export * from "./links";
-      export * from "./localDate";
-      export * from "./objectset";
-      export * from "./ObjectType";
-      export * from "./OntologyObject";
-      export * from "./Queries";
-      export * from "./timeseries";
-      export * from "./timestamp";`));
+  await fs.writeFile(path15__namespace.join(baseTypesDir, "index.ts"), await formatTs(`export * from "./ActionType${importExt}";
+      export * from "./attachments/index${importExt}";
+      export * from "./geoshapes/index${importExt}";
+      export * from "./links${importExt}";
+      export * from "./localDate${importExt}";
+      export * from "./objectset/index${importExt}";
+      export * from "./ObjectType${importExt}";
+      export * from "./OntologyObject${importExt}";
+      export * from "./Queries${importExt}";
+      export * from "./timeseries/index${importExt}";
+      export * from "./timestamp${importExt}";`));
   const geoshapesDir = path15__namespace.join(baseTypesDir, "geoshapes");
-  await generateGeoshapesDir(geoshapesDir, fs);
+  await generateGeoshapesDir(geoshapesDir, fs, importExt);
   const timeseriesDir = path15__namespace.join(baseTypesDir, "timeseries");
-  await generateTimeSeriesDir(timeseriesDir, fs);
+  await generateTimeSeriesDir(timeseriesDir, fs, importExt);
   const attachmentsDir = path15__namespace.join(baseTypesDir, "attachments");
-  await generateAttachmentsDir(attachmentsDir, fs);
+  await generateAttachmentsDir(attachmentsDir, fs, importExt);
   const objectSetDir = path15__namespace.join(baseTypesDir, "objectset");
-  await generateObjectSetDir(objectSetDir, fs);
+  await generateObjectSetDir(objectSetDir, fs, importExt);
   const sharedObjectCodeDir = path15__namespace.join(baseTypesDir, "sharedObjectCode");
-  await generateSharedObjectCodeDir(sharedObjectCodeDir, fs);
-  await fs.writeFile(path15__namespace.join(baseTypesDir, "ActionType.ts"), await formatTs(`import { OntologyObject } from "./OntologyObject";
+  await generateSharedObjectCodeDir(sharedObjectCodeDir, fs, importExt);
+  await fs.writeFile(path15__namespace.join(baseTypesDir, "ActionType.ts"), await formatTs(`import { OntologyObject } from "./OntologyObject${importExt}";
       ` + reexportConsts(["ActionExecutionMode", "ReturnEditsMode", "ActionValidationResult"]) + reexportTypes(["ActionExecutionOptions", "ValidationResponse", "BulkEdits"]) + reexportTypes(["CreatedObjectEdits", "ModifiedObjectEdits"], "<T extends OntologyObject>") + reexportTypes(["Edits"], "<TAddedObjects extends OntologyObject | void, TModifiedObjects extends OntologyObject | void>") + reexportTypes(["ActionResponse"], "<TEdits extends Edits<any, any> | undefined = undefined>", "<TEdits>") + reexportTypes(["ActionResponseFromOptions"], "<TOptions extends ActionExecutionOptions | undefined = undefined, TEdits extends Edits<any, any> | undefined = undefined>", "<TOptions, TEdits>")));
   await fs.writeFile(path15__namespace.join(baseTypesDir, "OntologyObject.ts"), await formatTs(reexportTypes(["OntologyObject"]) + reexportConsts(["isOntologyObject"])));
-  await fs.writeFile(path15__namespace.join(baseTypesDir, "links.ts"), await formatTs(`import { OntologyObject } from "./OntologyObject` + reexportTypes(["SingleLink", "MultiLink"], "<T extends OntologyObject = OntologyObject>")));
+  await fs.writeFile(path15__namespace.join(baseTypesDir, "links.ts"), await formatTs(`import { OntologyObject } from "./OntologyObject${importExt}` + reexportTypes(["SingleLink", "MultiLink"], "<T extends OntologyObject = OntologyObject>")));
   await fs.writeFile(path15__namespace.join(baseTypesDir, "localDate.ts"), await formatTs(reexportConsts(["LocalDate"]) + reexportTypes(["LocalDate"])));
   await fs.writeFile(path15__namespace.join(baseTypesDir, "timestamp.ts"), await formatTs(reexportConsts(["Timestamp"]) + reexportTypes(["Timestamp"])));
-  await fs.writeFile(path15__namespace.join(baseTypesDir, "Queries.ts"), await formatTs(`import { BucketValue, Range, Rangeable } from "../aggregations";
+  await fs.writeFile(path15__namespace.join(baseTypesDir, "Queries.ts"), await formatTs(`import { BucketValue, Range, Rangeable } from "../aggregations/index${importExt}";
       ` + reexportTypes(["QueryResponse"], "<T>") + reexportTypes(["BaseBucket"], "<K, V>") + reexportTypes(["NestedBucket"], "<TGroupKey, TSegmentKey, TValue extends BucketValue>") + reexportTypes(["TwoDimensionalAggregation"], "<TGroupKey extends QueryBucketKey, TValue extends BucketValue = number>") + reexportTypes(["ThreeDimensionalAggregation"], "<TGroupKey extends QueryBucketKey, TSegmentKey extends QueryBucketKey, TValue extends BucketValue = number>") + reexportTypes(["QueryBucketKey"])));
-  await fs.writeFile(path15__namespace.join(baseTypesDir, "ObjectType.ts"), await formatTs(`import { OntologyObject } from "./OntologyObject";` + reexportTypes(["BaseType", "StringType", "IntegerType", "DateType", "BooleanType", "ByteType", "DecimalType", "FloatType", "TimestampType", "ShortType", "LongType", "DoubleType", "GeoPointType", "GeoShapeType", "AttachmentType", "ObjectType", "StructField", "QueryBucketRangeableType", "QueryBucketKeyType", "QueryBucketValueType", "AllValueTypes", "OntologyType", "ObjectTypeProperties", "StructType"]) + reexportTypes(["TimeSeriesType", "ArrayType", "SetType"], "<T extends BaseType>") + reexportTypes(["Property"], "<TType extends OntologyType = OntologyType>") + reexportTypes(["BaseObjectType"], "<TOntologyObject extends OntologyObject = OntologyObject>") + reexportTypes(["ObjectSetType"], "<T extends ObjectType>") + reexportTypes(["RangeType"], "<T extends QueryBucketRangeableType>") + reexportTypes(["TwoDimensionalAggregationType"], "<TGroupKey extends QueryBucketKeyType, TValue extends QueryBucketValueType>") + reexportTypes(["ThreeDimensionalAggregationType"], "<TGroupKey extends QueryBucketKeyType, TSegmentKey extends QueryBucketKeyType, TValue extends QueryBucketValueType>")));
+  await fs.writeFile(path15__namespace.join(baseTypesDir, "ObjectType.ts"), await formatTs(`import { OntologyObject } from "./OntologyObject${importExt}";` + reexportTypes(["BaseType", "StringType", "IntegerType", "DateType", "BooleanType", "ByteType", "DecimalType", "FloatType", "TimestampType", "ShortType", "LongType", "DoubleType", "GeoPointType", "GeoShapeType", "AttachmentType", "ObjectType", "StructField", "QueryBucketRangeableType", "QueryBucketKeyType", "QueryBucketValueType", "AllValueTypes", "OntologyType", "ObjectTypeProperties", "StructType"]) + reexportTypes(["TimeSeriesType", "ArrayType", "SetType"], "<T extends BaseType>") + reexportTypes(["Property"], "<TType extends OntologyType = OntologyType>") + reexportTypes(["BaseObjectType"], "<TOntologyObject extends OntologyObject = OntologyObject>") + reexportTypes(["ObjectSetType"], "<T extends ObjectType>") + reexportTypes(["RangeType"], "<T extends QueryBucketRangeableType>") + reexportTypes(["TwoDimensionalAggregationType"], "<TGroupKey extends QueryBucketKeyType, TValue extends QueryBucketValueType>") + reexportTypes(["ThreeDimensionalAggregationType"], "<TGroupKey extends QueryBucketKeyType, TSegmentKey extends QueryBucketKeyType, TValue extends QueryBucketValueType>")));
 }
-async function generateClientDir(runtimeDistDir, fs) {
+async function generateClientDir(runtimeDistDir, fs, importExt = "") {
   const pagingDir = path15__namespace.default.join(runtimeDistDir, "client");
   await fs.mkdir(pagingDir, {
     recursive: true
   });
-  await fs.writeFile(path15__namespace.default.join(pagingDir, "index.ts"), await formatTs(`export * from "./clientOptions";`));
+  await fs.writeFile(path15__namespace.default.join(pagingDir, "index.ts"), await formatTs(`export * from "./clientOptions${importExt}";`));
   await fs.writeFile(path15__namespace.default.join(pagingDir, "clientOptions.ts"), await formatTs(`import {Auth} from "@osdk/legacy-client";` + reexportTypes(["FoundryClientOptions"], "<TAuth extends Auth = Auth>")));
 }
-async function generateFiltersDir(runtimeDistDir, fs) {
+async function generateFiltersDir(runtimeDistDir, fs, importExt = "") {
   const pagingDir = path15__namespace.default.join(runtimeDistDir, "filters");
   await fs.mkdir(pagingDir, {
     recursive: true
   });
-  await fs.writeFile(path15__namespace.default.join(pagingDir, "index.ts"), await formatTs(`export * from "./ArrayFilter";
-      export * from "./AttachmentFilter";
-      export * from "./BooleanFilter";
-      export * from "./DateTimeFilters";
-      export * from "./Filters";
-      export * from "./GeoPointFilter";
-      export * from "./GeoShapeFilter";
-      export * from "./NumericFilter";
-      export * from "./Op";
-      export * from "./OrderByOption";
-      export * from "./StringFilter";`));
-  await fs.writeFile(path15__namespace.default.join(pagingDir, "ArrayFilter.ts"), await formatTs(`import { Attachment, GeoPoint, GeoShape, LocalDate, Timestamp } from "../baseTypes";` + reexportConsts(["ArrayFilter"]) + reexportTypes(["ArrayFilter"], "<T extends string | number | Timestamp | LocalDate | boolean | GeoShape | GeoPoint | Attachment>")));
+  await fs.writeFile(path15__namespace.default.join(pagingDir, "index.ts"), await formatTs(`export * from "./ArrayFilter${importExt}";
+      export * from "./AttachmentFilter${importExt}";
+      export * from "./BooleanFilter${importExt}";
+      export * from "./DateTimeFilters${importExt}";
+      export * from "./Filters${importExt}";
+      export * from "./GeoPointFilter${importExt}";
+      export * from "./GeoShapeFilter${importExt}";
+      export * from "./NumericFilter${importExt}";
+      export * from "./Op${importExt}";
+      export * from "./OrderByOption${importExt}";
+      export * from "./StringFilter${importExt}";`));
+  await fs.writeFile(path15__namespace.default.join(pagingDir, "ArrayFilter.ts"), await formatTs(`import { Attachment, GeoPoint, GeoShape, LocalDate, Timestamp } from "../baseTypes/index${importExt}";` + reexportConsts(["ArrayFilter"]) + reexportTypes(["ArrayFilter"], "<T extends string | number | Timestamp | LocalDate | boolean | GeoShape | GeoPoint | Attachment>")));
   await fs.writeFile(path15__namespace.default.join(pagingDir, "AttachmentFilter.ts"), await formatTs(reexportConsts(["AttachmentFilter"]) + reexportTypes(["AttachmentFilter"])));
   await fs.writeFile(path15__namespace.default.join(pagingDir, "BooleanFilter.ts"), await formatTs(reexportConsts(["BooleanFilter"]) + reexportTypes(["BooleanFilter"])));
   await fs.writeFile(path15__namespace.default.join(pagingDir, "GeoPointFilter.ts"), await formatTs(reexportConsts(["GeoPointFilter"]) + reexportTypes(["GeoPointFilter", "BoundingBox"])));
@@ -497,7 +497,7 @@ async function generateResult(fs, ontologyProviderDir) {
 }
 
 // src/v1.1/backcompat/internal-foundry-ontology-runtime-dist/generateOntologyProviderDir.ts
-async function generateOntologyProviderDir(fs, runtimeDistDir) {
+async function generateOntologyProviderDir(fs, runtimeDistDir, importExt = "") {
   const ontologyProviderDir = path15__namespace.join(runtimeDistDir, "ontologyProvider");
   await fs.mkdir(ontologyProviderDir, {
     recursive: true
@@ -507,55 +507,55 @@ async function generateOntologyProviderDir(fs, runtimeDistDir) {
   await generateResult(fs, ontologyProviderDir);
   await fs.writeFile(path15__namespace.join(ontologyProviderDir, "index.ts"), await formatTs(`
     ${""}
-      export * from "./Errors";
-      export * from "./OntologyMetadata";
+      export * from "./Errors${importExt}";
+      export * from "./OntologyMetadata${importExt}";
       ${""}
     ${""}
-      // export * from "./Result";
+      // export * from "./Result${importExt}";
   `));
 }
-async function generatePagingDir(runtimeDistDir, fs) {
+async function generatePagingDir(runtimeDistDir, fs, importExt = "") {
   const pagingDir = path15__namespace.join(runtimeDistDir, "paging");
   await fs.mkdir(pagingDir, {
     recursive: true
   });
-  await fs.writeFile(path15__namespace.join(pagingDir, "index.ts"), await formatTs(`export * from "./Page";`));
+  await fs.writeFile(path15__namespace.join(pagingDir, "index.ts"), await formatTs(`export * from "./Page${importExt}";`));
   await fs.writeFile(path15__namespace.join(pagingDir, "Page.ts"), await formatTs(reexportTypes(["Page"], "<T>")));
 }
 
 // src/v1.1/backcompat/generateOntologyRuntimeDistDir.ts
-async function generateOntologyRuntimeDistDir(outDir, fs) {
+async function generateOntologyRuntimeDistDir(outDir, fs, importExt = "") {
   const runtimeDistDir = path15__namespace.join(outDir, "internal", "@foundry", "ontology-runtime", "dist");
   await fs.mkdir(runtimeDistDir, {
     recursive: true
   });
-  await generateOntologyProviderDir(fs, runtimeDistDir);
-  await generateAggregationsDir(fs, runtimeDistDir);
-  await generatePagingDir(runtimeDistDir, fs);
-  await generateBaseTypesDir(runtimeDistDir, fs);
-  await generateClientDir(runtimeDistDir, fs);
-  await generateFiltersDir(runtimeDistDir, fs);
+  await generateOntologyProviderDir(fs, runtimeDistDir, importExt);
+  await generateAggregationsDir(fs, runtimeDistDir, importExt);
+  await generatePagingDir(runtimeDistDir, fs, importExt);
+  await generateBaseTypesDir(runtimeDistDir, fs, importExt);
+  await generateClientDir(runtimeDistDir, fs, importExt);
+  await generateFiltersDir(runtimeDistDir, fs, importExt);
   await fs.writeFile(
     path15__namespace.join(runtimeDistDir, "index.ts"),
     // TRASHFIXME
     await formatTs(`
-      export * from "./aggregations";
-      export * from "./baseTypes";
+      export * from "./aggregations/index${importExt}";
+      export * from "./baseTypes/index${importExt}";
       ${""}
-      // export * from "./filters";
+      // export * from "./filters/index${importExt}";
       ${""}
       ${""}
     
-      export * from "./ontologyProvider";
-      export * from "./paging";
+      export * from "./ontologyProvider/index${importExt}";
+      export * from "./paging/index${importExt}";
 `)
   );
 }
 
 // src/v1.1/generateBackCompatDeprecatedExports.ts
-async function generateBackCompatDeprecatedExports(fs, outDir) {
-  await generateOntologyRuntimeDistDir(outDir, fs);
-  await generateOAuthClientDistDir(outDir, fs);
+async function generateBackCompatDeprecatedExports(fs, outDir, importExt = "") {
+  await generateOntologyRuntimeDistDir(outDir, fs, importExt);
+  await generateOAuthClientDistDir(outDir, fs, importExt);
 }
 async function generateFoundryClientFile(fs, outDir, importExt = "") {
   await fs.writeFile(path15__namespace.default.join(outDir, "FoundryClient.ts"), await formatTs(`
@@ -1012,10 +1012,10 @@ function isReservedKeyword(name) {
 }
 
 // src/v1.1/wireObjectTypeV2ToV1ObjectInterfaceString.ts
-function wireObjectTypeV2ToObjectInterfaceStringV1(objectTypeWithLinks) {
+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}";`).join("\n")}
+${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}";
@@ -1093,7 +1093,7 @@ async function generatePerObjectInterfaceAndDataFiles(ontology, fs, outDir, impo
     object.linkTypes;
     await fs.writeFile(path15__namespace.default.join(outDir, `${object.objectType.apiName}.ts`), await formatTs(`
         import type { ObjectTypeDefinition } from "@osdk/api";
-        ${wireObjectTypeV2ToObjectInterfaceStringV1(object)}
+        ${wireObjectTypeV2ToObjectInterfaceStringV1(object, importExt)}
 
         ${wireObjectTypeV2ToSdkObjectConst(object)}
         `));
@@ -1483,7 +1483,7 @@ async function generateClientSdkVersionOneDotOne(ontology, fs, outDir, packageTy
   await generateQueries(sanitizedOntology, fs, queriesDir, importExt);
   await generatePerQueryDataFiles(sanitizedOntology, fs, queriesDir, importExt);
   await generateIndexFile(fs, outDir, importExt);
-  await generateBackCompatDeprecatedExports(fs, outDir);
+  await generateBackCompatDeprecatedExports(fs, outDir, importExt);
 }
 
 // src/shared/UNSTABLE_wireInterfaceTypeV2ToSdkObjectConst.ts
@@ -1516,7 +1516,7 @@ async function generateClientSdkVersionTwoPointZero(ontology, fs, outDir, packag
   const sanitizedOntology = sanitizeMetadata(ontology);
   const objectNames = Object.keys(sanitizedOntology.objectTypes);
   const actionNames = Object.keys(sanitizedOntology.actionTypes);
-  const interfaceNames = Object.keys(sanitizedOntology.__UNSTABLE_interfaceTypes ?? {});
+  const interfaceNames = Object.keys(sanitizedOntology.interfaceTypes ?? {});
   const importExt = packageType === "module" ? ".js" : "";
   await fs.mkdir(outDir, {
     recursive: true
@@ -1602,7 +1602,7 @@ async function generateOntologyInterfaces(fs, outDir, interfaceNames, ontology,
     recursive: true
   });
   for (const name of interfaceNames) {
-    const obj = ontology.__UNSTABLE_interfaceTypes[name];
+    const obj = ontology.interfaceTypes[name];
     await fs.writeFile(path15__namespace.default.join(interfacesDir, `${name}.ts`), await formatTs(`
     
       import type { InterfaceDefinition } from "@osdk/api";
@@ -1611,7 +1611,7 @@ async function generateOntologyInterfaces(fs, outDir, interfaceNames, ontology,
     `));
   }
   await fs.writeFile(interfacesDir + ".ts", await formatTs(`
-    ${Object.keys(ontology.__UNSTABLE_interfaceTypes ?? {}).map((apiName) => `export * from "./interfaces/${apiName}${importExt}";`).join("\n")}
+    ${Object.keys(ontology.interfaceTypes ?? {}).map((apiName) => `export * from "./interfaces/${apiName}${importExt}";`).join("\n")}
     `));
 }