terse-cli 0.2.15 → 0.3.0

package/src/providers/typescript/modules/attio/attio.schemas.hbs

@@ -0,0 +1,150 @@
+{{sectionHeader "Attio workspace schemas"}}
+
+{{#each section.valueTypeLines}}
+{{{this}}}
+{{/each}}
+
+export type AttioAttributeDefinition<TSlug extends string = string, TType extends string = string> = {
+    apiSlug: TSlug
+    title?: string
+    type?: TType
+    isRequired?: boolean
+    isUnique?: boolean
+}
+
+export class AttioObject<
+    TSlug extends string = string,
+    TRecordValues extends Record<string, unknown> = Record<string, unknown>,
+    TInputValues extends Record<string, unknown> = TRecordValues
+> {
+    constructor(
+        public readonly apiSlug: TSlug,
+        public readonly name: string,
+        public readonly objectId: string,
+        public readonly attributes: readonly AttioAttributeDefinition[] = []
+    ) {}
+
+    declare readonly __recordValues: TRecordValues
+    declare readonly __inputValues: TInputValues
+{{#if section.objects.length}}
+
+{{#each section.objects}}
+    static {{staticName}} = new AttioObject<"{{escape apiSlug}}", {{{recordValuesType}}}, {{{inputValuesType}}}>("{{escape apiSlug}}", "{{escape singularNoun}}", "{{escape objectId}}", {{{attributeSource}}})
+{{/each}}
+{{/if}}
+}
+
+{{#if section.objects.length}}
+export type GeneratedAttioObject =
+{{#each section.objects}}
+    | typeof AttioObject.{{staticName}}
+{{/each}}
+{{else}}
+export type GeneratedAttioObject = AttioObject
+{{/if}}
+
+export class AttioList<
+    TSlug extends string = string,
+    TEntryValues extends Record<string, unknown> = Record<string, unknown>,
+    TEntryRecordValues extends Record<string, unknown> = TEntryValues
+> {
+    constructor(
+        public readonly apiSlug: TSlug,
+        public readonly name: string,
+        public readonly listId: string,
+        public readonly parentObject: string,
+        public readonly attributes: readonly AttioAttributeDefinition[] = []
+    ) {}
+
+    declare readonly __entryValues: TEntryValues
+    declare readonly __entryRecordValues: TEntryRecordValues
+{{#if section.lists.length}}
+
+{{#each section.lists}}
+    static {{staticName}} = new AttioList<"{{escape apiSlug}}", {{{entryValuesType}}}, {{{entryRecordValuesType}}}>("{{escape apiSlug}}", "{{escape name}}", "{{escape listId}}", "{{escape parentObject}}", {{{attributeSource}}})
+{{/each}}
+{{/if}}
+}
+
+{{#if section.lists.length}}
+export type GeneratedAttioList =
+{{#each section.lists}}
+    | typeof AttioList.{{staticName}}
+{{/each}}
+{{else}}
+export type GeneratedAttioList = AttioList
+{{/if}}
+
+{{sectionHeader "Attio type machinery"}}
+
+{{#if toolFile}}
+{{#each toolTypeDeclarations}}
+{{{this}}}
+{{/each}}
+export type __AttioPrimitive = string | number | boolean | null
+export type __AttioStructuredValue = Record<string, unknown>
+export type __AttioValue = __AttioPrimitive | __AttioStructuredValue | (__AttioPrimitive | __AttioStructuredValue)[]
+export type __AttioFilterAtom<T> = T extends AttioSelectOption ? string : T extends AttioActorReference ? string : T extends AttioRecordReferenceValue ? string : T extends AttioCurrencyValue ? number : T
+export type __AttioFilterShorthand<T> = T extends (infer U)[] ? __AttioFilterAtom<U> | __AttioFilterAtom<U>[] : __AttioFilterAtom<T>
+export type __AttioFilterValue<T> = __AttioFilterShorthand<T> | { $eq?: __AttioFilterShorthand<T>; $contains?: string; $starts_with?: string; $ends_with?: string } | Record<string, unknown>
+export type __AttioFilterExpression<TValues extends Record<string, unknown>> = Partial<{ [K in keyof TValues]: __AttioFilterValue<TValues[K]> }> & { $and?: Array<__AttioFilterExpression<TValues>>; $or?: Array<__AttioFilterExpression<TValues>> }
+export type __AttioRecordWithValues<TValues extends Record<string, unknown>> = Omit<AttioRecordBase, "values"> & TValues & { values: TValues; attributes: TValues }
+
+{{#if section.objects.length}}
+export type AttioInputValuesByObject = {
+{{#each section.objects}}
+    "{{escape apiSlug}}": {{inputValuesType}}
+{{/each}}
+}
+
+export type AttioRecordValuesByObject = {
+{{#each section.objects}}
+    "{{escape apiSlug}}": {{recordValuesType}}
+{{/each}}
+}
+
+export type AttioFilterByObject = {
+{{#each section.objects}}
+    "{{escape apiSlug}}": __AttioFilterExpression<AttioRecordValuesByObject["{{escape apiSlug}}"]>
+{{/each}}
+}
+
+export type AttioRecordByObject = {
+{{#each section.objects}}
+    "{{escape apiSlug}}": __AttioRecordWithValues<AttioRecordValuesByObject["{{escape apiSlug}}"]>
+{{/each}}
+}
+{{else}}
+export type AttioInputValuesByObject = Record<string, Record<string, __AttioValue>>
+export type AttioRecordValuesByObject = Record<string, Record<string, __AttioValue>>
+export type AttioFilterByObject = Record<string, __AttioFilterExpression<Record<string, __AttioValue>>>
+export type AttioRecordByObject = Record<string, __AttioRecordWithValues<Record<string, __AttioValue>>>
+{{/if}}
+
+export type AttioValuesFor<TObject extends GeneratedAttioObject = GeneratedAttioObject> = TObject extends { __inputValues: infer TInputValues } ? TInputValues : AttioInputValuesByObject[TObject["apiSlug"]]
+export type AttioRecordValuesFor<TObject extends GeneratedAttioObject = GeneratedAttioObject> = TObject extends { __recordValues: infer TRecordValues } ? TRecordValues : AttioRecordValuesByObject[TObject["apiSlug"]]
+export type AttioAttributeSlug<TObject extends GeneratedAttioObject = GeneratedAttioObject> = Extract<keyof AttioValuesFor<TObject>, string>
+export type AttioFilterFor<TObject extends GeneratedAttioObject = GeneratedAttioObject> = __AttioFilterExpression<AttioRecordValuesFor<TObject>>
+export type AttioRecordFor<TObject extends GeneratedAttioObject = GeneratedAttioObject> = __AttioRecordWithValues<AttioRecordValuesFor<TObject>>
+export type AttioQueryRecordsParams<TObject extends GeneratedAttioObject = GeneratedAttioObject> = { object: TObject; filter?: AttioFilterFor<TObject> | null; limit?: number | null; offset?: number | null }
+export type AttioSearchRecordsParams<TObject extends GeneratedAttioObject = GeneratedAttioObject> = { object: TObject; query: string; limit?: number | null }
+export type AttioGetRecordParams<TObject extends GeneratedAttioObject = GeneratedAttioObject> = { object: TObject; recordId: string }
+export type AttioCreateRecordParams<TObject extends GeneratedAttioObject = GeneratedAttioObject> = { object: TObject; values: AttioValuesFor<TObject> }
+export type AttioUpdateRecordParams<TObject extends GeneratedAttioObject = GeneratedAttioObject> = { object: TObject; recordId: string; values: Partial<AttioValuesFor<TObject>>; multiselectMode?: "overwrite" | "append" | null }
+export type AttioUpsertRecordParams<TObject extends GeneratedAttioObject = GeneratedAttioObject> = { object: TObject; matchingAttribute: AttioAttributeSlug<TObject>; records: AttioValuesFor<TObject>[] }
+export type AttioDeleteRecordParams<TObject extends GeneratedAttioObject = GeneratedAttioObject> = { object: TObject; recordId: string }
+export type AttioGetAttributeHistoryParams<TObject extends GeneratedAttioObject = GeneratedAttioObject> = { object: TObject; recordId: string; attribute: AttioAttributeSlug<TObject>; limit?: number | null; offset?: number | null }
+export type AttioQueryRecordsResult<TObject extends GeneratedAttioObject = GeneratedAttioObject> = { records: Array<AttioRecordFor<TObject>>; count: number; offset: number }
+export type AttioSearchRecordsResult = { matches: NonNullable<AttioRecordsResult["matches"]>; count: number }
+export type AttioUpsertRecordResult<TObject extends GeneratedAttioObject = GeneratedAttioObject> = { records: Array<AttioRecordFor<TObject>>; count: number }
+export type AttioSingleRecordResult<TObject extends GeneratedAttioObject = GeneratedAttioObject> = AttioRecordFor<TObject>
+export type AttioEntryValuesFor<TList> = TList extends { __entryValues: infer TValues } ? TValues : Record<string, unknown>
+export type AttioEntryRecordValuesFor<TList> = TList extends { __entryRecordValues: infer TValues extends Record<string, unknown> } ? TValues : Record<string, unknown>
+export type AttioEntryFilterFor<TList> = __AttioFilterExpression<AttioEntryRecordValuesFor<TList>>
+export type AttioListEntryFor<TList> = { id: { workspace_id: string; list_id: string; entry_id: string }; parent_record_id: string; parent_object: string; created_at: string; entry_values: AttioEntryRecordValuesFor<TList> }
+export type AttioListEntriesResult<TList> = { entries: Array<AttioListEntryFor<TList>>; count: number; offset: number }
+export type AttioListEntryResult<TList> = AttioListEntryFor<TList>
+export type __AttioSingleValue<T> = T extends (infer U)[] ? U : T
+export type AttioAttributeHistoryEntryFor<TValue> = { active_from: string; active_until: string | null; value: TValue }
+export type AttioAttributeHistoryResult<TValue = unknown> = { history: Array<AttioAttributeHistoryEntryFor<TValue>>; count: number }
+{{/if}}

package/src/providers/typescript/modules/attio/attio.tools.hbs

@@ -0,0 +1,192 @@
+{{#if toolFile}}
+{{sectionHeader "Attio tools"}}
+
+{{> tools-slice toolFile}}
+
+{{/if}}
+{{sectionHeader "Attio skill"}}
+
+/** Attio — query and upsert records on a CRM object */
+export function attioSkill(opts: { object: AttioObject<any> }): TypedSkill<{{{section.skillToolType}}}> {
+    return new AttioOutputConfig("{{escape section.id}}", opts.object.apiSlug)
+}
+
+{{sectionHeader "Attio internals (generated plumbing — no need to read)"}}
+
+{{#if toolFile}}
+function __normalizeAttioObjectSlug(object: unknown): string {
+    if (object && typeof object === "object" && "apiSlug" in (object as Record<string, unknown>)) {
+        const apiSlug = (object as { apiSlug?: unknown }).apiSlug
+        if (typeof apiSlug === "string" && apiSlug.length > 0) return apiSlug
+    }
+    return typeof object === "string" ? object : ""
+}
+
+function __serializeAttioFilter(filter: unknown): string | null {
+    if (filter === undefined || filter === null) return null
+    return JSON.stringify(filter)
+}
+
+function __serializeAttioValues(values: unknown): string {
+    return JSON.stringify(values ?? {})
+}
+
+function __serializeAttioRecords(records: unknown): string {
+    if (!Array.isArray(records)) return JSON.stringify([])
+    return JSON.stringify(records.filter((record): record is Record<string, unknown> => typeof record === "object" && record !== null && !Array.isArray(record)))
+}
+
+function __enhanceAttioRecord<TObject extends GeneratedAttioObject>(object: TObject, record: unknown): __AttioRecordWithValues<AttioRecordValuesFor<TObject>> | undefined {
+    if (!record || typeof record !== "object") return undefined
+    const values = __getAttioRecordValues<AttioRecordValuesFor<TObject>>(__normalizeAttioObjectSlug(object), record)
+    return { ...values, ...(record as AttioRecordBase), values, attributes: values } as __AttioRecordWithValues<AttioRecordValuesFor<TObject>>
+}
+
+function __requireAttioPayload<T>(value: T | null | undefined, what: string): T {
+    if (value === null || value === undefined) throw new Error("Attio returned a response without the expected " + what + " payload.")
+    return value
+}
+
+function __enhanceAttioQueryResult<TObject extends GeneratedAttioObject>(object: TObject, result: AttioRecordsResult): AttioQueryRecordsResult<TObject> {
+    const records = (result.records || []).map(record => __enhanceAttioRecord(object, record)).filter(Boolean) as Array<AttioRecordFor<TObject>>
+    return { records, count: records.length, offset: result.offset ?? 0 }
+}
+
+function __enhanceAttioSearchResult(result: AttioRecordsResult): AttioSearchRecordsResult {
+    const matches = result.matches ?? []
+    return { matches, count: matches.length }
+}
+
+function __enhanceAttioUpsertResult<TObject extends GeneratedAttioObject>(object: TObject, result: AttioRecordsResult): AttioUpsertRecordResult<TObject> {
+    const records = (result.records || []).map(record => __enhanceAttioRecord(object, record)).filter(Boolean) as Array<AttioRecordFor<TObject>>
+    return { records, count: records.length }
+}
+
+function __enhanceAttioSingleRecordResult<TObject extends GeneratedAttioObject>(object: TObject, result: AttioRecordsResult): AttioSingleRecordResult<TObject> {
+    return __requireAttioPayload(__enhanceAttioRecord(object, result.record), "record")
+}
+
+{{/if}}
+const __attioMetadataKeys = new Set([
+    "active_from",
+    "active_until",
+    "attribute_type",
+    "created_by_actor",
+])
+
+const __attioMultiValueAttributeSlugsByObject: Record<string, readonly string[]> = {
+{{#each section.objects}}
+    "{{escape apiSlug}}": [{{{multiValueSlugsText}}}],
+{{/each}}
+}
+
+const __attioObjectSlugByObjectId: Record<string, string> = {
+{{#each section.objects}}
+    "{{escape objectId}}": "{{escape apiSlug}}",
+{{/each}}
+}
+
+function __flattenAttioLeafValue(value: unknown): unknown {
+    if (value === null || value === undefined) return value
+    if (Array.isArray(value)) return value.map(entry => __flattenAttioLeafValue(entry))
+    if (typeof value !== "object") return value
+    const rawObject = value as Record<string, unknown>
+    if (rawObject.attribute_type === "status") return __toAttioSelectOption(rawObject.status)
+    if (rawObject.attribute_type === "select") return __toAttioSelectOption(rawObject.option)
+    if (typeof rawObject.full_name === "string") return rawObject.full_name
+    if (typeof rawObject.email_address === "string") return rawObject.email_address
+    if (typeof rawObject.domain === "string") return rawObject.domain
+    if (typeof rawObject.phone_number === "string") return rawObject.phone_number
+    if ("value" in rawObject) return __flattenAttioLeafValue(rawObject.value)
+    const dataEntries = Object.entries(rawObject).filter(([key]) => !__attioMetadataKeys.has(key))
+    if (dataEntries.length === 0) return rawObject
+    if (dataEntries.length === 1) return __flattenAttioLeafValue(dataEntries[0][1])
+    return Object.fromEntries(dataEntries.map(([key, entryValue]) => [key, __flattenAttioLeafValue(entryValue)]))
+}
+
+function __toAttioSelectOption(option: unknown): unknown {
+    if (!option || typeof option !== "object") return option
+    const rawOption = option as Record<string, unknown>
+    const rawId = rawOption.id && typeof rawOption.id === "object" ? (rawOption.id as Record<string, unknown>) : undefined
+    const id = rawId?.status_id ?? rawId?.option_id ?? rawOption.id
+    return {
+        id: typeof id === "string" ? id : "",
+        title: typeof rawOption.title === "string" ? rawOption.title : "",
+        is_archived: rawOption.is_archived === true,
+    } satisfies AttioSelectOption
+}
+
+function __flattenAttioAttributeValue(rawValue: unknown, preferArray: boolean): unknown {
+    if (!Array.isArray(rawValue)) return __flattenAttioLeafValue(rawValue)
+    const flattened = rawValue.map(entry => __flattenAttioLeafValue(entry)).filter(entry => entry !== undefined)
+    return preferArray ? flattened : flattened[0]
+}
+
+function __isAttioMultiValueAttribute(objectSlug: string, attributeSlug: string): boolean {
+    return (__attioMultiValueAttributeSlugsByObject[objectSlug] || []).includes(attributeSlug)
+}
+
+function __getAttioRecordValues<TValues extends Record<string, unknown>>(objectSlug: string, record: unknown): TValues {
+    const rawValues = record && typeof record === "object" ? (record as { values?: unknown }).values : undefined
+    if (!rawValues || typeof rawValues !== "object" || Array.isArray(rawValues)) return {} as TValues
+    const flattenedValues: Record<string, unknown> = {}
+    for (const [attributeSlug, rawValue] of Object.entries(rawValues)) {
+        flattenedValues[attributeSlug] = __flattenAttioAttributeValue(rawValue, __isAttioMultiValueAttribute(objectSlug, attributeSlug))
+    }
+    return flattenedValues as TValues
+}
+
+const __attioMultiValueEntrySlugsByList: Record<string, readonly string[]> = {
+{{#each section.lists}}
+    "{{escape apiSlug}}": [{{{multiValueSlugsText}}}],
+    "{{escape listId}}": [{{{multiValueSlugsText}}}],
+{{/each}}
+}
+
+function __getAttioEntryValues<TValues extends Record<string, unknown>>(listKey: string, rawEntryValues: unknown): TValues {
+    if (!rawEntryValues || typeof rawEntryValues !== "object" || Array.isArray(rawEntryValues)) return {} as TValues
+    const flattenedValues: Record<string, unknown> = {}
+    const multiValueSlugs = __attioMultiValueEntrySlugsByList[listKey] || []
+    for (const [attributeSlug, rawValue] of Object.entries(rawEntryValues)) {
+        flattenedValues[attributeSlug] = __flattenAttioAttributeValue(rawValue, multiValueSlugs.includes(attributeSlug))
+    }
+    return flattenedValues as TValues
+}
+
+function __requireAttioListParentObject(list: unknown, parentObjectSlug: string | null | undefined): string {
+    if (parentObjectSlug) return parentObjectSlug
+    if (list && typeof list === "object" && "parentObject" in (list as Record<string, unknown>)) {
+        const parentObject = (list as { parentObject?: unknown }).parentObject
+        if (typeof parentObject === "string" && parentObject.length > 0) return parentObject
+    }
+    throw new Error("parentObjectSlug is required when the list is passed as a plain ID/slug rather than a generated AttioList constant.")
+}
+
+function __enhanceAttioListEntry<TList>(list: TList, entry: unknown): AttioListEntryFor<TList> {
+    const raw = (entry && typeof entry === "object" ? entry : {}) as { entry_values?: unknown }
+    return { ...(raw as object), entry_values: __getAttioEntryValues(__normalizeAttioObjectSlug(list), raw.entry_values) } as AttioListEntryFor<TList>
+}
+
+function __enhanceAttioListEntriesResult<TList>(list: TList, result: AttioListsResult): AttioListEntriesResult<TList> {
+    const entries = (result.entries || []).map(entry => __enhanceAttioListEntry(list, entry))
+    return { entries, count: entries.length, offset: result.offset ?? 0 }
+}
+
+function __enhanceAttioListEntryResult<TList>(list: TList, result: AttioListsResult): AttioListEntryResult<TList> {
+    if (!result.entry) throw new Error("Attio returned a response without the expected list entry payload.")
+    return __enhanceAttioListEntry(list, result.entry)
+}
+
+function __enhanceAttioHistoryResult<TValue>(result: AttioRecordsResult): AttioAttributeHistoryResult<TValue> {
+    const history = (result.history || []).map(entry => ({ active_from: entry.active_from, active_until: entry.active_until, value: __flattenAttioLeafValue(entry) as TValue }))
+    return { history, count: history.length }
+}
+
+registerEventTransform("attio", (event) => {
+    const e = event as { record?: { values?: unknown }; resourceIds?: { object_id?: string } }
+    if (!e?.record?.values) return event
+    const objectId = e.resourceIds?.object_id
+    const slug = objectId ? __attioObjectSlugByObjectId[objectId] : undefined
+    if (!slug) return event
+    return { ...e, record: { ...e.record, values: __getAttioRecordValues(slug, e.record) } }
+})

package/src/providers/typescript/modules/attio/attio.triggers.hbs

@@ -0,0 +1,130 @@
+{{sectionHeader "Attio triggers"}}
+
+{{#each triggerDeclarations}}
+{{{this}}}
+
+{{/each}}
+{{#each section.recordTriggerAliases}}
+{{{this}}}
+{{/each}}
+
+function attioParentObjectFilter(object: GeneratedAttioObject | undefined) {
+    if (!object) return null
+    return { $and: [{ field: "id.object_id", operator: "equals" as const, value: object.objectId }] }
+}
+
+export const attioTriggers = {
+    /** Trigger when a call recording is created */
+    onCallRecordingCreated(): TypedTrigger<AttioCallRecordingCreatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.CALL_RECORDING_CREATED }])
+    },
+    /** Trigger when a comment is created */
+    onCommentCreated(): TypedTrigger<AttioCommentCreatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.COMMENT_CREATED }])
+    },
+    /** Trigger when a comment is resolved */
+    onCommentResolved(): TypedTrigger<AttioCommentResolvedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.COMMENT_RESOLVED }])
+    },
+    /** Trigger when a comment is unresolved */
+    onCommentUnresolved(): TypedTrigger<AttioCommentUnresolvedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.COMMENT_UNRESOLVED }])
+    },
+    /** Trigger when a comment is deleted */
+    onCommentDeleted(): TypedTrigger<AttioCommentDeletedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.COMMENT_DELETED }])
+    },
+    /** Trigger when a list is created */
+    onListCreated(): TypedTrigger<AttioListCreatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.LIST_CREATED }])
+    },
+    /** Trigger when a list is updated */
+    onListUpdated(): TypedTrigger<AttioListUpdatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.LIST_UPDATED }])
+    },
+    /** Trigger when a list is deleted */
+    onListDeleted(): TypedTrigger<AttioListDeletedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.LIST_DELETED }])
+    },
+    /** Trigger when a list attribute is created */
+    onListAttributeCreated(): TypedTrigger<AttioListAttributeCreatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.LIST_ATTRIBUTE_CREATED }])
+    },
+    /** Trigger when a list attribute is updated */
+    onListAttributeUpdated(): TypedTrigger<AttioListAttributeUpdatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.LIST_ATTRIBUTE_UPDATED }])
+    },
+    /** Trigger when a list entry is created */
+    onListEntryCreated(): TypedTrigger<AttioListEntryCreatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.LIST_ENTRY_CREATED }])
+    },
+    /** Trigger when a list entry is updated */
+    onListEntryUpdated(): TypedTrigger<AttioListEntryUpdatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.LIST_ENTRY_UPDATED }])
+    },
+    /** Trigger when a list entry is deleted */
+    onListEntryDeleted(): TypedTrigger<AttioListEntryDeletedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.LIST_ENTRY_DELETED }])
+    },
+    /** Trigger when an object attribute is created */
+    onObjectAttributeCreated(): TypedTrigger<AttioObjectAttributeCreatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.OBJECT_ATTRIBUTE_CREATED }])
+    },
+    /** Trigger when an object attribute is updated */
+    onObjectAttributeUpdated(): TypedTrigger<AttioObjectAttributeUpdatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.OBJECT_ATTRIBUTE_UPDATED }])
+    },
+    /** Trigger when a note is created */
+    onNoteCreated(): TypedTrigger<AttioNoteCreatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.NOTE_CREATED }])
+    },
+    /** Trigger when a note's content is updated */
+    onNoteContentUpdated(): TypedTrigger<AttioNoteContentUpdatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.NOTE_CONTENT_UPDATED }])
+    },
+    /** Trigger when a note is updated */
+    onNoteUpdated(): TypedTrigger<AttioNoteUpdatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.NOTE_UPDATED }])
+    },
+    /** Trigger when a note is deleted */
+    onNoteDeleted(): TypedTrigger<AttioNoteDeletedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.NOTE_DELETED }])
+    },
+    /** Trigger when a record is created. Pass `object` to scope to a specific Attio object. */
+    onRecordCreated<T extends GeneratedAttioObject = never>(opts?: { object: T }): TypedTrigger<AttioRecordCreatedTrigger<[T] extends [never] ? GeneratedAttioObject["__recordValues"] : T["__recordValues"]>> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.RECORD_CREATED, filter: attioParentObjectFilter(opts?.object) }])
+    },
+    /** Trigger when records are merged. Pass `object` to scope to a specific Attio object. */
+    onRecordMerged<T extends GeneratedAttioObject = never>(opts?: { object: T }): TypedTrigger<AttioRecordMergedTrigger<[T] extends [never] ? GeneratedAttioObject["__recordValues"] : T["__recordValues"]>> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.RECORD_MERGED, filter: attioParentObjectFilter(opts?.object) }])
+    },
+    /** Trigger when a record is updated. Pass `object` to scope to a specific Attio object. */
+    onRecordUpdated<T extends GeneratedAttioObject = never>(opts?: { object: T }): TypedTrigger<AttioRecordUpdatedTrigger<[T] extends [never] ? GeneratedAttioObject["__recordValues"] : T["__recordValues"]>> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.RECORD_UPDATED, filter: attioParentObjectFilter(opts?.object) }])
+    },
+    /** Trigger when a record is deleted. Pass `object` to scope to a specific Attio object. */
+    onRecordDeleted(opts?: { object?: GeneratedAttioObject }): TypedTrigger<AttioRecordDeletedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.RECORD_DELETED, filter: attioParentObjectFilter(opts?.object) }])
+    },
+    /** Trigger when a task is created */
+    onTaskCreated(): TypedTrigger<AttioTaskCreatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.TASK_CREATED }])
+    },
+    /** Trigger when a task is updated */
+    onTaskUpdated(): TypedTrigger<AttioTaskUpdatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.TASK_UPDATED }])
+    },
+    /** Trigger when a task is deleted */
+    onTaskDeleted(): TypedTrigger<AttioTaskDeletedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.TASK_DELETED }])
+    },
+    /** Trigger when a workspace member is added */
+    onWorkspaceMemberCreated(): TypedTrigger<AttioWorkspaceMemberCreatedTrigger> {
+        return new AttioInputConfig("{{escape section.id}}", [{ eventType: AttioEventType.WORKSPACE_MEMBER_CREATED }])
+    },
+    /** Trigger on one or more Attio event types. Pass `object` to scope record events to a specific Attio object. */
+    trigger(opts: { eventTypes: AttioEventType[]; object?: GeneratedAttioObject }): TypedTrigger<AttioTrigger> {
+        const filter = attioParentObjectFilter(opts.object)
+        return new AttioInputConfig("{{escape section.id}}", opts.eventTypes.map(eventType => ({ eventType, filter })))
+    },
+}

package/src/providers/typescript/modules/datadog/datadog.tools.hbs

@@ -0,0 +1,16 @@
+{{sectionHeader "Datadog resources"}}
+
+{{> resource-class section.indexClass}}
+
+{{#if toolFile}}
+{{sectionHeader "Datadog tools"}}
+
+{{> tools-slice toolFile}}
+
+{{/if}}
+{{sectionHeader "Datadog skill"}}
+
+/** Datadog — search and analyze logs, optionally scoped to specific indexes */
+export function datadogSkill(opts?: { indexes?: DatadogIndex[] }): TypedSkill<{{{section.skillToolType}}}> {
+    return new DatadogConfig("{{escape section.id}}", opts?.indexes?.map(i => i.name))
+}

package/src/providers/typescript/modules/github/github.tools.hbs

@@ -0,0 +1,68 @@
+{{sectionHeader "GitHub resources"}}
+
+export class GithubOwner {
+    constructor(public readonly name: string) {}
+{{#if section.owners.length}}
+
+{{#each section.owners}}
+    static {{staticName}} = new GithubOwner("{{escape name}}")
+{{/each}}
+{{/if}}
+}
+
+export class Repos {
+    constructor(
+        public readonly repositoryId: number,
+        public readonly name: string,
+        public readonly owner: GithubOwner,
+        public readonly fullName: string
+    ) {}
+{{#if section.repoGroups.length}}
+
+{{#each section.repoGroups}}
+    static {{ownerStaticName}} = {
+{{#each repos}}
+        {{staticName}}: new Repos({{id}}, "{{escape name}}", GithubOwner.{{../ownerStaticName}}, "{{escape fullName}}"),
+{{/each}}
+    } as const
+{{/each}}
+{{/if}}
+}
+
+{{#if repoMappings.length}}
+const __githubRepoNameToFullName = new Map<string, string>([
+{{#each repoMappings}}
+    ["{{escape name}}", "{{escape fullName}}"],
+{{/each}}
+])
+
+function __normalizeGitHubRepos(repo: unknown): string {
+    if (repo && typeof repo === "object" && "fullName" in (repo as Record<string, unknown>)) {
+        const fullName = (repo as { fullName?: unknown }).fullName
+        if (typeof fullName === "string" && fullName.length > 0) return fullName
+    }
+    if (typeof repo === "string") {
+        if (repo.includes("/")) return repo
+        return __githubRepoNameToFullName.get(repo) ?? repo
+    }
+    return String(repo ?? "")
+}
+
+function __normalizeGitHubReposNames(repositories: unknown): string[] {
+    if (!Array.isArray(repositories)) return []
+    return repositories.map(repo => __normalizeGitHubRepos(repo))
+}
+
+{{/if}}
+{{#if toolFile}}
+{{sectionHeader "GitHub tools"}}
+
+{{> tools-slice toolFile}}
+
+{{/if}}
+{{sectionHeader "GitHub skill"}}
+
+/** GitHub — read code and pull requests from the given repositories */
+export function githubSkill(opts: { repos: Repos[] }): TypedSkill<{{{section.skillToolType}}}> {
+    return new GitHubConfig("{{escape section.id}}", opts.repos.map(r => r.repositoryId))
+}

package/src/providers/typescript/modules/github/github.triggers.hbs

@@ -0,0 +1,40 @@
+{{sectionHeader "GitHub triggers"}}
+
+{{#each triggerDeclarations}}
+{{{this}}}
+
+{{/each}}
+export const githubTriggers = {
+    /** Trigger on push to a repository */
+    onPush(opts: { repo: Repos }): TypedTrigger<GithubPushTrigger> {
+        return new GitHubConfig("{{escape section.id}}", [opts.repo.repositoryId], [GitHubEventType.PUSH])
+    },
+    /** Trigger when a pull request is opened */
+    onPROpened(opts: { repo: Repos }): TypedTrigger<GithubPROpenedTrigger> {
+        return new GitHubConfig("{{escape section.id}}", [opts.repo.repositoryId], [GitHubEventType.PR_OPENED])
+    },
+    /** Trigger when a pull request is merged */
+    onPRMerged(opts: { repo: Repos }): TypedTrigger<GithubPRMergedTrigger> {
+        return new GitHubConfig("{{escape section.id}}", [opts.repo.repositoryId], [GitHubEventType.PR_MERGED])
+    },
+    /** Trigger when a pull request is closed */
+    onPRClosed(opts: { repo: Repos }): TypedTrigger<GithubPRClosedTrigger> {
+        return new GitHubConfig("{{escape section.id}}", [opts.repo.repositoryId], [GitHubEventType.PR_CLOSED])
+    },
+    /** Trigger when a pull request is synchronized */
+    onPRSynchronized(opts: { repo: Repos }): TypedTrigger<GithubPRSynchronizedTrigger> {
+        return new GitHubConfig("{{escape section.id}}", [opts.repo.repositoryId], [GitHubEventType.PR_SYNCHRONIZE])
+    },
+    /** Trigger on any pull request event */
+    onPR(opts: { repo: Repos }): TypedTrigger<GithubPRTrigger> {
+        return new GitHubConfig("{{escape section.id}}", [opts.repo.repositoryId], [GitHubEventType.PR_OPENED, GitHubEventType.PR_MERGED, GitHubEventType.PR_CLOSED, GitHubEventType.PR_SYNCHRONIZE])
+    },
+    /** Trigger when a comment is created on an issue or pull request */
+    onIssueComment(opts: { repo: Repos }): TypedTrigger<GithubIssueCommentCreatedTrigger> {
+        return new GitHubConfig("{{escape section.id}}", [opts.repo.repositoryId], [GitHubEventType.ISSUE_COMMENT_CREATED])
+    },
+    /** Trigger on specific GitHub events for the given repositories */
+    trigger(opts: { repos: Repos[]; eventTypes?: GitHubEventType[] }): TypedTrigger<GithubTrigger> {
+        return new GitHubConfig("{{escape section.id}}", opts.repos.map(r => r.repositoryId), opts.eventTypes)
+    },
+}

package/src/providers/typescript/modules/gmail/gmail.tools.hbs

@@ -0,0 +1,17 @@
+{{#if toolFile}}
+{{sectionHeader "Gmail tools"}}
+
+{{> tools-slice toolFile}}
+
+{{/if}}
+{{sectionHeader "Gmail skills"}}
+
+/** Gmail — send emails */
+export function gmailSkill(): TypedSkill<{{{section.skillToolType}}}> {
+    return new GmailOutputConfig("{{escape section.id}}")
+}
+
+/** Gmail — create draft emails (no auto-send) */
+export function gmailDraftSkill(): TypedSkill<{{{section.skillToolType}}}> {
+    return new GmailDraftOutputConfig("{{escape section.id}}")
+}

package/src/providers/typescript/modules/gmail/gmail.triggers.hbs

@@ -0,0 +1,16 @@
+{{sectionHeader "Gmail triggers"}}
+
+{{#each triggerDeclarations}}
+{{{this}}}
+
+{{/each}}
+export const gmailTriggers = {
+    /** Trigger when a new email is received */
+    onEmail(): TypedTrigger<GmailTrigger> {
+        return new GmailConfig("{{escape section.id}}", [GmailEventType.EMAIL_RECEIVED])
+    },
+    /** Trigger on all Gmail events */
+    trigger(opts?: { eventTypes?: GmailEventType[] }): TypedTrigger<GmailTrigger> {
+        return new GmailConfig("{{escape section.id}}", opts?.eventTypes)
+    },
+}

package/src/providers/typescript/modules/hey_reach/hey_reach.tools.hbs

@@ -0,0 +1,9 @@
+{{sectionHeader "HeyReach resources"}}
+
+{{> resource-class section.campaignClass}}
+
+{{#if toolFile}}
+{{sectionHeader "HeyReach tools"}}
+
+{{> tools-slice toolFile}}
+{{/if}}