@stripe/extensibility-dev-tools 0.23.5

package/dist/bin/create-upload-image.js

@@ -0,0 +1,2113 @@
+#!/usr/bin/env node
+
+// src/bin/create-upload-image.ts
+import { execSync as execSync2 } from "child_process";
+import * as fs3 from "fs";
+import * as os2 from "os";
+import * as path3 from "path";
+
+// src/custom-objects/build-definitions.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import * as customObjectTools from "@stripe/extensibility-custom-objects-tools/internal";
+
+// src/manifest/stripe-app-manifest.ts
+import { _toSnakeCase } from "@stripe/extensibility-tool-utils";
+
+// src/manifest/manifest-v2.ts
+import { readFile, writeFile } from "fs/promises";
+import * as yaml from "yaml";
+import { _toPascalCase } from "@stripe/extensibility-tool-utils";
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0;
+}
+function isYamlObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function validateManifestV2Data(data) {
+  if (!isNonEmptyString(data.id)) {
+    throw new Error('Manifest must contain non-empty "id" field');
+  }
+  if (!isNonEmptyString(data.name)) {
+    throw new Error('Manifest must contain non-empty "name" field');
+  }
+  if (!isNonEmptyString(data.version)) {
+    throw new Error('Manifest must contain non-empty "version" field');
+  }
+  if ("extensions" in data && !Array.isArray(data.extensions)) {
+    throw new Error('Manifest field "extensions" must be an array when provided');
+  }
+  if ("custom_object_definitions" in data && !isYamlObject(data.custom_object_definitions)) {
+    throw new Error(
+      'Manifest field "custom_object_definitions" must be an object with a "definitions" array'
+    );
+  }
+  const coBlock = data.custom_object_definitions;
+  const definitions = isYamlObject(coBlock) ? coBlock.definitions : void 0;
+  if (!definitions) {
+    return;
+  }
+  if (!Array.isArray(definitions)) {
+    throw new Error(
+      'Manifest field "custom_object_definitions.definitions" must be an array'
+    );
+  }
+  for (let i = 0; i < definitions.length; i++) {
+    const def = definitions[i];
+    const prefix = `custom_object_definitions.definitions[${String(i)}]`;
+    if (!isYamlObject(def) || !isNonEmptyString(def.id)) {
+      throw new Error(
+        `${prefix}: missing or invalid "id" field. Got: ${JSON.stringify(def)}`
+      );
+    }
+    if (!isYamlObject(def.specification)) {
+      throw new Error(
+        `${prefix}: missing or invalid "specification" field. Expected: { type: "typescript", content: "path/to/file.ts" }. Got: ${JSON.stringify(def)}`
+      );
+    }
+    if (!isNonEmptyString(def.specification.type)) {
+      throw new Error(
+        `${prefix}: missing or invalid "specification.type" field. Got: ${JSON.stringify(def)}`
+      );
+    }
+    if (!isNonEmptyString(def.specification.content)) {
+      throw new Error(
+        `${prefix}: missing or invalid "specification.content" field. Got: ${JSON.stringify(def)}`
+      );
+    }
+  }
+}
+var _ManifestV2 = class __ManifestV2 {
+  constructor(filePath, data) {
+    this.filePath = filePath;
+    this.data = data;
+  }
+  /**
+   * Load stripe-app.yaml from disk
+   * @param filePath - Path to stripe-app.yaml
+   * @throws Error if file is invalid or cannot be read
+   */
+  static async load(filePath) {
+    try {
+      const content = await readFile(filePath, "utf-8");
+      const parsed = yaml.parse(content);
+      if (!isYamlObject(parsed)) {
+        throw new Error("Invalid stripe-app.yaml format: root must be an object");
+      }
+      validateManifestV2Data(parsed);
+      const data = parsed;
+      data.extensions ??= [];
+      return new __ManifestV2(filePath, data);
+    } catch (err) {
+      if (err instanceof Error) {
+        throw new Error(`Error reading stripe-app.yaml: ${err.message}`);
+      }
+      throw new Error(`Error reading stripe-app.yaml: ${String(err)}`);
+    }
+  }
+  /**
+   * Get the app ID from the manifest
+   */
+  getAppId() {
+    return this.data.id;
+  }
+  /**
+   * Get the app name from the manifest
+   */
+  getAppName() {
+    return this.data.name;
+  }
+  // ============================================================
+  // Custom Objects
+  // ============================================================
+  /**
+   * Get all custom object definitions, parsed into internal format.
+   * Entries are guaranteed structurally valid by load-time validation.
+   */
+  getCustomObjects() {
+    const definitions = this.data.custom_object_definitions?.definitions;
+    if (!definitions || definitions.length === 0) {
+      return [];
+    }
+    return definitions.map((def) => ({
+      id: def.id,
+      type: def.specification.type,
+      path: def.specification.content,
+      name: _toPascalCase(def.id)
+    }));
+  }
+  /**
+   * Check if a custom object exists by id
+   */
+  hasCustomObject(id) {
+    const definitions = this.data.custom_object_definitions?.definitions;
+    if (!definitions) return false;
+    return definitions.some((def) => def.id === id);
+  }
+  /**
+   * Add a custom object definition.
+   *
+   * Identity is keyed on `id` alone. The export name is derived via
+   * `_toPascalCase(id)` at read time, so `id` should be valid snake_case
+   * (e.g., "device", "loyalty_card", "http_request").
+   *
+   * @param id - Object identifier (e.g., "device", "loyalty_card")
+   * @param content - Path to the definition file (e.g., "src/device.object.ts")
+   * @param type - Specification type, defaults to "typescript"
+   * @returns true if added, false if already exists
+   */
+  addCustomObject(id, content, type = "typescript") {
+    if (this.hasCustomObject(id)) {
+      return false;
+    }
+    this.data.custom_object_definitions ??= {};
+    this.data.custom_object_definitions.definitions ??= [];
+    this.data.custom_object_definitions.definitions.push({
+      id,
+      specification: { type, content }
+    });
+    return true;
+  }
+  /**
+   * Remove a custom object definition by id
+   * @param id - Object identifier to remove
+   * @returns true if removed, false if not found
+   */
+  removeCustomObject(id) {
+    const block = this.data.custom_object_definitions;
+    if (!block?.definitions) {
+      return false;
+    }
+    const originalLength = block.definitions.length;
+    block.definitions = block.definitions.filter((def) => def.id !== id);
+    const newLength = block.definitions.length;
+    if (newLength === 0) {
+      delete this.data.custom_object_definitions;
+    }
+    return newLength < originalLength;
+  }
+  // ============================================================
+  // Extensions
+  // ============================================================
+  /**
+   * Add a new extension or update an existing one by ID
+   * If an extension with the provided ID exists, it will be replaced entirely
+   * @param extension - Extension configuration with all required fields including id
+   * @returns The extension ID
+   */
+  addOrUpdateExtension(extension) {
+    const newExtension = {
+      id: extension.id,
+      name: extension.name,
+      interface_id: extension.interface_id,
+      version: extension.version,
+      ...extension.description !== void 0 && {
+        description: extension.description
+      },
+      ...extension.stripe_version !== void 0 && {
+        stripe_version: extension.stripe_version
+      },
+      ...extension.script_entry_point !== void 0 && {
+        script_entry_point: extension.script_entry_point
+      },
+      ...extension.script !== void 0 && { script: extension.script },
+      permissions: extension.permissions,
+      methods: extension.methods,
+      ...extension.configuration !== void 0 && {
+        configuration: extension.configuration
+      },
+      ...extension.endpoints !== void 0 && {
+        endpoints: extension.endpoints
+      }
+    };
+    this.data.extensions ??= [];
+    const existingIndex = this.data.extensions.findIndex(
+      (ext) => ext.id === extension.id
+    );
+    if (existingIndex !== -1) {
+      this.data.extensions[existingIndex] = newExtension;
+    } else {
+      this.data.extensions.push(newExtension);
+    }
+    return extension.id;
+  }
+  /**
+   * Get a read-only view of all extensions
+   */
+  getExtensions() {
+    return this.data.extensions ?? [];
+  }
+  /**
+   * Get the raw manifest data (for reading other fields)
+   */
+  getRawData() {
+    return this.data;
+  }
+  /**
+   * Save changes back to disk
+   * @throws Error if file cannot be written
+   */
+  async save() {
+    try {
+      const updatedContent = yaml.stringify(this.data);
+      await writeFile(this.filePath, updatedContent, "utf-8");
+    } catch (err) {
+      if (err instanceof Error) {
+        throw new Error(`Error writing stripe-app.yaml: ${err.message}`);
+      }
+      throw new Error(`Error writing stripe-app.yaml: ${String(err)}`);
+    }
+  }
+};
+
+// src/templates/template-manager.ts
+import { _TemplateManager } from "@stripe/extensibility-tool-utils";
+
+// src/templates/extensions/types.ts
+var _ExtensionTemplateManager = class extends _TemplateManager {
+  /**
+   * Get summary info for all registered extension templates
+   */
+  getTemplateInfo() {
+    return this.getTemplateEntries().map(([key, t]) => ({
+      key,
+      description: t.description,
+      deprecated: t.deprecated ?? false,
+      hidden: t.hidden ?? false,
+      methods: t.methods
+    }));
+  }
+};
+
+// src/templates/fs/in-memory.ts
+import { _createInMemoryTemplateFS } from "@stripe/extensibility-tool-utils";
+
+// templates-virtual:./_impl.js
+var TEMPLATE_FS_IMAGE = [
+  {
+    path: "extensions/billing.bill.discount_calculation/index.test.ts",
+    content: `import { beforeEach, describe, it, expect } from 'vitest';
+
+import MyDiscountCalculation from './index.js';
+
+describe('MyDiscountCalculation', () => {
+  let instance: MyDiscountCalculation;
+
+  beforeEach(() => {
+    instance = new MyDiscountCalculation();
+  });
+
+  it('should be constructable', () => {
+    expect(instance).toBeInstanceOf(MyDiscountCalculation);
+  });
+});
+`
+  },
+  {
+    path: "extensions/billing.bill.discount_calculation/index.ts",
+    content: `import type { Billing } from '@stripe/extensibility-sdk/extensions';
+import type { Context } from '@stripe/extensibility-sdk/extensions';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+interface MyDiscountCalculationConfig extends Record<string, unknown> {}
+
+export default class MyDiscountCalculation implements Billing.Bill
+  .DiscountCalculation<MyDiscountCalculationConfig> {
+  computeDiscounts(
+    request: Billing.Bill.DiscountCalculation.DiscountableItem,
+    _config: MyDiscountCalculationConfig,
+    _context: Context
+  ) {
+    // TODO: implement your discount logic here
+
+    return {
+      discount: { amount: request.grossAmount },
+    };
+  }
+}
+`
+  },
+  {
+    path: "extensions/billing.customer_balance_application/index.test.ts",
+    content: `import { beforeEach, describe, it, expect } from 'vitest';
+
+import MyCustomerBalanceApplication from './index.js';
+
+describe('MyCustomerBalanceApplication', () => {
+  let instance: MyCustomerBalanceApplication;
+
+  beforeEach(() => {
+    instance = new MyCustomerBalanceApplication();
+  });
+
+  it('should be constructable', () => {
+    expect(instance).toBeInstanceOf(MyCustomerBalanceApplication);
+  });
+});
+`
+  },
+  {
+    path: "extensions/billing.customer_balance_application/index.ts",
+    content: `import type { Billing, Context } from '@stripe/extensibility-sdk/extensions';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+interface MyCustomerBalanceApplicationConfig extends Record<string, unknown> {}
+
+export default class MyCustomerBalanceApplication implements Billing.CustomerBalanceApplication<MyCustomerBalanceApplicationConfig> {
+  computeAppliedCustomerBalance(
+    request: Billing.CustomerBalanceApplication.CustomerBalanceApplicationInput,
+    _config: MyCustomerBalanceApplicationConfig,
+    _context: Context
+  ) {
+    // TODO: implement your customer balance logic here
+
+    return {
+      appliedCustomerBalance: request.customerBalance,
+    };
+  }
+}
+`
+  },
+  {
+    path: "extensions/billing.invoice_collection_setting/index.test.ts",
+    content: `import { beforeEach, describe, it, expect } from 'vitest';
+
+import MyInvoiceCollectionSetting from './index.js';
+
+describe('MyInvoiceCollectionSetting', () => {
+  let instance: MyInvoiceCollectionSetting;
+
+  beforeEach(() => {
+    instance = new MyInvoiceCollectionSetting();
+  });
+
+  it('should be constructable', () => {
+    expect(instance).toBeInstanceOf(MyInvoiceCollectionSetting);
+  });
+});
+`
+  },
+  {
+    path: "extensions/billing.invoice_collection_setting/index.ts",
+    content: `import type { Billing, Context } from '@stripe/extensibility-sdk/extensions';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+interface MyInvoiceCollectionSettingConfig extends Record<string, unknown> {}
+
+export default class MyInvoiceCollectionSetting implements Billing.InvoiceCollectionSetting<MyInvoiceCollectionSettingConfig> {
+  collectionOverride(
+    _request: Billing.InvoiceCollectionSetting.InvoiceCollectionRequest,
+    _config: MyInvoiceCollectionSettingConfig,
+    _context: Context
+  ) {
+    // TODO: implement your collection setting logic here
+
+    return {};
+  }
+}
+`
+  },
+  {
+    path: "extensions/billing.prorations/index.test.ts",
+    content: `import { beforeEach, describe, it, expect } from 'vitest';
+
+import MyProrations from './index.js';
+
+describe('MyProrations', () => {
+  let instance: MyProrations;
+
+  beforeEach(() => {
+    instance = new MyProrations();
+  });
+
+  it('should be constructable', () => {
+    expect(instance).toBeInstanceOf(MyProrations);
+  });
+});
+`
+  },
+  {
+    path: "extensions/billing.prorations/index.ts",
+    content: `import type { Billing, Context } from '@stripe/extensibility-sdk/extensions';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+interface MyProrationsConfig extends Record<string, unknown> {}
+
+export default class MyProrations implements Billing.Prorations<MyProrationsConfig> {
+  prorateItems(
+    _request: Billing.Prorations.ProrateItemsInput,
+    _config: MyProrationsConfig,
+    _context: Context
+  ) {
+    // TODO: implement your proration logic here
+
+    return {
+      items: [],
+    };
+  }
+}
+`
+  },
+  {
+    path: "extensions/billing.recurring_billing_item_handling/index.test.ts",
+    content: `import { beforeEach, describe, it, expect } from 'vitest';
+
+import MyRecurringBillingItemHandling from './index.js';
+
+describe('MyRecurringBillingItemHandling', () => {
+  let instance: MyRecurringBillingItemHandling;
+
+  beforeEach(() => {
+    instance = new MyRecurringBillingItemHandling();
+  });
+
+  it('should be constructable', () => {
+    expect(instance).toBeInstanceOf(MyRecurringBillingItemHandling);
+  });
+});
+`
+  },
+  {
+    path: "extensions/billing.recurring_billing_item_handling/index.ts",
+    content: `import type { Billing, Context } from '@stripe/extensibility-sdk/extensions';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+interface MyRecurringBillingItemHandlingConfig extends Record<string, unknown> {}
+
+export default class MyRecurringBillingItemHandling implements Billing.RecurringBillingItemHandling<MyRecurringBillingItemHandlingConfig> {
+  beforeItemCreation(
+    _request: Billing.RecurringBillingItemHandling.BeforeItemCreationInput,
+    _config: MyRecurringBillingItemHandlingConfig,
+    _context: Context
+  ) {
+    // TODO: implement your before-item-creation logic here
+
+    return {
+      items: [],
+    };
+  }
+
+  filterItems(
+    _request: Billing.RecurringBillingItemHandling.FilterItemsInput,
+    _config: MyRecurringBillingItemHandlingConfig,
+    _context: Context
+  ) {
+    // TODO: implement your filter-items logic here
+
+    return {
+      items: [],
+    };
+  }
+
+  groupItems(
+    _request: Billing.RecurringBillingItemHandling.GroupItemsInput,
+    _config: MyRecurringBillingItemHandlingConfig,
+    _context: Context
+  ) {
+    // TODO: implement your group-items logic here
+
+    return {
+      groups: [],
+    };
+  }
+}
+`
+  },
+  {
+    path: "extensions/common/.prettierignore",
+    content: `dist
+generated
+node_modules
+`
+  },
+  {
+    path: "extensions/common/eslint.config.mts.mustache",
+    content: `import eslint from '@eslint/js';
+import { defineConfig } from 'eslint/config';
+import tseslint from 'typescript-eslint';
+import eslintConfigPrettier from 'eslint-config-prettier/flat';
+
+import globals from 'globals';
+
+import stripeAppsConfig from '@stripe/extensibility-eslint-plugin';
+import extensionTypeConfig from '@stripe/extensibility-eslint-plugin/{{extensionInterfaceId}}';
+
+export default defineConfig([
+  eslint.configs.recommended,
+  ...tseslint.configs.recommended,
+  ...stripeAppsConfig,
+  ...extensionTypeConfig,
+
+  // Global ignores
+  {
+    ignores: ['dist', 'generated', 'node_modules'],
+  },
+
+  // TypeScript source files (with type-checking)
+  {
+    name: 'sources',
+    files: ['src/**/*.ts'],
+    ignores: ['**/*.test.ts', '**/__tests__/**'],
+    languageOptions: {
+      globals: {
+        ...globals.node,
+      },
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+  },
+
+  // Test files (type-checking, relaxed rules)
+  {
+    name: 'tests',
+    files: ['src/**/*.test.ts', 'src/**/__tests__/**/*.ts'],
+    languageOptions: {
+      globals: {
+        ...globals.node,
+      },
+      parserOptions: {
+        projectService: true,
+        tsconfigRootDir: import.meta.dirname,
+      },
+    },
+    rules: {
+      '@typescript-eslint/no-explicit-any': 'off',
+      '@typescript-eslint/no-unused-vars': 'off',
+      'no-console': 'off',
+    },
+  },
+
+  // Config files
+  {
+    name: 'ts-configs',
+    files: ['*.config.m?ts', 'eslint.config.mts'],
+    languageOptions: {
+      globals: {
+        ...globals.node,
+      },
+      parserOptions: {
+        projectService: false,
+      },
+    },
+    rules: {
+      '@typescript-eslint/no-unused-vars': 'off',
+    },
+  },
+
+  // JavaScript/MJS files (scripts, configs)
+  {
+    name: 'js-configs',
+    files: ['**/*.js', '**/*.mjs'],
+    languageOptions: {
+      globals: {
+        ...globals.node,
+      },
+      parserOptions: {
+        projectService: false,
+      },
+    },
+    rules: {
+      '@typescript-eslint/no-require-imports': 'off',
+      '@typescript-eslint/no-unused-vars': 'off',
+      'no-unused-vars': 'off',
+    },
+  },
+
+  eslintConfigPrettier,
+]);
+`
+  },
+  {
+    path: "extensions/common/package.json.mustache",
+    content: `{
+  "name": "{{id}}",
+  "version": "{{version}}",
+  "description": "{{name}}",
+  "private": true,
+  "license": "~~proprietary~~",
+  "type": "module",
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && pnpm build:schemas",
+    "build:schemas": "gen-schemas --root ../.. --extension-id \\"$npm_package_name\\" --out-dir generated --schema-name config",
+    "lint": "pnpm lint:types && pnpm lint:eslint && pnpm lint:format",
+    "lint:types": "tsc -p tsconfig.build.json --noEmit && tsc -p tsconfig.json --noEmit",
+    "lint:eslint": "eslint .",
+    "lint:format": "prettier --check .",
+    "fix:lint": "eslint --fix .",
+    "fix:format": "prettier --write .",
+    "test": "vitest --root ../.. run --project \\"$npm_package_name\\"",
+    "test:watch": "pnpm test --watch",
+    "dev": "concurrently -n build,lint,test -c blue,yellow,green 'tsc -p tsconfig.json -w --noEmit' 'chokidar \\"src/**/*.{ts,json}\\" -c \\"eslint .\\"' 'pnpm test --watch --no-clear-screen'",
+    "stripe:regen": "gen-workspace --root ../.. --package-dir . --template-id {{extensionInterfaceId}}"
+  },
+  "lint-staged": {
+    "*.{ts,mts,mjs,js}": ["eslint --fix", "prettier --write"],
+    "*.{json,md,yaml}": "prettier --write"
+  }
+}
+`
+  },
+  {
+    path: "extensions/common/tsconfig.build.json.mustache",
+    content: `{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "lib": null,
+    "noLib": true,
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": [
+    "src/**/*.ts",
+    "node_modules/@stripe/extensibility-sdk/tslibs/5.9.3/lib.es2022.{{executionProfile}}.d.ts",
+    "node_modules/@stripe/extensibility-sdk/tslibs/lib.{{executionProfile}}.globals.d.ts"
+  ],
+  "exclude": ["src/**/*.test.ts", "src/**/__tests__"]
+}
+`
+  },
+  {
+    path: "extensions/common/tsconfig.json.mustache",
+    content: `{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "plugins": [
+      {
+        "name": "@stripe/extensibility-language-server/plugin"
+      }
+    ]
+  },
+  "include": [
+    "src/**/*.ts",
+    "node_modules/@stripe/extensibility-sdk/tslibs/lib.{{executionProfile}}.globals.d.ts"
+  ],
+  "exclude": ["dist"]
+}
+`
+  },
+  {
+    path: "extensions/core.workflows.custom_action/custom_input.schema.json",
+    content: `{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {},
+  "additionalProperties": false
+}
+`
+  },
+  {
+    path: "extensions/core.workflows.custom_action/index.test.ts",
+    content: `import { beforeEach, describe, it, expect } from 'vitest';
+
+import MyCustomAction from './index.js';
+
+describe('MyCustomAction', () => {
+  let instance: MyCustomAction;
+
+  beforeEach(() => {
+    instance = new MyCustomAction();
+  });
+
+  it('should be constructable', () => {
+    expect(instance).toBeInstanceOf(MyCustomAction);
+  });
+});
+`
+  },
+  {
+    path: "extensions/core.workflows.custom_action/index.ts",
+    content: `import type { Core } from '@stripe/extensibility-sdk/extensions';
+import type { Context } from '@stripe/extensibility-sdk/extensions';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+interface MyCustomActionConfig extends Record<string, unknown> {}
+
+export default class MyCustomAction implements Core.Workflows
+  .CustomAction<MyCustomActionConfig> {
+  execute(
+    _request: Core.Workflows.CustomAction.ExecuteCustomActionRequest,
+    _config: MyCustomActionConfig,
+    _context: Context
+  ) {
+    // TODO: implement your action logic here
+
+    return {};
+  }
+
+  getFormState(
+    _request: Core.Workflows.CustomAction.GetFormStateRequest,
+    _config: MyCustomActionConfig,
+    _context: Context
+  ) {
+    // TODO: implement your logic here
+
+    return {
+      values: {},
+      config: {},
+    };
+  }
+}
+`
+  },
+  {
+    path: "extensions/extend.workflows.custom_action/custom_input.schema.json",
+    content: `{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "type": "object",
+  "properties": {},
+  "additionalProperties": false
+}
+`
+  },
+  {
+    path: "extensions/extend.workflows.custom_action/index.test.ts",
+    content: `import { beforeEach, describe, it, expect } from 'vitest';
+
+import MyCustomAction from './index.js';
+
+describe('MyCustomAction', () => {
+  let instance: MyCustomAction;
+
+  beforeEach(() => {
+    instance = new MyCustomAction();
+  });
+
+  it('should be constructable', () => {
+    expect(instance).toBeInstanceOf(MyCustomAction);
+  });
+});
+`
+  },
+  {
+    path: "extensions/extend.workflows.custom_action/index.ts",
+    content: `import type { Extend } from '@stripe/extensibility-sdk/extensions';
+import type { Context } from '@stripe/extensibility-sdk/extensions';
+
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+interface MyCustomActionConfig extends Record<string, unknown> {}
+
+export default class MyCustomAction implements Extend.Workflows
+  .CustomAction<MyCustomActionConfig> {
+  execute(
+    _request: Extend.Workflows.CustomAction.ExecuteCustomActionRequest,
+    _config: MyCustomActionConfig,
+    _context: Context
+  ) {
+    // TODO: implement your action logic here
+
+    return {};
+  }
+
+  getFormState(
+    _request: Extend.Workflows.CustomAction.GetFormStateRequest,
+    _config: MyCustomActionConfig,
+    _context: Context
+  ) {
+    // TODO: implement your logic here
+
+    return {
+      values: {},
+      config: {},
+    };
+  }
+}
+`
+  },
+  {
+    path: "root/.husky/pre-commit",
+    content: `pnpm lint-staged
+`
+  },
+  {
+    path: "root/.prettierignore",
+    content: `dist
+generated
+node_modules
+pnpm-lock.yaml
+.build
+`
+  },
+  {
+    path: "root/.prettierrc",
+    content: `{
+  "semi": true,
+  "singleQuote": true,
+  "tabWidth": 2,
+  "trailingComma": "es5",
+  "printWidth": 90
+}
+`
+  },
+  {
+    path: "root/_gitignore",
+    content: `# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+*~
+
+# dependencies
+node_modules
+dist
+
+# testing
+/coverage
+
+# production
+/.build
+
+# misc
+.DS_Store
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+install-deps.log
+
+# generated schemas
+generated
+`
+  },
+  {
+    path: "root/custom-objects/package.json",
+    content: `{
+  "name": "custom-objects",
+  "type": "module",
+  "version": "0.0.1",
+  "license": "UNLICENSED",
+  "private": true,
+  "scripts": {
+    "build": "test -d src && custom-objects-build --input src --output dist || true",
+    "lint:types": "test ! -d src || tsc --noEmit",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "@stripe/extensibility-custom-objects": "0.7.4",
+    "@stripe/extensibility-sdk": "0.22.4"
+  },
+  "devDependencies": {
+    "@stripe/extensibility-custom-objects-tools": "0.40.0",
+    "@stripe/extensibility-test-helpers": "0.2.7"
+  }
+}
+`
+  },
+  {
+    path: "root/custom-objects/tsconfig.json",
+    content: `{
+  "extends": "../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "types": ["vitest/globals"]
+  },
+  "exclude": ["dist"]
+}
+`
+  },
+  {
+    path: "root/eslint.config.mts",
+    content: `import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import eslint from '@eslint/js';
+import { defineConfig } from 'eslint/config';
+import tseslint from 'typescript-eslint';
+import workspaces from 'eslint-plugin-workspaces';
+import eslintConfigPrettier from 'eslint-config-prettier/flat';
+
+import globals from 'globals';
+
+import stripeAppsConfig from '@stripe/extensibility-eslint-plugin';
+
+// Read additional ignore globs from package.json (written by the generate plugin
+// to exclude generated SDK directories from linting).
+let stripeGlobsToIgnore: string[] = [];
+try {
+  const configDir = dirname(fileURLToPath(import.meta.url));
+  const packageJsonPath = resolve(configDir, './package.json');
+  const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+  const globs = pkg?.stripe?.eslintIgnoreGlobs;
+  if (Array.isArray(globs)) {
+    stripeGlobsToIgnore = globs.filter(
+      (g: unknown): g is string => typeof g === 'string'
+    );
+  }
+} catch {
+  // package.json not found or unparseable \u2014 ignore
+}
+
+export default defineConfig([
+  eslint.configs.recommended,
+  ...tseslint.configs.recommended,
+  ...stripeAppsConfig,
+
+  // Global ignores
+  {
+    ignores: [
+      '.build',
+      '**/dist',
+      '**/generated',
+      '**/node_modules',
+      'extensions/**',
+      'custom-objects',
+      'ui',
+      ...stripeGlobsToIgnore,
+    ],
+  },
+
+  // Common rules for all files
+  {
+    plugins: { workspaces },
+    rules: {
+      ...workspaces.configs.recommended.rules,
+    },
+  },
+
+  // Config files (vitest.config.ts, eslint.config.ts, etc.)
+  {
+    name: 'ts-configs',
+    files: ['extensions/*/*.config.m?ts', '*.config.m?ts', 'eslint.config.mts'],
+    languageOptions: {
+      globals: {
+        ...globals.node,
+      },
+      parserOptions: {
+        projectService: false,
+      },
+    },
+    rules: {
+      '@typescript-eslint/no-unused-vars': 'off',
+    },
+  },
+
+  // JavaScript/MJS files (scripts, configs)
+  {
+    name: 'js-configs',
+    files: ['**/*.js', '**/*.mjs'],
+    languageOptions: {
+      globals: {
+        ...globals.node,
+      },
+      parserOptions: {
+        projectService: false,
+      },
+    },
+    rules: {
+      '@typescript-eslint/no-require-imports': 'off',
+      '@typescript-eslint/no-unused-vars': 'off',
+      'no-unused-vars': 'off',
+    },
+  },
+
+  eslintConfigPrettier,
+]);
+`
+  },
+  {
+    path: "root/package.json.mustache",
+    content: `{
+  "name": "{{ appId }}",
+  "version": "{{ version }}",
+  "description": "{{ appName }}",
+  "private": true,
+  "license": "~~proprietary~~",
+  "engines": {
+    "node": ">=20.0.0"
+  },
+  "packageManager": "pnpm@10.30.3",
+  "scripts": {
+    "build": "pnpm -r --if-present build",
+    "lint": "pnpm lint:types && pnpm lint:eslint && pnpm lint:format",
+    "lint:types": "pnpm -r --if-present lint:types",
+    "lint:eslint": "eslint . --ignore-pattern 'extensions/**' && pnpm -r --filter './extensions/*' --if-present lint:eslint",
+    "lint:format": "prettier --check .",
+    "fix:lint": "eslint --fix . --ignore-pattern 'extensions/**' && pnpm -r --filter './extensions/*' --if-present fix:lint",
+    "fix:format": "prettier --write .",
+    "test": "tsx tools/test.mts",
+    "test:watch": "vitest watch",
+    "check": "pnpm build && pnpm lint && pnpm test",
+    "prepare": "husky",
+    "preimage": "pnpm install --lockfile-only && pnpm build && pnpm lint:types && pnpm lint:eslint && pnpm test",
+    "image": "rm -rf .build && create-upload-image .build",
+    "postimage": "cp pnpm-lock.yaml .build/",
+    "stripe:regen": "gen-workspace --package-dir ."
+  },
+  "lint-staged": {
+    "*.{ts,mts,mjs,js}": ["eslint --fix", "prettier --write"],
+    "*.{json,md,yaml}": "prettier --write"
+  }
+}
+`
+  },
+  {
+    path: "root/pnpm-workspace.yaml",
+    content: `packages:
+  - extensions/*
+  - custom-objects
+  - ui
+
+overrides:
+  vite: ^6.0.0
+`
+  },
+  {
+    path: "root/stripe-app.yaml.mustache",
+    content: `$schema: https://stripe.com/stripe-app/v2.0.0/schema
+id: '{{ appId }}'
+name: '{{ appName }}'
+version: 0.0.1
+declarations:
+  distribution_type: private
+`
+  },
+  {
+    path: "root/tools/test.mts",
+    content: `#!/usr/bin/env tsx
+/**
+ * Runs tests across the workspace:
+ * - vitest for script extensions and custom objects (extensions/*)
+ * - jest for UI extensions (ui/)
+ */
+import { existsSync, readdirSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+
+const hasExtensions =
+  existsSync('extensions') &&
+  readdirSync('extensions').some((name) => existsSync(\`extensions/\${name}/package.json\`));
+
+const hasUI = existsSync('ui/package.json');
+
+let exitCode = 0;
+
+function run(cmd: string): void {
+  try {
+    execSync(cmd, { stdio: 'inherit' });
+  } catch (e: unknown) {
+    exitCode = (e as NodeJS.ErrnoException & { status?: number }).status ?? 1;
+  }
+}
+
+if (hasExtensions) {
+  run('vitest run');
+}
+
+if (hasUI) {
+  try {
+    execSync('pnpm --filter "./ui" test', { stdio: 'inherit' });
+  } catch {
+    // UI test failures are non-fatal
+  }
+}
+
+process.exit(exitCode);
+`
+  },
+  {
+    path: "root/tsconfig.base.json",
+    content: `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "lib": ["ES2022"],
+    "declaration": true,
+    "declarationMap": true,
+    "esModuleInterop": true,
+    "exactOptionalPropertyTypes": false,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitReturns": true,
+    "removeComments": false,
+    "resolveJsonModule": true,
+    "skipLibCheck": true,
+    "sourceMap": true,
+    "strict": true,
+    "types": [],
+    "verbatimModuleSyntax": true
+  }
+}
+`
+  },
+  {
+    path: "root/tsconfig.json",
+    content: `{
+  "extends": "./tsconfig.base.json",
+  "compilerOptions": {
+    "noEmit": true,
+    "plugins": [
+      {
+        "name": "@stripe/extensibility-language-server/plugin"
+      }
+    ],
+    "preserveWatchOutput": true,
+    "types": ["vitest/globals", "node"]
+  },
+  "include": ["**/*.ts"],
+  "exclude": ["**/node_modules", "**/dist"]
+}
+`
+  },
+  {
+    path: "root/ui/package.json",
+    content: `{
+  "name": "ui",
+  "version": "0.0.1",
+  "license": "UNLICENSED",
+  "private": true,
+  "scripts": {
+    "test": "jest --passWithNoTests"
+  },
+  "dependencies": {
+    "@stripe/ui-extension-sdk": "^9.1.0"
+  },
+  "devDependencies": {
+    "@stripe/ui-extension-tools": "^0.0.1",
+    "@types/jest": "^27.5.2",
+    "@types/react": "^17.0.2"
+  }
+}
+`
+  },
+  {
+    path: "root/vitest.config.mts",
+    content: `import { defineConfig } from 'vitest/config';
+import { existsSync, readdirSync } from 'fs';
+import { dirname, resolve } from 'path';
+import { fileURLToPath } from 'url';
+
+const rootDir = dirname(fileURLToPath(import.meta.url));
+const extensionsDir = resolve(rootDir, 'extensions');
+
+const extensionProjects = existsSync(extensionsDir)
+  ? readdirSync(extensionsDir)
+      .filter((name) => existsSync(resolve(extensionsDir, name, 'package.json')))
+      .map((name) => resolve(extensionsDir, name))
+  : [];
+
+const coProjects = existsSync(resolve(rootDir, 'custom-objects/package.json'))
+  ? [resolve(rootDir, 'custom-objects')]
+  : [];
+
+const projects = [...extensionProjects, ...coProjects];
+
+if (projects.length === 0) {
+  console.debug(\`No vitest projects detected. This means either:
+- You have no extension projects defined, in which case this warning is expected.
+- There is an internal error detecting vitest projects relative to the project root
+  \${rootDir}.
+\`);
+}
+
+export default projects.length > 0
+  ? defineConfig({
+      test: {
+        projects,
+        passWithNoTests: true,
+
+        // Only run tests from src, not compiled dist
+        exclude: ['**/node_modules', '**/dist'],
+        // Place snapshots alongside test files instead of in __snapshots__
+        snapshotFormat: {
+          escapeString: false,
+          printBasicPrototype: false,
+        },
+        resolveSnapshotPath: (testPath, snapExtension) => {
+          return testPath.replace(/\\.test\\.ts$/, \`.test\${snapExtension}\`);
+        },
+      },
+    })
+  : defineConfig({ test: { passWithNoTests: true, include: [] } });
+`
+  }
+];
+var _fs = _createInMemoryTemplateFS(TEMPLATE_FS_IMAGE);
+
+// src/dependencies/index.ts
+import path from "path";
+import fs from "fs";
+import os from "os";
+import { execSync } from "child_process";
+import PackageJson from "@npmcli/package-json";
+import * as semver from "semver";
+import { load as parseToml } from "js-toml";
+import { _createCliContext } from "@stripe/extensibility-tool-utils";
+function _npmDep(name, version) {
+  return { type: "npm", name, version };
+}
+function _devNpmDep(name, version) {
+  return { type: "dev-npm", name, version };
+}
+
+// src/templates/extensions/base.ts
+import { _workspaceVersion } from "@stripe/extensibility-tool-utils";
+var SDK_PACKAGE_NAME = "@stripe/extensibility-sdk";
+var LANGUAGE_SERVER_PACKAGE_NAME = "@stripe/extensibility-language-server";
+var LANGUAGE_SERVER_PACKAGE_VERSION = "^0.2.0";
+function _createExtensionEslintConfigFile(params, context) {
+  const { id, extensionInterfaceId } = params;
+  const { fs: fs4 } = context;
+  return {
+    path: `extensions/${id}/eslint.config.mts`,
+    content: fs4.mustache(
+      { extensionInterfaceId },
+      "common",
+      "eslint.config.mts.mustache"
+    ),
+    precious: true
+  };
+}
+function _createBaseOutput(params, context) {
+  const { id } = params;
+  const { fs: fs4 } = context;
+  return {
+    files: [
+      {
+        path: `extensions/${id}/package.json`,
+        content: fs4.mustache(params, "common", "package.json.mustache")
+      },
+      {
+        ..._createExtensionEslintConfigFile(params, context)
+      },
+      {
+        path: `extensions/${id}/tsconfig.build.json`,
+        content: fs4.mustache(params, "common", "tsconfig.build.json.mustache")
+      },
+      {
+        path: `extensions/${id}/tsconfig.json`,
+        content: fs4.mustache(params, "common", "tsconfig.json.mustache")
+      },
+      {
+        path: `extensions/${id}/.prettierignore`,
+        content: fs4.textFile("common", ".prettierignore")
+      }
+    ],
+    methods: {},
+    dependencies: {
+      // Exact pin (no caret) — the SDK is tightly coupled to dev-tools and
+      // must match the version that generated the extension scaffolding.
+      runtime: [_npmDep(SDK_PACKAGE_NAME, _workspaceVersion(SDK_PACKAGE_NAME))],
+      dev: [_devNpmDep(LANGUAGE_SERVER_PACKAGE_NAME, LANGUAGE_SERVER_PACKAGE_VERSION)]
+    },
+    postGenerationHooks: [
+      {
+        script: "build",
+        description: "Build extension"
+      },
+      {
+        exec: "prettier --write .",
+        description: "Format generated files"
+      }
+    ]
+  };
+}
+
+// src/templates/extensions/core.workflows.custom_action.ts
+var EXTENSION_INTERFACE_ID = "core.workflows.custom_action";
+var customActionTemplate = {
+  methods: {
+    execute: { implementation_types: ["script", "remote-function"] },
+    get_form_state: { implementation_types: ["script", "remote-function"] }
+  },
+  description: "Custom actions let your app define actions that users can add to their automated workflows. When a workflow triggers a custom action, Stripe calls your app to execute it.",
+  generate: (params, context) => {
+    const { id } = params;
+    const { fs: fs4 } = context;
+    const base = _createBaseOutput(
+      {
+        ...params,
+        extensionInterfaceId: EXTENSION_INTERFACE_ID,
+        executionProfile: "egress"
+      },
+      context
+    );
+    return {
+      ...base,
+      files: [
+        {
+          path: `extensions/${id}/src/index.ts`,
+          content: fs4.textFile(EXTENSION_INTERFACE_ID, "index.ts"),
+          precious: true
+        },
+        {
+          path: `extensions/${id}/src/custom_input.schema.json`,
+          content: fs4.textFile(EXTENSION_INTERFACE_ID, "custom_input.schema.json"),
+          precious: true
+        },
+        {
+          path: `extensions/${id}/src/index.test.ts`,
+          content: fs4.textFile(EXTENSION_INTERFACE_ID, "index.test.ts"),
+          precious: true
+        },
+        ...base.files
+      ],
+      methods: {
+        execute: {
+          implementation_type: "script",
+          custom_input: {
+            input_schema: {
+              type: "json_schema",
+              content: `extensions/${id}/src/custom_input.schema.json`
+            }
+          }
+        },
+        get_form_state: {
+          implementation_type: "script"
+        }
+      }
+    };
+  }
+};
+var core_workflows_custom_action_default = {
+  [EXTENSION_INTERFACE_ID]: customActionTemplate
+};
+
+// src/templates/extensions/extend.objects.custom_objects.ts
+var EXTENSION_INTERFACE_ID2 = "extend.objects.custom_objects";
+var customObjectsTemplate = {
+  methods: {
+    execute_method: { implementation_types: ["script"] }
+  },
+  description: "Methods extension for custom object actions. Generated at build time \u2014 the transformed custom object class becomes the entry point.",
+  hidden: true,
+  generate: (params, context) => {
+    const base = _createBaseOutput(
+      {
+        ...params,
+        extensionInterfaceId: EXTENSION_INTERFACE_ID2,
+        executionProfile: "egress"
+      },
+      context
+    );
+    return {
+      ...base,
+      methods: {
+        execute_method: {
+          implementation_type: "script"
+        }
+      }
+    };
+  }
+};
+var extend_objects_custom_objects_default = {
+  [EXTENSION_INTERFACE_ID2]: customObjectsTemplate
+};
+
+// src/templates/extensions/extend.workflows.custom_action.ts
+var EXTENSION_INTERFACE_ID3 = "extend.workflows.custom_action";
+var extendCustomActionTemplate = {
+  methods: {
+    execute: { implementation_types: ["script", "remote-function"] },
+    get_form_state: { implementation_types: ["script", "remote-function"] }
+  },
+  description: "Custom actions let your app define actions that users can add to their automated workflows. When a workflow triggers a custom action, Stripe calls your app to execute it.",
+  generate: (params, context) => {
+    const { id } = params;
+    const { fs: fs4 } = context;
+    const base = _createBaseOutput(
+      {
+        ...params,
+        extensionInterfaceId: EXTENSION_INTERFACE_ID3,
+        executionProfile: "egress"
+      },
+      context
+    );
+    return {
+      ...base,
+      files: [
+        {
+          path: `extensions/${id}/src/index.ts`,
+          content: fs4.textFile(EXTENSION_INTERFACE_ID3, "index.ts"),
+          precious: true
+        },
+        {
+          path: `extensions/${id}/src/custom_input.schema.json`,
+          content: fs4.textFile(EXTENSION_INTERFACE_ID3, "custom_input.schema.json"),
+          precious: true
+        },
+        {
+          path: `extensions/${id}/src/index.test.ts`,
+          content: fs4.textFile(EXTENSION_INTERFACE_ID3, "index.test.ts"),
+          precious: true
+        },
+        ...base.files
+      ],
+      methods: {
+        execute: {
+          implementation_type: "script",
+          custom_input: {
+            input_schema: {
+              type: "json_schema",
+              content: `extensions/${id}/src/custom_input.schema.json`
+            }
+          }
+        },
+        get_form_state: {
+          implementation_type: "script"
+        }
+      }
+    };
+  }
+};
+var extend_workflows_custom_action_default = {
+  [EXTENSION_INTERFACE_ID3]: extendCustomActionTemplate
+};
+
+// src/templates/extensions/billing.customer_balance_application.ts
+var EXTENSION_INTERFACE_ID4 = "billing.customer_balance_application";
+var customerBalanceApplicationTemplate = {
+  methods: {
+    compute_applied_customer_balance: { implementation_types: ["script"] }
+  },
+  description: "Implement custom logic to control when and how much customer balance is applied to subscription invoices using scripts.",
+  generate: (params, context) => {
+    const { id } = params;
+    const { fs: fs4 } = context;
+    const base = _createBaseOutput(
+      {
+        ...params,
+        extensionInterfaceId: EXTENSION_INTERFACE_ID4,
+        executionProfile: "restricted"
+      },
+      context
+    );
+    return {
+      ...base,
+      files: [
+        {
+          path: `extensions/${id}/src/index.ts`,
+          content: fs4.textFile(EXTENSION_INTERFACE_ID4, "index.ts"),
+          precious: true
+        },
+        {
+          path: `extensions/${id}/src/index.test.ts`,
+          content: fs4.textFile(EXTENSION_INTERFACE_ID4, "index.test.ts"),
+          precious: true
+        },
+        ...base.files
+      ],
+      methods: {
+        compute_applied_customer_balance: {
+          implementation_type: "script"
+        }
+      }
+    };
+  }
+};
+var billing_customer_balance_application_default = {
+  [EXTENSION_INTERFACE_ID4]: customerBalanceApplicationTemplate
+};
+
+// src/templates/extensions/billing.bill.discount_calculation.ts
+var EXTENSION_INTERFACE_ID5 = "billing.bill.discount_calculation";
+var discountCalculationTemplate = {
+  hidden: true,
+  methods: {
+    compute_discounts: { implementation_types: ["script"] }
+  },
+  description: "Create coupons with custom scripting logic for dynamic discounts based on subscription attributes, customer metadata, and complex business rules.",
+  generate: (params, context) => {
+    const { id } = params;
+    const { fs: fs4 } = context;
+    const base = _createBaseOutput(
+      {
+        ...params,
+        extensionInterfaceId: EXTENSION_INTERFACE_ID5,
+        executionProfile: "restricted"
+      },
+      context
+    );
+    return {
+      ...base,
+      files: [
+        {
+          path: `extensions/${id}/src/index.ts`,
+          content: fs4.textFile(EXTENSION_INTERFACE_ID5, "index.ts"),
+          precious: true
+        },
+        {
+          path: `extensions/${id}/src/index.test.ts`,
+          content: fs4.textFile(EXTENSION_INTERFACE_ID5, "index.test.ts"),
+          precious: true
+        },
+        ...base.files
+      ],
+      methods: {
+        compute_discounts: {
+          implementation_type: "script"
+        }
+      }
+    };
+  }
+};
+var billing_bill_discount_calculation_default = {
+  [EXTENSION_INTERFACE_ID5]: discountCalculationTemplate
+};
+
+// src/templates/extensions/billing.invoice_collection_setting.ts
+var EXTENSION_INTERFACE_ID6 = "billing.invoice_collection_setting";
+var invoiceCollectionSettingTemplate = {
+  hidden: true,
+  methods: {
+    collection_override: { implementation_types: ["script"] }
+  },
+  description: "Use Stripe Scripts to create custom invoice collection logic that controls how your integration handles invoices generated from subscriptions.",
+  generate: (params, context) => {
+    const { id } = params;
+    const { fs: fs4 } = context;
+    const base = _createBaseOutput(
+      {
+        ...params,
+        extensionInterfaceId: EXTENSION_INTERFACE_ID6,
+        executionProfile: "restricted"
+      },
+      context
+    );
+    return {
+      ...base,
+      files: [
+        {
+          path: `extensions/${id}/src/index.ts`,
+          content: fs4.textFile(EXTENSION_INTERFACE_ID6, "index.ts"),
+          precious: true
+        },
+        {
+          path: `extensions/${id}/src/index.test.ts`,
+          content: fs4.textFile(EXTENSION_INTERFACE_ID6, "index.test.ts"),
+          precious: true
+        },
+        ...base.files
+      ],
+      methods: {
+        collection_override: {
+          implementation_type: "script"
+        }
+      }
+    };
+  }
+};
+var billing_invoice_collection_setting_default = {
+  [EXTENSION_INTERFACE_ID6]: invoiceCollectionSettingTemplate
+};
+
+// src/templates/extensions/billing.prorations.ts
+var EXTENSION_INTERFACE_ID7 = "billing.prorations";
+var prorationsTemplate = {
+  methods: {
+    prorate_items: { implementation_types: ["script"] }
+  },
+  description: "Create custom proration logic for subscriptions using scripts to handle upgrades, downgrades, and mid-cycle changes.",
+  generate: (params, context) => {
+    const { id } = params;
+    const { fs: fs4 } = context;
+    const base = _createBaseOutput(
+      {
+        ...params,
+        extensionInterfaceId: EXTENSION_INTERFACE_ID7,
+        executionProfile: "restricted"
+      },
+      context
+    );
+    return {
+      ...base,
+      files: [
+        {
+          path: `extensions/${id}/src/index.ts`,
+          content: fs4.textFile(EXTENSION_INTERFACE_ID7, "index.ts"),
+          precious: true
+        },
+        {
+          path: `extensions/${id}/src/index.test.ts`,
+          content: fs4.textFile(EXTENSION_INTERFACE_ID7, "index.test.ts"),
+          precious: true
+        },
+        ...base.files
+      ],
+      methods: {
+        prorate_items: {
+          implementation_type: "script"
+        }
+      }
+    };
+  }
+};
+var billing_prorations_default = {
+  [EXTENSION_INTERFACE_ID7]: prorationsTemplate
+};
+
+// src/templates/extensions/billing.recurring_billing_item_handling.ts
+var EXTENSION_INTERFACE_ID8 = "billing.recurring_billing_item_handling";
+var template = {
+  methods: {
+    before_item_creation: { implementation_types: ["script"] },
+    filter_items: { implementation_types: ["script"] },
+    group_items: { implementation_types: ["script"] }
+  },
+  description: "Customize how recurring billing items are filtered, grouped, and created during subscription billing runs.",
+  generate: (params, context) => {
+    const { id } = params;
+    const { fs: fs4 } = context;
+    const base = _createBaseOutput(
+      {
+        ...params,
+        extensionInterfaceId: EXTENSION_INTERFACE_ID8,
+        executionProfile: "restricted"
+      },
+      context
+    );
+    return {
+      ...base,
+      files: [
+        {
+          path: `extensions/${id}/src/index.ts`,
+          content: fs4.textFile(EXTENSION_INTERFACE_ID8, "index.ts"),
+          precious: true
+        },
+        {
+          path: `extensions/${id}/src/index.test.ts`,
+          content: fs4.textFile(EXTENSION_INTERFACE_ID8, "index.test.ts"),
+          precious: true
+        },
+        ...base.files
+      ],
+      methods: {
+        before_item_creation: {
+          implementation_type: "script"
+        },
+        filter_items: {
+          implementation_type: "script"
+        },
+        group_items: {
+          implementation_type: "script"
+        }
+      }
+    };
+  }
+};
+var billing_recurring_billing_item_handling_default = {
+  [EXTENSION_INTERFACE_ID8]: template
+};
+
+// src/templates/extensions/registry.ts
+var DEFAULT_TEMPLATES = {
+  ...core_workflows_custom_action_default,
+  ...extend_objects_custom_objects_default,
+  ...extend_workflows_custom_action_default,
+  ...billing_customer_balance_application_default,
+  ...billing_bill_discount_calculation_default,
+  ...billing_invoice_collection_setting_default,
+  ...billing_prorations_default,
+  ...billing_recurring_billing_item_handling_default
+};
+var registry_default = DEFAULT_TEMPLATES;
+
+// src/templates/extensions/index.ts
+var _templateManager = new _ExtensionTemplateManager(
+  registry_default,
+  _fs.scope("extensions")
+);
+
+// src/custom-objects/generated/proto/vendor/publicapi/v2ext.pb.ts
+var FieldPresence = {
+  /** FIELD_PRESENCE_INVALID - buf:lint:ignore ENUM_ZERO_VALUE_SUFFIX */
+  FIELD_PRESENCE_INVALID: "FIELD_PRESENCE_INVALID",
+  PRESENT: "PRESENT",
+  NOT_PRESENT: "NOT_PRESENT",
+  PRESENT_BUT_NULL: "PRESENT_BUT_NULL",
+  UNRECOGNIZED: "UNRECOGNIZED"
+};
+
+// src/custom-objects/generated/proto/custom_objects/pub/api/common/schema.pb.ts
+var DataType = {
+  UNSPECIFIED: "UNSPECIFIED",
+  STRING_TYPE: "STRING_TYPE",
+  INTEGER_TYPE: "INTEGER_TYPE",
+  BOOLEAN_TYPE: "BOOLEAN_TYPE",
+  ENUM_TYPE: "ENUM_TYPE",
+  OBJECT_REFERENCE_TYPE: "OBJECT_REFERENCE_TYPE",
+  DATETIME_TYPE: "DATETIME_TYPE",
+  UNRECOGNIZED: "UNRECOGNIZED"
+};
+
+// src/custom-objects/to-proto-json.ts
+function toUpsertRequestJson(buildArtifact) {
+  const { platformMetadata, fields, actions } = buildArtifact;
+  return {
+    apiNameSingular: platformMetadata.apiName,
+    apiNamePlural: platformMetadata.apiNamePlural,
+    displayNameSingular: platformMetadata.displayName,
+    displayNamePlural: platformMetadata.displayNamePlural,
+    description: fields.jsonSchema.description,
+    primaryDisplayProperty: buildArtifact.primaryDisplayProperty ?? "",
+    secondaryDisplayProperty: buildArtifact.secondaryDisplayProperty,
+    properties: mapProperties(fields.jsonSchema),
+    apiActions: mapActions(actions),
+    metadata: void 0,
+    targetCompartment: void 0
+  };
+}
+function mapActions(actions) {
+  const result = {};
+  for (const [apiName, action] of Object.entries(actions)) {
+    result[apiName] = {
+      scriptActionDefinition: {
+        scriptMethodName: action.methodName,
+        inputProperties: mapProperties(action.input?.jsonSchema),
+        outputProperties: mapProperties(action.output.jsonSchema)
+      }
+    };
+  }
+  return result;
+}
+function mapProperties(schema) {
+  const result = {};
+  const requiredSet = new Set(schema?.required ?? []);
+  if (!schema?.properties) return result;
+  const defs = schema.$defs ?? {};
+  for (const [key, propSchema] of Object.entries(schema.properties)) {
+    result[key] = toFieldSchema(resolveRef(propSchema, defs), requiredSet.has(key));
+  }
+  return result;
+}
+function resolveRef(schema, defs) {
+  const ref = schema.$ref;
+  if (!ref) return schema;
+  if (!ref.startsWith("#/$defs/")) return schema;
+  const defName = ref.slice("#/$defs/".length);
+  const defSchema = defs[defName];
+  if (!defSchema) return schema;
+  const { $ref: _, ...rest } = schema;
+  return { ...defSchema, ...rest };
+}
+function toFieldSchema(schema, required) {
+  const enumValues = extractEnumValues(schema);
+  const refTarget = schema.type === "object" ? getRefTargetType(schema) : null;
+  const dataType = resolveDataType(schema, enumValues, refTarget);
+  const fieldSchema = {
+    type: dataType,
+    values: [],
+    valuesPresence: FieldPresence.NOT_PRESENT
+  };
+  if (schema.title !== void 0) fieldSchema.title = schema.title;
+  if (schema.description !== void 0) fieldSchema.description = schema.description;
+  if (required) fieldSchema.required = true;
+  if (schema.deprecated) fieldSchema.deprecated = true;
+  if (refTarget !== null) fieldSchema.referencedType = refTarget;
+  if (schema.minLength !== void 0) fieldSchema.minLength = schema.minLength;
+  if (schema.maxLength !== void 0) fieldSchema.maxLength = schema.maxLength;
+  if (schema.minimum !== void 0) fieldSchema.minimum = toValueBoundary(schema.minimum);
+  if (schema.exclusiveMinimum !== void 0) {
+    fieldSchema.exclusiveMinimum = toValueBoundary(schema.exclusiveMinimum);
+  }
+  if (schema.maximum !== void 0) fieldSchema.maximum = toValueBoundary(schema.maximum);
+  if (schema.exclusiveMaximum !== void 0) {
+    fieldSchema.exclusiveMaximum = toValueBoundary(schema.exclusiveMaximum);
+  }
+  if (enumValues) {
+    fieldSchema.values = enumValues;
+    fieldSchema.valuesPresence = FieldPresence.PRESENT;
+  }
+  if (schema.default !== void 0) {
+    fieldSchema.default = toDefaultValue(schema.default, fieldSchema.type);
+  }
+  return fieldSchema;
+}
+function resolveDataType(schema, enumValues, refTarget) {
+  if (enumValues) return DataType.ENUM_TYPE;
+  if (refTarget !== null) return DataType.OBJECT_REFERENCE_TYPE;
+  switch (schema.type) {
+    case "string":
+      if (schema.format === "date-time") return DataType.DATETIME_TYPE;
+      return DataType.STRING_TYPE;
+    case "integer":
+    case "number":
+      return DataType.INTEGER_TYPE;
+    case "boolean":
+      return DataType.BOOLEAN_TYPE;
+    default:
+      return DataType.UNSPECIFIED;
+  }
+}
+function getRefTargetType(schema) {
+  if (!schema.properties) return null;
+  const properties = schema.properties;
+  const realProps = Object.keys(properties).filter((k) => !k.startsWith("__"));
+  const allowedProps = /* @__PURE__ */ new Set(["id", "type", "url"]);
+  if (realProps.length === 0 || realProps.some((k) => !allowedProps.has(k))) return null;
+  const idProp = properties.id;
+  const typeProp = properties.type;
+  if (!idProp || !typeProp) return null;
+  if (idProp.type !== "string") return null;
+  const requiredSet = new Set(schema.required ?? []);
+  if (!requiredSet.has("id") || !requiredSet.has("type")) return null;
+  return extractSingleLiteral(typeProp);
+}
+function extractSingleLiteral(schema) {
+  if (Array.isArray(schema.enum) && schema.enum.length === 1 && typeof schema.enum[0] === "string") {
+    return schema.enum[0];
+  }
+  if (Array.isArray(schema.oneOf) && schema.oneOf.length === 1 && schema.oneOf.every(
+    (item) => "const" in item && typeof item.const === "string"
+  )) {
+    const values = schema.oneOf.map(
+      (item) => String(item.const)
+    );
+    return values[0] ?? null;
+  }
+  return null;
+}
+function extractEnumValues(schema) {
+  if (schema.enum) {
+    return schema.enum.map(String);
+  }
+  if (Array.isArray(schema.oneOf) && schema.oneOf.length > 0 && schema.oneOf.every((item) => "const" in item)) {
+    return schema.oneOf.map((item) => String(item.const));
+  }
+  return null;
+}
+function toValueBoundary(value) {
+  if (!Number.isInteger(value)) {
+    throw new Error(
+      `ValueBoundary only supports integers, got ${String(value)}. Custom object numeric fields are integer-only.`
+    );
+  }
+  return { value: { $case: "integerBoundary", value } };
+}
+function toDefaultValue(value, dataType) {
+  if (dataType === DataType.STRING_TYPE && typeof value === "string") {
+    return { value: { $case: "stringDefault", value } };
+  }
+  if (dataType === DataType.INTEGER_TYPE && typeof value === "number") {
+    return { value: { $case: "integerDefault", value } };
+  }
+  if (dataType === DataType.BOOLEAN_TYPE && typeof value === "boolean") {
+    return { value: { $case: "booleanDefault", value } };
+  }
+  return { value: void 0 };
+}
+
+// src/custom-objects/build-definitions.ts
+import { _createCliContext as _createCliContext2 } from "@stripe/extensibility-tool-utils";
+async function analyzeAndInjectManifest(options) {
+  const context = options.context ?? _createCliContext2();
+  const manifestPath = options.manifestPath ?? "stripe-app.yaml";
+  const projectRoot = options.projectRoot ?? path2.dirname(path2.resolve(manifestPath));
+  const resolvedManifestPath = path2.resolve(manifestPath);
+  const manifest = await _ManifestV2.load(resolvedManifestPath);
+  const customObjects = manifest.getCustomObjects();
+  if (customObjects.length === 0) {
+    return null;
+  }
+  const targets = customObjects.map((obj) => ({
+    modulePath: path2.resolve(projectRoot, obj.path),
+    exportName: obj.name
+  }));
+  context.ux.log(
+    `Building ${String(customObjects.length)} custom object definition(s)...`
+  );
+  for (const obj of customObjects) {
+    context.ux.log(`  ${obj.path}#${obj.name}`);
+  }
+  const packageBuild = customObjectTools.buildCustomObjectPackage({ targets });
+  const errorDiagnostics = packageBuild.diagnostics.filter(
+    (diagnostic) => diagnostic.severity === "error"
+  );
+  if (errorDiagnostics.length > 0) {
+    const details = errorDiagnostics.map((diagnostic) => diagnostic.message).join("; ");
+    throw new Error(details);
+  }
+  const coPackageJsonPath = path2.join(projectRoot, "custom-objects", "package.json");
+  const coVersion = readPackageVersion(coPackageJsonPath);
+  const coDependencies = readPackageDependencies(coPackageJsonPath);
+  let manifestModified = false;
+  for (const obj of customObjects) {
+    const absoluteModulePath = path2.resolve(projectRoot, obj.path);
+    const objectKey = customObjectTools.toObjectKey({
+      modulePath: absoluteModulePath,
+      exportName: obj.name
+    });
+    const artifact = packageBuild.objects[objectKey];
+    if (!artifact) {
+      throw new Error(
+        `Package build did not return an artifact for "${obj.name}" (${obj.path}).`
+      );
+    }
+    const hasActions = Object.keys(artifact.actions).length > 0;
+    if (!hasActions) {
+      continue;
+    }
+    const transformedCode = packageBuild.transformedModules[absoluteModulePath];
+    if (!transformedCode) {
+      continue;
+    }
+    const extensionId = `methods.${obj.id}`;
+    const scriptContentPath = `extensions/${extensionId}/src/index.ts`;
+    const templateOutput = await _templateManager.generate(
+      "extend.objects.custom_objects",
+      { id: extensionId, name: `${obj.id} methods`, version: coVersion }
+    );
+    manifest.addOrUpdateExtension({
+      id: extensionId,
+      name: `${obj.id} methods`,
+      interface_id: "extend.objects.custom_objects",
+      version: manifest.getRawData().version,
+      script: {
+        type: "typescript",
+        content: scriptContentPath
+      },
+      permissions: [],
+      methods: templateOutput.methods
+    });
+    manifestModified = true;
+  }
+  if (manifestModified) {
+    await manifest.save();
+    context.ux.log("  Updated stripe-app.yaml with methods extension entries");
+  }
+  return {
+    packageBuild,
+    customObjects,
+    manifest,
+    coVersion,
+    coDependencies,
+    projectRoot
+  };
+}
+async function writeCustomObjectArtifacts(options, state) {
+  const context = options.context ?? _createCliContext2();
+  const targetPath = path2.resolve(options.targetPath);
+  const { packageBuild, customObjects, coVersion, coDependencies, projectRoot } = state;
+  for (const obj of customObjects) {
+    const absoluteModulePath = path2.resolve(projectRoot, obj.path);
+    const objectKey = customObjectTools.toObjectKey({
+      modulePath: absoluteModulePath,
+      exportName: obj.name
+    });
+    const artifact = packageBuild.objects[objectKey];
+    if (!artifact) {
+      throw new Error(
+        `Package build did not return an artifact for "${obj.name}" (${obj.path}).`
+      );
+    }
+    const requestJson = toUpsertRequestJson(artifact);
+    const definitionPath = path2.join(targetPath, obj.path.replace(/\.tsx?$/, ".json"));
+    fs2.mkdirSync(path2.dirname(definitionPath), { recursive: true });
+    fs2.writeFileSync(definitionPath, JSON.stringify(requestJson, null, 2) + "\n");
+    context.ux.log(`    \u2192 ${path2.relative(targetPath, definitionPath)}`);
+    const hasActions = Object.keys(artifact.actions).length > 0;
+    if (!hasActions) {
+      continue;
+    }
+    const transformedCode = packageBuild.transformedModules[absoluteModulePath];
+    if (!transformedCode) {
+      continue;
+    }
+    const extensionId = `methods.${obj.id}`;
+    const scriptContentPath = `extensions/${extensionId}/src/index.ts`;
+    const templateOutput = await _templateManager.generate(
+      "extend.objects.custom_objects",
+      { id: extensionId, name: `${obj.id} methods`, version: coVersion }
+    );
+    for (const file of templateOutput.files) {
+      const filePath = path2.join(targetPath, file.path);
+      fs2.mkdirSync(path2.dirname(filePath), { recursive: true });
+      if (file.path.endsWith("package.json") && coDependencies) {
+        const pkg = JSON.parse(file.content);
+        pkg.dependencies = coDependencies;
+        fs2.writeFileSync(filePath, JSON.stringify(pkg, null, 2) + "\n");
+      } else {
+        fs2.writeFileSync(filePath, file.content);
+      }
+      context.ux.log(`    \u2192 ${path2.relative(targetPath, filePath)}`);
+    }
+    const transformedPath = path2.join(targetPath, scriptContentPath);
+    fs2.mkdirSync(path2.dirname(transformedPath), { recursive: true });
+    fs2.writeFileSync(transformedPath, transformedCode);
+    context.ux.log(`    \u2192 ${path2.relative(targetPath, transformedPath)}`);
+  }
+}
+function readPackageJson(packageJsonPath) {
+  try {
+    const raw = JSON.parse(fs2.readFileSync(packageJsonPath, "utf8"));
+    if (typeof raw === "object" && raw !== null && !Array.isArray(raw)) {
+      return raw;
+    }
+  } catch {
+  }
+  return void 0;
+}
+function readPackageVersion(packageJsonPath) {
+  const pkg = readPackageJson(packageJsonPath);
+  return typeof pkg?.version === "string" ? pkg.version : "0.0.0";
+}
+function readPackageDependencies(packageJsonPath) {
+  const pkg = readPackageJson(packageJsonPath);
+  const deps = pkg?.dependencies;
+  if (typeof deps === "object" && deps !== null && !Array.isArray(deps)) {
+    return deps;
+  }
+  return void 0;
+}
+
+// src/bin/create-upload-image.ts
+async function main() {
+  const targetPath = process.argv[2];
+  if (!targetPath) {
+    console.error("Usage: create-upload-image <target-path>");
+    process.exit(1);
+  }
+  let state = null;
+  const manifestPath = "stripe-app.yaml";
+  if (fs3.existsSync(manifestPath)) {
+    state = await analyzeAndInjectManifest({ manifestPath });
+  }
+  fs3.mkdirSync(targetPath, { recursive: true });
+  const tarball = path3.join(os2.tmpdir(), `upload-image-${String(Date.now())}.tgz`);
+  try {
+    execSync2(`pnpm pack --out ${JSON.stringify(tarball)}`, { stdio: "pipe" });
+    execSync2(
+      `tar -xzf ${JSON.stringify(tarball)} -C ${JSON.stringify(targetPath)} --strip-components=1`,
+      { stdio: "pipe" }
+    );
+  } finally {
+    try {
+      fs3.unlinkSync(tarball);
+    } catch {
+    }
+  }
+  const extensionsDir = "extensions";
+  if (fs3.existsSync(extensionsDir)) {
+    const entries = fs3.readdirSync(extensionsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      const generatedSrc = path3.join(extensionsDir, entry.name, "generated");
+      if (!fs3.existsSync(generatedSrc)) {
+        continue;
+      }
+      const generatedDst = path3.join(targetPath, extensionsDir, entry.name, "generated");
+      fs3.mkdirSync(generatedDst, { recursive: true });
+      fs3.cpSync(generatedSrc, generatedDst, { recursive: true });
+    }
+  }
+  if (state) {
+    await writeCustomObjectArtifacts({ targetPath }, state);
+  }
+  const imageMetadata = JSON.stringify(
+    { image: { version: "1.0", built: (/* @__PURE__ */ new Date()).toISOString() } },
+    null,
+    2
+  );
+  fs3.writeFileSync(path3.join(targetPath, ".image.json"), imageMetadata + "\n");
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});