@wictorwilen/cocogen 1.0.0

package/dist/init/templates/ts/package.json.ejs

@@ -0,0 +1,25 @@
+{
+  "name": "<%= projectName %>",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "provision": "npm run build && node dist/cli.js provision",
+    "ingest": "npm run build && node dist/cli.js ingest",
+<% if (isPeopleConnector) { -%>
+    "register-profile-source": "npm run build && node dist/cli.js register-profile-source",
+<% } -%>
+    "delete": "npm run build && node dist/cli.js delete"
+  },
+  "dependencies": {
+    "@azure/identity": "^4.13.0",
+    "commander": "^14.0.2",
+    "dotenv": "^17.2.3",
+    "csv-parse": "^6.1.0"
+  },
+  "devDependencies": {
+    "@wictorwilen/cocogen": "^1.0.0",
+    "typescript": "^5.9.3",
+    "@types/node": "^25.0.9"
+  }
+}

package/dist/init/templates/ts/src/cli.ts.ejs

@@ -0,0 +1,299 @@
+import "dotenv/config";
+
+import { Command } from "commander";
+import { ClientSecretCredential } from "@azure/identity";
+
+import type { Item } from "./schema/model.js";
+import {
+  contentCategory,
+  connectionId as defaultConnectionId,
+  connectionDescription as defaultConnectionDescription,
+  profileSourceWebUrl as defaultProfileSourceWebUrl,
+  profileSourceDisplayName as defaultProfileSourceDisplayName,
+  profileSourcePriority as defaultProfileSourcePriority,
+  schemaPayload
+} from "./schema/index.js";
+import { getItemId, toExternalItem } from "./schema/itemPayload.js";
+import { CsvItemSource } from "./datasource/csvItemSource.js";
+
+const GRAPH_BASE_URL = <%= JSON.stringify(graphBaseUrl) %>;
+const PROFILE_SOURCE_URL_PREFIX = `${GRAPH_BASE_URL}/admin/people/profileSources`;
+
+function requiredEnv(name: string): string {
+  const value = process.env[name];
+  if (!value) throw new Error(`Missing env var: ${name}`);
+  return value;
+}
+
+function resolveConnectionId(): string {
+  const value = process.env.CONNECTION_ID ?? defaultConnectionId;
+  if (!value) throw new Error("Missing env var: CONNECTION_ID");
+  return value;
+}
+
+function resolveConnectionName(): string {
+  return requiredEnv("CONNECTION_NAME");
+}
+
+function resolveConnectionDescription(): string {
+  const value = process.env.CONNECTION_DESCRIPTION ?? defaultConnectionDescription;
+  if (!value) throw new Error("Missing env var: CONNECTION_DESCRIPTION");
+  return value;
+}
+
+function resolveProfileSourceWebUrl(): string {
+  const value = process.env.PROFILE_SOURCE_WEB_URL ?? defaultProfileSourceWebUrl;
+  if (!value) throw new Error("Missing env var: PROFILE_SOURCE_WEB_URL");
+  return value;
+}
+
+function resolveProfileSourcePriority(): "first" | "last" {
+  const raw = process.env.PROFILE_SOURCE_PRIORITY ?? defaultProfileSourcePriority ?? "first";
+  const value = raw.trim().toLowerCase();
+  if (value !== "first" && value !== "last") {
+    throw new Error("Invalid PROFILE_SOURCE_PRIORITY: expected 'first' or 'last'");
+  }
+  return value;
+}
+
+async function getAccessToken(): Promise<string> {
+  const tenantId = requiredEnv("TENANT_ID");
+  const clientId = requiredEnv("CLIENT_ID");
+  const clientSecret = requiredEnv("CLIENT_SECRET");
+
+  const credential = new ClientSecretCredential(tenantId, clientId, clientSecret);
+  const token = await credential.getToken("https://graph.microsoft.com/.default");
+  if (!token?.token) throw new Error("Failed to acquire access token");
+  return token.token;
+}
+
+async function graphRequest(method: string, url: string, body?: unknown): Promise<Response> {
+  const token = await getAccessToken();
+  return fetch(url, {
+    method,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    },
+    body: body ? JSON.stringify(body) : undefined
+  });
+}
+
+<% if (isPeopleConnector) { -%>
+async function listProfilePropertySettings(): Promise<Array<{ id: string; prioritizedSourceUrls: string[] }>> {
+  const res = await graphRequest("GET", `${GRAPH_BASE_URL}/admin/people/profilePropertySettings`);
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Failed to list profile property settings (HTTP ${res.status}): ${text}`);
+  }
+  const json = (await res.json()) as { value?: Array<{ id?: string; prioritizedSourceUrls?: string[] }> };
+  return (json.value ?? [])
+    .filter((entry) => typeof entry.id === "string")
+    .map((entry) => ({
+      id: entry.id as string,
+      prioritizedSourceUrls: Array.isArray(entry.prioritizedSourceUrls) ? entry.prioritizedSourceUrls : [],
+    }));
+}
+
+async function registerProfileSource(connectionId: string): Promise<void> {
+  const webUrl = resolveProfileSourceWebUrl();
+  const displayName =
+    process.env.PROFILE_SOURCE_DISPLAY_NAME ?? defaultProfileSourceDisplayName ?? requiredEnv("CONNECTION_NAME");
+  const priority = resolveProfileSourcePriority();
+
+  const payload: any = {
+    sourceId: connectionId,
+    displayName,
+    webUrl
+  };
+
+  const create = await graphRequest("POST", `${GRAPH_BASE_URL}/admin/people/profileSources`, payload);
+  if (!create.ok && create.status !== 409) {
+    const text = await create.text();
+    throw new Error(`Failed to register profile source (HTTP ${create.status}): ${text}`);
+  }
+
+  const sourceUrl = `${PROFILE_SOURCE_URL_PREFIX}(sourceId='${connectionId}')`;
+  const settings = await listProfilePropertySettings();
+  for (const setting of settings) {
+    const existing = setting.prioritizedSourceUrls.filter((value) => value !== sourceUrl);
+    const updated = priority === "first" ? [sourceUrl, ...existing] : [...existing, sourceUrl];
+    const res = await graphRequest(
+      "PATCH",
+      `${GRAPH_BASE_URL}/admin/people/profilePropertySettings/${setting.id}`,
+      {
+        "@odata.type": "#microsoft.graph.profilePropertySetting",
+        prioritizedSourceUrls: updated
+      }
+    );
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Failed to update profile property setting ${setting.id} (HTTP ${res.status}): ${text}`);
+    }
+  }
+}
+
+async function unregisterProfileSource(connectionId: string): Promise<void> {
+  const sourceUrl = `${PROFILE_SOURCE_URL_PREFIX}(sourceId='${connectionId}')`;
+  const settings = await listProfilePropertySettings();
+  for (const setting of settings) {
+    const updated = setting.prioritizedSourceUrls.filter((value) => value !== sourceUrl);
+    const res = await graphRequest(
+      "PATCH",
+      `${GRAPH_BASE_URL}/admin/people/profilePropertySettings/${setting.id}`,
+      {
+        "@odata.type": "#microsoft.graph.profilePropertySetting",
+        prioritizedSourceUrls: updated
+      }
+    );
+    if (!res.ok) {
+      const text = await res.text();
+      throw new Error(`Failed to update profile property setting ${setting.id} (HTTP ${res.status}): ${text}`);
+    }
+  }
+
+  const res = await graphRequest(
+    "DELETE",
+    `${PROFILE_SOURCE_URL_PREFIX}(sourceId='${connectionId}')`
+  );
+  if (!res.ok && res.status !== 404) {
+    const text = await res.text();
+    throw new Error(`Failed to delete profile source (HTTP ${res.status}): ${text}`);
+  }
+}
+<% } -%>
+
+async function ensureConnection(connectionId: string): Promise<void> {
+  const name = resolveConnectionName();
+  const description = resolveConnectionDescription();
+
+  const payload: any = {
+    id: connectionId,
+    name,
+    description
+  };
+
+  if (contentCategory) payload.contentCategory = contentCategory;
+
+  const createUrl = `${GRAPH_BASE_URL}/external/connections`;
+  const create = await graphRequest("POST", createUrl, payload);
+  if (!create.ok) {
+    if (create.status !== 409) {
+      const text = await create.text();
+      throw new Error(`Failed to create connection (HTTP ${create.status}): ${text}`);
+    }
+  }
+}
+
+async function patchSchema(connectionId: string): Promise<void> {
+  const schemaUrl = `${GRAPH_BASE_URL}/external/connections/${connectionId}/schema`;
+  const res = await graphRequest("PATCH", schemaUrl, schemaPayload);
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Failed to patch schema (HTTP ${res.status}): ${text}`);
+  }
+}
+
+async function provision(): Promise<void> {
+  const connectionId = resolveConnectionId();
+  await ensureConnection(connectionId);
+  await patchSchema(connectionId);
+<% if (isPeopleConnector) { -%>
+  await registerProfileSource(connectionId);
+<% } -%>
+  console.log("ok: provisioned");
+}
+
+async function deleteConnection(): Promise<void> {
+  const connectionId = resolveConnectionId();
+<% if (isPeopleConnector) { -%>
+  await unregisterProfileSource(connectionId);
+<% } -%>
+  const res = await graphRequest("DELETE", `${GRAPH_BASE_URL}/external/connections/${connectionId}`);
+  if (!res.ok && res.status !== 404) {
+    const text = await res.text();
+    throw new Error(`Failed to delete connection (HTTP ${res.status}): ${text}`);
+  }
+  console.log("ok: deleted");
+}
+
+async function putItem(connectionId: string, item: Item, verbose: boolean): Promise<void> {
+  const itemId = getItemId(item);
+  const url = `${GRAPH_BASE_URL}/external/connections/${connectionId}/items/${encodeURIComponent(itemId)}`;
+
+  const payload = toExternalItem(item);
+  if (verbose) {
+    console.log("verbose: PUT", url);
+    console.log("verbose: payload", JSON.stringify(payload, null, 2));
+  }
+
+  const res = await graphRequest("PUT", url, payload);
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Failed to ingest item '${itemId}' (HTTP ${res.status}): ${text}`);
+  }
+}
+
+async function ingest(options: {
+  csvPath?: string;
+  dryRun?: boolean;
+  limit?: number;
+  verbose?: boolean;
+}): Promise<void> {
+  const connectionId = options.dryRun ? "dry-run" : resolveConnectionId();
+  // Swap this for any ItemSource implementation (API, DB, queue, etc.).
+  const source = new CsvItemSource(options.csvPath ?? process.env.CSV_PATH ?? "data.csv");
+  let count = 0;
+  for await (const item of source.getItems()) {
+    if (options.limit && count >= options.limit) break;
+    if (!options.dryRun) {
+      await putItem(connectionId, item, Boolean(options.verbose));
+    } else if (options.verbose) {
+      console.log("verbose: DRY RUN item", JSON.stringify(toExternalItem(item), null, 2));
+    }
+    count++;
+  }
+
+  console.log("ok: ingested " + count + " item(s)");
+}
+
+const program = new Command();
+program.name("connector").description("Connector CLI generated by cocogen");
+
+program
+  .command("provision")
+  .description("Create or update the connection and schema")
+  .action(() => provision());
+
+program
+  .command("ingest")
+  .description("Ingest items from CSV")
+  .option("--csv <path>", "CSV path")
+  .option("--dry-run", "Build payloads but do not send to Graph")
+  .option("--limit <n>", "Limit number of items", (value) => Number(value))
+  .option("--verbose", "Print payloads sent to Graph")
+  .action((options: { csv?: string; dryRun?: boolean; limit?: number; verbose?: boolean }) =>
+    ingest({
+      csvPath: options.csv,
+      dryRun: options.dryRun,
+      limit: options.limit,
+      verbose: options.verbose,
+    })
+  );
+
+<% if (isPeopleConnector) { -%>
+program
+  .command("register-profile-source")
+  .description("Register the connection as a profile source (people connectors)")
+  .action(() => registerProfileSource(resolveConnectionId()));
+<% } -%>
+
+program
+  .command("delete")
+  .description("Delete the connection (and profile source for people connectors)")
+  .action(() => deleteConnection());
+
+program.parseAsync(process.argv).catch((e) => {
+  console.error("error:", e instanceof Error ? e.message : String(e));
+  process.exitCode = 1;
+});

package/dist/init/templates/ts/src/datasource/csvItemSource.ts.ejs

@@ -0,0 +1,25 @@
+import { createReadStream } from "node:fs";
+import { parse } from "csv-parse";
+
+import type { Item } from "../schema/model.js";
+import type { ItemSource } from "./itemSource.js";
+import { fromCsvRow } from "../schema/fromCsvRow.js";
+
+// CSV-based datasource (default). Replace with your own ItemSource as needed.
+export class CsvItemSource implements ItemSource {
+  constructor(private readonly filePath: string) {}
+
+  async *getItems(): AsyncIterable<Item> {
+    const parser = parse({
+      columns: true,
+      skip_empty_lines: true,
+      trim: true
+    });
+
+    const stream = createReadStream(this.filePath, { encoding: "utf8" }).pipe(parser);
+
+    for await (const row of stream as AsyncIterable<Record<string, unknown>>) {
+      yield fromCsvRow(row);
+    }
+  }
+}

package/dist/init/templates/ts/src/datasource/itemSource.ts.ejs

@@ -0,0 +1,8 @@
+import type { Item } from "../schema/model.js";
+
+// Contract for any datasource that yields Items for ingestion.
+// Implement this interface to swap CSV for an API, database, or other system.
+export interface ItemSource {
+  // Return items as an async iterable (streaming preferred).
+  getItems(): AsyncIterable<Item>;
+}

package/dist/init/templates/ts/src/generated/constants.ts.ejs

@@ -0,0 +1,10 @@
+export const graphApiVersion = <%= JSON.stringify(graphApiVersion) %> as const;
+export const contentCategory: string | null = <%= JSON.stringify(contentCategory) %>;
+export const connectionId: string | null = <%= JSON.stringify(connectionId) %>;
+export const connectionDescription: string | null = <%= JSON.stringify(connectionDescription) %>;
+export const profileSourceWebUrl: string | null = <%= JSON.stringify(profileSourceWebUrl) %>;
+export const profileSourceDisplayName: string | null = <%= JSON.stringify(profileSourceDisplayName) %>;
+export const profileSourcePriority: "first" | "last" | null = <%= JSON.stringify(profileSourcePriority) %>;
+export const itemTypeName = <%= JSON.stringify(itemTypeName) %> as const;
+export const idPropertyName = <%= JSON.stringify(idPropertyName) %> as const;
+export const contentPropertyName: string | null = <%= JSON.stringify(contentPropertyName) %>;

package/dist/init/templates/ts/src/generated/csv.ts.ejs

@@ -0,0 +1,44 @@
+function parseString(value: unknown): string {
+  if (value === undefined || value === null) return "";
+  return String(value);
+}
+
+function parseNumber(value: unknown): number {
+  const text = parseString(value).trim();
+  if (!text) return 0;
+  const numberValue = Number(text);
+  return Number.isFinite(numberValue) ? numberValue : 0;
+}
+
+function parseBoolean(value: unknown): boolean {
+  const text = parseString(value).trim().toLowerCase();
+  return text === "true" || text === "1" || text === "yes";
+}
+
+function splitCollection(value: unknown): string[] {
+  const text = parseString(value).trim();
+  if (!text) return [];
+  return text.split(/\s*[;,|]\s*/).map((s) => s.trim()).filter(Boolean);
+}
+
+function parseStringCollection(value: unknown): string[] {
+  return splitCollection(value);
+}
+
+function parseNumberCollection(value: unknown): number[] {
+  return splitCollection(value).map((s) => parseNumber(s));
+}
+
+function readSourceValue(row: Record<string, unknown>, headers: string[]): unknown {
+  if (headers.length === 0) return "";
+  return row[headers[0]];
+}
+
+export {
+  parseString,
+  parseNumber,
+  parseBoolean,
+  parseStringCollection,
+  parseNumberCollection,
+  readSourceValue
+};

package/dist/init/templates/ts/src/generated/fromCsvRow.ts.ejs

@@ -0,0 +1,43 @@
+import type { Item } from "./model.js";
+import {
+  parseBoolean,
+  parseNumber,
+  parseNumberCollection,
+  parseString,
+  parseStringCollection,
+  readSourceValue
+} from "../datasource/csv.js";
+<% if (propertyTransforms.length > 0) { -%>
+import {
+<% for (const prop of propertyTransforms) { -%>
+  transform<%= prop.transformName %>,
+<% } -%>
+} from "./propertyTransforms.js";
+<% } -%>
+<% if (hasPersonEntities) { -%>
+import { buildPersonEntityDefault, buildPersonEntityDefaultCollection } from "./personEntityDefaults.js";
+import { transformPersonEntity, transformPersonEntityCollection } from "./personEntityOverrides.js";
+<% } -%>
+
+export function fromCsvRow(row: Record<string, unknown>): Item {
+  return {
+<% for (const prop of properties) { -%>
+  <% if (prop.expression) { -%>
+    <%= prop.name %>: <%= prop.isCollection ? "transformPersonEntityCollection" : "transformPersonEntity" %>(
+      <%= JSON.stringify(prop.name) %>,
+      row,
+      <%= prop.isCollection ? "buildPersonEntityDefaultCollection" : "buildPersonEntityDefault" %>(
+        <%= JSON.stringify(prop.name) %>,
+        row
+      )
+    ),
+  <% } else { -%>
+    <% if (prop.isExplicitSource) { -%>
+    <%= prop.name %>: transform<%= prop.transformName %>(readSourceValue(row, <%= JSON.stringify(prop.csvHeaders) %>)),
+    <% } else { -%>
+    <%= prop.name %>: transform<%= prop.transformName %>(row),
+    <% } -%>
+  <% } -%>
+<% } -%>
+  };
+}

package/dist/init/templates/ts/src/generated/index.ts.ejs

@@ -0,0 +1,5 @@
+export * from "./constants.js";
+export * from "./model.js";
+export * from "./schemaPayload.js";
+export * from "./fromCsvRow.js";
+export * from "./itemPayload.js";

package/dist/init/templates/ts/src/generated/itemPayload.ts.ejs

@@ -0,0 +1,21 @@
+import type { Item } from "./model.js";
+import { contentPropertyName, idPropertyName } from "./constants.js";
+
+export function getItemId(item: Item): string {
+  return String((item as any)[idPropertyName] ?? "");
+}
+
+export function toExternalItem(item: Item): {
+  acl: Array<{ type: string; value: string; accessType: string }>;
+  properties: Record<string, unknown>;
+  content?: { type: string; value: string };
+} {
+  const properties = {
+<%- propertiesObjectLines %>
+  };
+
+  return {
+    acl: [{ type: "everyone", value: "everyone", accessType: "grant" }],
+    properties<%- contentBlock %>
+  };
+}

package/dist/init/templates/ts/src/generated/model.ts.ejs

@@ -0,0 +1,16 @@
+<% if (itemTypeName === "Item") { -%>
+export type Item = {
+<% for (const prop of properties) { -%>
+  <%= prop.name %>: <%= prop.tsType %>;
+<% } -%>
+};
+<% } else { -%>
+
+export type <%= itemTypeName %> = {
+<% for (const prop of properties) { -%>
+  <%= prop.name %>: <%= prop.tsType %>;
+<% } -%>
+};
+
+export type Item = <%= itemTypeName %>;
+<% } -%>

package/dist/init/templates/ts/src/generated/personEntityDefaults.ts.ejs

@@ -0,0 +1,33 @@
+// Auto-generated defaults for people connector entity payloads.
+// These are derived from @coco.source mappings and regenerated on every update.
+// Customize output in personEntityOverrides.ts instead.
+
+import type { Item } from "./model.js";
+import { parseString, parseStringCollection, readSourceValue } from "../datasource/csv.js";
+
+export function buildPersonEntityDefault(name: string, row: Record<string, unknown>): string {
+  switch (name) {
+<% for (const def of defaults) { -%>
+  <% if (!def.isCollection) { -%>
+    case <%= JSON.stringify(def.name) %>:
+      return <%- def.expression %>;
+  <% } -%>
+<% } -%>
+    default:
+      return "";
+  }
+}
+
+export function buildPersonEntityDefaultCollection(name: string, row: Record<string, unknown>): string[] {
+  switch (name) {
+<% for (const def of defaults) { -%>
+  <% if (def.isCollection) { -%>
+    case <%= JSON.stringify(def.name) %>: {
+      return <%- def.expression %>;
+    }
+  <% } -%>
+<% } -%>
+    default:
+      return [];
+  }
+}

package/dist/init/templates/ts/src/generated/propertyTransforms.ts.ejs

@@ -0,0 +1,23 @@
+// Property transforms for custom mapping logic.
+// For explicit @coco.source mappings, the function receives the source column value.
+// When no @coco.source is provided, the function receives the full row.
+
+import {
+  parseBoolean,
+  parseNumber,
+  parseNumberCollection,
+  parseString,
+  parseStringCollection,
+  readSourceValue
+} from "../datasource/csv.js";
+
+<% for (const prop of properties) { -%>
+export function transform<%= prop.transformName %>(<%= prop.isExplicitSource ? "value: unknown" : "row: Record<string, unknown>" %>): <%= prop.tsType %> {
+  // TODO: customize mapping for <%= prop.name %>
+  return <%- prop.isExplicitSource
+    ? `${prop.parser}(value)`
+    : `${prop.parser}(readSourceValue(row, ${JSON.stringify(prop.csvHeaders)}))`
+  %>;
+}
+
+<% } -%>

package/dist/init/templates/ts/src/generated/schemaPayload.ts.ejs

@@ -0,0 +1 @@
+export const schemaPayload = <%- schemaPayloadJson %> as const;

package/dist/init/templates/ts/src/index.ts.ejs

@@ -0,0 +1 @@
+export * from "./schema/index.js";

package/dist/init/templates/ts/src/personEntityOverrides.ts.ejs

@@ -0,0 +1,36 @@
+// User-editable overrides for people connector entity mapping.
+// This file is created once and will not be overwritten by cocogen update.
+
+export function transformPersonEntity(
+  name: string,
+  row: Record<string, unknown>,
+  value: string
+): string {
+  switch (name) {
+<% for (const propName of names) { -%>
+    case <%= JSON.stringify(propName) %>:
+      // TODO: customize mapping for this entity. Example for skillProficiency:
+      // return JSON.stringify({ displayName: String(row["skill"] ?? ""), proficiency: String(row["proficiency"] ?? "") });
+      return value;
+<% } -%>
+    default:
+      return value;
+  }
+}
+
+export function transformPersonEntityCollection(
+  name: string,
+  row: Record<string, unknown>,
+  value: string[]
+): string[] {
+  switch (name) {
+<% for (const propName of names) { -%>
+    case <%= JSON.stringify(propName) %>:
+      // TODO: customize mapping for this collection entity. Example for skills:
+      // return [JSON.stringify({ displayName: String(row["skill"] ?? ""), proficiency: String(row["proficiency"] ?? "") })];
+      return value;
+<% } -%>
+    default:
+      return value;
+  }
+}

package/dist/init/templates/ts/tsconfig.json.ejs

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "strict": true,
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "skipLibCheck": true,
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}

package/dist/init/templates/ts/tspconfig.yaml.ejs

@@ -0,0 +1,2 @@
+imports:
+  - "@wictorwilen/cocogen"

package/dist/ir.d.ts

@@ -0,0 +1,49 @@
+export type GraphApiVersion = "v1.0" | "beta";
+export type PropertyType = "string" | "int64" | "double" | "dateTime" | "boolean" | "stringCollection" | "int64Collection" | "doubleCollection" | "dateTimeCollection" | "principal";
+export type SearchFlags = {
+    searchable?: boolean;
+    queryable?: boolean;
+    retrievable?: boolean;
+    refinable?: boolean;
+    exactMatchRequired?: boolean;
+};
+export type ConnectorIr = {
+    connection: {
+        contentCategory?: string;
+        connectionId?: string;
+        connectionDescription?: string;
+        profileSource?: {
+            webUrl: string;
+            displayName?: string;
+            priority?: "first" | "last";
+        };
+        graphApiVersion: GraphApiVersion;
+    };
+    item: {
+        typeName: string;
+        idPropertyName: string;
+        contentPropertyName?: string;
+    };
+    properties: Array<{
+        name: string;
+        type: PropertyType;
+        description?: string;
+        labels: string[];
+        aliases: string[];
+        search: SearchFlags;
+        personEntity?: {
+            entity: "userAccountInformation" | "personName" | "workPosition" | "itemAddress" | "itemEmail" | "itemPhone" | "personAward" | "personCertification" | "projectParticipation" | "skillProficiency" | "webAccount" | "personWebsite" | "personAnniversary" | "personAnnotation";
+            fields: Array<{
+                path: string;
+                source: {
+                    csvHeaders: string[];
+                };
+            }>;
+        };
+        source: {
+            csvHeaders: string[];
+            explicit?: boolean;
+        };
+    }>;
+};
+//# sourceMappingURL=ir.d.ts.map