@coloop-ai/openai-ads-sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1000 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_sdk_gen = require("./sdk.gen-DZPUCME9.cjs");
+//#region src/errors.ts
+var OpenAIAdsApiError = class extends Error {
+	code;
+	param;
+	payload;
+	request;
+	response;
+	status;
+	statusText;
+	type;
+	constructor(options) {
+		super(options.message);
+		this.name = "OpenAIAdsApiError";
+		this.code = options.code;
+		this.param = options.param;
+		this.payload = options.payload;
+		this.request = options.request;
+		this.response = options.response;
+		this.status = options.status;
+		this.statusText = options.statusText;
+		this.type = options.type;
+	}
+};
+var OpenAIAdsTimeoutError = class extends Error {
+	request;
+	timeoutMs;
+	constructor(timeoutMs, request) {
+		super(`OpenAI Ads API request timed out after ${String(timeoutMs)} ms`);
+		this.name = "OpenAIAdsTimeoutError";
+		this.request = request;
+		this.timeoutMs = timeoutMs;
+	}
+};
+var OpenAIAdsConfigurationError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "OpenAIAdsConfigurationError";
+	}
+};
+//#endregion
+//#region src/rest-operations.ts
+const REST_OPERATIONS = {
+	"campaigns.list": rest("ListCampaignsMethod", "GET", "/campaigns"),
+	"campaigns.create": rest("CreateCampaignMethod", "POST", "/campaigns", { idempotency: "optional" }),
+	"campaigns.get": rest("GetCampaignMethod", "GET", "/campaigns/{campaign_id}"),
+	"campaigns.update": rest("UpdateCampaignMethod", "POST", "/campaigns/{campaign_id}"),
+	"campaigns.activate": rest("ActivateCampaignMethod", "POST", "/campaigns/{campaign_id}/activate"),
+	"campaigns.pause": rest("PauseCampaignMethod", "POST", "/campaigns/{campaign_id}/pause"),
+	"campaigns.archive": rest("ArchiveCampaignMethod", "POST", "/campaigns/{campaign_id}/archive"),
+	"customAudiences.list": rest("ListCustomAudiencesMethod", "GET", "/custom_audiences"),
+	"customAudiences.create": rest("CreateCustomAudienceMethod", "POST", "/custom_audiences"),
+	"customAudiences.get": rest("GetCustomAudienceMethod", "GET", "/custom_audiences/{custom_audience_id}"),
+	"customAudiences.archive": rest("ArchiveCustomAudienceMethod", "POST", "/custom_audiences/{custom_audience_id}/archive"),
+	"customAudiences.addMembers": rest("AddCustomAudienceMembersMethod", "POST", "/custom_audiences/{custom_audience_id}/add", { idempotency: "required" }),
+	"customAudiences.removeMembers": rest("RemoveCustomAudienceMembersMethod", "POST", "/custom_audiences/{custom_audience_id}/remove", { idempotency: "required" }),
+	"customAudiences.replaceMembers": rest("ReplaceCustomAudienceMembersMethod", "POST", "/custom_audiences/{custom_audience_id}/replace", { idempotency: "required" }),
+	"customAudiences.merge": rest("MergeCustomAudiencesMethod", "POST", "/custom_audiences/merge", { idempotency: "required" }),
+	"customAudiences.operations.get": rest("GetCustomAudienceOperationMethod", "GET", "/custom_audiences/{custom_audience_id}/operations/{operation_id}"),
+	"businessAgentTools.list": rest("ListBusinessAgentToolsMethod", "GET", "/business_agent_tools", {
+		accountHeader: false,
+		auth: "apiKey"
+	}),
+	"businessAgents.list": rest("ListBusinessAgentsMethod", "GET", "/business_agents"),
+	"businessAgents.create": rest("CreateBusinessAgentMethod", "POST", "/business_agents"),
+	"leadForms.list": rest("ListLeadFormsMethod", "GET", "/lead_forms"),
+	"leadForms.create": rest("CreateLeadFormMethod", "POST", "/lead_forms"),
+	"leadForms.get": rest("GetLeadFormMethod", "GET", "/lead_forms/{lead_form_id}"),
+	"leadForms.update": rest("UpdateLeadFormMethod", "POST", "/lead_forms/{lead_form_id}"),
+	"leadForms.publish": rest("PublishLeadFormMethod", "POST", "/lead_forms/{lead_form_id}/publish"),
+	"leadForms.archive": rest("ArchiveLeadFormMethod", "POST", "/lead_forms/{lead_form_id}/archive"),
+	"leadForms.testSubmissions.create": rest("CreateTestLeadSubmissionMethod", "POST", "/lead_forms/{lead_form_id}/test_submissions", { idempotency: "required" }),
+	"businessAgents.get": rest("GetBusinessAgentMethod", "GET", "/business_agents/{business_agent_id}"),
+	"businessAgents.update": rest("UpdateBusinessAgentMethod", "POST", "/business_agents/{business_agent_id}"),
+	"businessAgents.preview": rest("PreviewBusinessAgentMethod", "POST", "/business_agents/{business_agent_id}/preview"),
+	"businessAgents.publish": rest("PublishBusinessAgentMethod", "POST", "/business_agents/{business_agent_id}/publish"),
+	"apiKeys.create": rest("CreateApiKeyMethod", "POST", "/api_keys", {
+		accountHeader: false,
+		auth: "apiKey"
+	}),
+	"adAccount.updateBrand": rest("UpdateAdAccountMethod", "POST", "/ad_account/brand"),
+	"adAccount.updateNegativeKeywords": rest("UpdateAdAccountNegativeKeywordsMethod", "POST", "/ad_account/negative_keywords"),
+	"adAccount.activate": rest("ActivateAdAccountMethod", "POST", "/ad_account/activate"),
+	"adAccount.pause": rest("PauseAdAccountMethod", "POST", "/ad_account/pause"),
+	"adAccounts.list": rest("ListAdAccountsMethod", "GET", "/ad_accounts", { accountHeader: false }),
+	"adAccountCreationSessions.create": rest("CreateAdAccountCreationSessionMethod", "POST", "/ad_account_creation_sessions", {
+		accountHeader: false,
+		auth: "accessToken",
+		idempotency: "required"
+	}),
+	"oauth.getMe": rest("GetAdsOAuthMeMethod", "GET", "/me", {
+		accountHeader: false,
+		auth: "accessToken"
+	}),
+	"adAccount.get": rest("GetAdAccountMethod", "GET", "/ad_account"),
+	"adAccount.spendLimitWindows.list": rest("GetAdAccountSpendLimitWindowsMethod", "GET", "/ad_account/spend_limit_windows"),
+	"adAccount.spendLimitWindows.create": rest("CreateAdAccountSpendLimitWindowMethod", "POST", "/ad_account/spend_limit_windows"),
+	"adAccount.spendLimitWindows.update": rest("UpdateAdAccountSpendLimitWindowMethod", "POST", "/ad_account/spend_limit_windows/{window_id}"),
+	"adAccount.spendLimitWindows.delete": rest("DeleteAdAccountSpendLimitWindowMethod", "POST", "/ad_account/spend_limit_windows/{window_id}/delete"),
+	"insights.adAccount": rest("GetAdAccountInsightsMethod", "GET", "/ad_account/insights"),
+	"insights.campaign": rest("GetCampaignInsightsMethod", "GET", "/campaigns/{campaign_id}/insights"),
+	"insights.adGroup": rest("GetAdGroupInsightsMethod", "GET", "/ad_groups/{ad_group_id}/insights"),
+	"insights.ad": rest("GetAdInsightsMethod", "GET", "/ads/{ad_id}/insights"),
+	"geo.search": rest("GetGeoLookupMethod", "GET", "/geo_lookup/search"),
+	"leadSync.subscriptions.create": rest("CreateLeadSyncSubscriptionMethod", "POST", "/lead_sync_subscriptions", { idempotency: "required" }),
+	"leadSync.subscriptions.list": rest("ListLeadSyncSubscriptionsMethod", "GET", "/lead_sync_subscriptions"),
+	"leadSync.subscriptions.get": rest("GetLeadSyncSubscriptionMethod", "GET", "/lead_sync_subscriptions/{subscription_id}"),
+	"leadSync.subscriptions.delete": rest("DeleteLeadSyncSubscriptionMethod", "DELETE", "/lead_sync_subscriptions/{subscription_id}"),
+	"conversions.apiKeys.create": rest("CreateConversionApiKeyMethod", "POST", "/conversions/api_keys", {
+		accountHeader: false,
+		auth: "apiKey"
+	}),
+	"conversions.eventSettings.create": rest("CreateConversionEventSettingMethod", "POST", "/conversions/event_settings"),
+	"conversions.eventSettings.list": rest("ListConversionEventSettingsMethod", "GET", "/conversions/event_settings"),
+	"conversions.pixels.create": rest("CreateConversionSourceMethod", "POST", "/conversions/pixels"),
+	"conversions.pixels.list": rest("ListConversionSourcesMethod", "GET", "/conversions/pixels"),
+	"conversions.events.list": rest("ListConversionEventsMethod", "GET", "/conversions/events", {
+		accountHeader: false,
+		auth: "apiKey"
+	}),
+	"conversions.insights.query": rest("PostConversionInsightsMethod", "POST", "/conversions/insights"),
+	"adGroups.list": rest("ListAdGroupsMethod", "GET", "/ad_groups"),
+	"adGroups.create": rest("CreateAdGroupMethod", "POST", "/ad_groups", { idempotency: "optional" }),
+	"adGroups.get": rest("GetAdGroupMethod", "GET", "/ad_groups/{ad_group_id}"),
+	"adGroups.update": rest("UpdateAdGroupMethod", "POST", "/ad_groups/{ad_group_id}"),
+	"adGroups.activate": rest("ActivateAdGroupMethod", "POST", "/ad_groups/{ad_group_id}/activate"),
+	"adGroups.pause": rest("PauseAdGroupMethod", "POST", "/ad_groups/{ad_group_id}/pause"),
+	"adGroups.archive": rest("ArchiveAdGroupMethod", "POST", "/ad_groups/{ad_group_id}/archive"),
+	"ads.list": rest("ListAdsMethod", "GET", "/ads"),
+	"ads.create": rest("CreateAdMethod", "POST", "/ads", { idempotency: "optional" }),
+	"ads.get": rest("GetAdMethod", "GET", "/ads/{ad_id}"),
+	"ads.update": rest("UpdateAdMethod", "POST", "/ads/{ad_id}"),
+	"ads.preview": rest("CreateAdPreviewMethod", "POST", "/ads/{ad_id}/preview"),
+	"ads.activate": rest("ActivateAdMethod", "POST", "/ads/{ad_id}/activate"),
+	"ads.pause": rest("PauseAdMethod", "POST", "/ads/{ad_id}/pause"),
+	"ads.archive": rest("ArchiveAdMethod", "POST", "/ads/{ad_id}/archive"),
+	"files.uploadBlob": rest("UploadBlobMethod", "POST", "/uploads"),
+	"files.uploadImage": rest("UploadImageMethod", "POST", "/upload"),
+	"productFeeds.archive": rest("ArchiveProductFeedMethod", "POST", "/feeds/{feed_id}/archive"),
+	"productFeeds.create": rest("CreateProductFeedMethod", "POST", "/feeds"),
+	"productFeeds.list": rest("ListProductFeedsMethod", "GET", "/feeds"),
+	"productFeeds.uploads.list": rest("ListProductFeedUploadsMethod", "GET", "/feeds/uploads"),
+	"productFeeds.products.query": rest("QueryProductFeedProductsMethod", "POST", "/feeds/{feed_id}/products/query"),
+	"productFeeds.products.patch": rest("PatchProductFeedProductsMethod", "PATCH", "/feeds/{feed_id}/products"),
+	"productFeeds.sftpAccess.get": rest("GetProductFeedSftpAccessMethod", "GET", "/feeds/{feed_id}/sftp_access"),
+	"productFeeds.sftpAccess.createOrReplace": rest("PostProductFeedSftpAccessMethod", "POST", "/feeds/{feed_id}/sftp_access"),
+	"productFeeds.sftpAccess.activate": rest("PostProductFeedSftpAccessActivateMethod", "POST", "/feeds/{feed_id}/sftp_access/activate"),
+	"productFeeds.sftpAccess.pause": rest("PostProductFeedSftpAccessPauseMethod", "POST", "/feeds/{feed_id}/sftp_access/pause"),
+	"partnerData.uploads.create": rest("CreatePartnerDataUploadMethod", "POST", "/partner_data/uploads", {
+		accountHeader: false,
+		auth: "apiKey"
+	}),
+	"partnerData.uploads.get": rest("GetPartnerDataUploadMethod", "GET", "/partner_data/uploads/{upload_id}", {
+		accountHeader: false,
+		auth: "apiKey"
+	})
+};
+function rest(operationId, method, path, overrides = {}) {
+	return {
+		accountHeader: overrides.accountHeader ?? true,
+		auth: overrides.auth ?? "either",
+		idempotency: overrides.idempotency ?? "none",
+		method,
+		operationId,
+		path
+	};
+}
+//#endregion
+//#region src/openai-ads.ts
+const DEFAULT_BASE_URL = "https://api.ads.openai.com/v1";
+var OpenAIAds = class {
+	campaigns = {
+		list: (query = {}, options = {}) => this.run(REST_OPERATIONS["campaigns.list"], options, {}, (signal) => require_sdk_gen.listCampaignsMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			query,
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		create: (body, options = {}) => this.run(REST_OPERATIONS["campaigns.create"], options, {}, (signal) => require_sdk_gen.createCampaignMethod({
+			body,
+			client: this.client,
+			headers: this.optionalIdempotencyHeaders(options),
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		get: (campaignId, query = {}, options = {}) => this.run(REST_OPERATIONS["campaigns.get"], options, { campaign_id: campaignId }, (signal) => require_sdk_gen.getCampaignMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { campaign_id: campaignId },
+			query,
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		update: (campaignId, body, options = {}) => this.run(REST_OPERATIONS["campaigns.update"], options, { campaign_id: campaignId }, (signal) => require_sdk_gen.updateCampaignMethod({
+			body,
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { campaign_id: campaignId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		activate: (campaignId, options = {}) => this.run(REST_OPERATIONS["campaigns.activate"], options, { campaign_id: campaignId }, (signal) => require_sdk_gen.activateCampaignMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { campaign_id: campaignId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		pause: (campaignId, options = {}) => this.run(REST_OPERATIONS["campaigns.pause"], options, { campaign_id: campaignId }, (signal) => require_sdk_gen.pauseCampaignMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { campaign_id: campaignId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		archive: (campaignId, options = {}) => this.run(REST_OPERATIONS["campaigns.archive"], options, { campaign_id: campaignId }, (signal) => require_sdk_gen.archiveCampaignMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { campaign_id: campaignId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data))
+	};
+	customAudiences = {
+		list: (query = {}, options = {}) => this.run(REST_OPERATIONS["customAudiences.list"], options, {}, (signal) => require_sdk_gen.listCustomAudiencesMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			query,
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		create: (body, options = {}) => this.run(REST_OPERATIONS["customAudiences.create"], options, {}, (signal) => require_sdk_gen.createCustomAudienceMethod({
+			body,
+			client: this.client,
+			headers: this.accountHeaders(options),
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		get: (customAudienceId, query = {}, options = {}) => this.run(REST_OPERATIONS["customAudiences.get"], options, { custom_audience_id: customAudienceId }, (signal) => require_sdk_gen.getCustomAudienceMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { custom_audience_id: customAudienceId },
+			query,
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		archive: (customAudienceId, options = {}) => this.run(REST_OPERATIONS["customAudiences.archive"], options, { custom_audience_id: customAudienceId }, (signal) => require_sdk_gen.archiveCustomAudienceMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { custom_audience_id: customAudienceId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		addMembers: (customAudienceId, body, options) => this.run(REST_OPERATIONS["customAudiences.addMembers"], options, { custom_audience_id: customAudienceId }, (signal) => require_sdk_gen.addCustomAudienceMembersMethod({
+			body,
+			client: this.client,
+			headers: this.requiredIdempotencyHeaders(options),
+			path: { custom_audience_id: customAudienceId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		removeMembers: (customAudienceId, body, options) => this.run(REST_OPERATIONS["customAudiences.removeMembers"], options, { custom_audience_id: customAudienceId }, (signal) => require_sdk_gen.removeCustomAudienceMembersMethod({
+			body,
+			client: this.client,
+			headers: this.requiredIdempotencyHeaders(options),
+			path: { custom_audience_id: customAudienceId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		replaceMembers: (customAudienceId, body, options) => this.run(REST_OPERATIONS["customAudiences.replaceMembers"], options, { custom_audience_id: customAudienceId }, (signal) => require_sdk_gen.replaceCustomAudienceMembersMethod({
+			body,
+			client: this.client,
+			headers: this.requiredIdempotencyHeaders(options),
+			path: { custom_audience_id: customAudienceId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		merge: (body, options) => this.run(REST_OPERATIONS["customAudiences.merge"], options, {}, (signal) => require_sdk_gen.mergeCustomAudiencesMethod({
+			body,
+			client: this.client,
+			headers: this.requiredIdempotencyHeaders(options),
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		operations: { get: (customAudienceId, operationId, options = {}) => this.run(REST_OPERATIONS["customAudiences.operations.get"], options, {
+			custom_audience_id: customAudienceId,
+			operation_id: operationId
+		}, (signal) => require_sdk_gen.getCustomAudienceOperationMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: {
+				custom_audience_id: customAudienceId,
+				operation_id: operationId
+			},
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)) }
+	};
+	businessAgentTools = { list: (options = {}) => this.run(REST_OPERATIONS["businessAgentTools.list"], options, {}, (signal) => require_sdk_gen.listBusinessAgentToolsMethod({
+		client: this.client,
+		signal,
+		throwOnError: true
+	}).then(({ data }) => data)) };
+	businessAgents = {
+		list: (options = {}) => this.run(REST_OPERATIONS["businessAgents.list"], options, {}, (signal) => require_sdk_gen.listBusinessAgentsMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		create: (body, options = {}) => this.run(REST_OPERATIONS["businessAgents.create"], options, {}, (signal) => require_sdk_gen.createBusinessAgentMethod({
+			body,
+			client: this.client,
+			headers: this.accountHeaders(options),
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		get: (businessAgentId, options = {}) => this.run(REST_OPERATIONS["businessAgents.get"], options, { business_agent_id: businessAgentId }, (signal) => require_sdk_gen.getBusinessAgentMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { business_agent_id: businessAgentId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		update: (businessAgentId, body, options = {}) => this.run(REST_OPERATIONS["businessAgents.update"], options, { business_agent_id: businessAgentId }, (signal) => require_sdk_gen.updateBusinessAgentMethod({
+			body,
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { business_agent_id: businessAgentId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		preview: (businessAgentId, body, options = {}) => this.run(REST_OPERATIONS["businessAgents.preview"], options, { business_agent_id: businessAgentId }, (signal) => require_sdk_gen.previewBusinessAgentMethod({
+			body,
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { business_agent_id: businessAgentId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		publish: (businessAgentId, options = {}) => this.run(REST_OPERATIONS["businessAgents.publish"], options, { business_agent_id: businessAgentId }, (signal) => require_sdk_gen.publishBusinessAgentMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { business_agent_id: businessAgentId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data))
+	};
+	leadForms = {
+		list: (options = {}) => this.run(REST_OPERATIONS["leadForms.list"], options, {}, (signal) => require_sdk_gen.listLeadFormsMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		create: (body, options = {}) => this.run(REST_OPERATIONS["leadForms.create"], options, {}, (signal) => require_sdk_gen.createLeadFormMethod({
+			body,
+			client: this.client,
+			headers: this.accountHeaders(options),
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		get: (leadFormId, query = {}, options = {}) => this.run(REST_OPERATIONS["leadForms.get"], options, { lead_form_id: leadFormId }, (signal) => require_sdk_gen.getLeadFormMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { lead_form_id: leadFormId },
+			query,
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		update: (leadFormId, body, options = {}) => this.run(REST_OPERATIONS["leadForms.update"], options, { lead_form_id: leadFormId }, (signal) => require_sdk_gen.updateLeadFormMethod({
+			body,
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { lead_form_id: leadFormId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		publish: (leadFormId, body, options = {}) => this.run(REST_OPERATIONS["leadForms.publish"], options, { lead_form_id: leadFormId }, (signal) => require_sdk_gen.publishLeadFormMethod({
+			body,
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { lead_form_id: leadFormId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		archive: (leadFormId, options = {}) => this.run(REST_OPERATIONS["leadForms.archive"], options, { lead_form_id: leadFormId }, (signal) => require_sdk_gen.archiveLeadFormMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { lead_form_id: leadFormId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		testSubmissions: { create: (leadFormId, body, options) => this.run(REST_OPERATIONS["leadForms.testSubmissions.create"], options, { lead_form_id: leadFormId }, (signal) => require_sdk_gen.createTestLeadSubmissionMethod({
+			body,
+			client: this.client,
+			headers: this.requiredIdempotencyHeaders(options),
+			path: { lead_form_id: leadFormId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)) }
+	};
+	apiKeys = { create: (body, options = {}) => this.run(REST_OPERATIONS["apiKeys.create"], options, {}, (signal) => require_sdk_gen.createApiKeyMethod({
+		body,
+		client: this.client,
+		signal,
+		throwOnError: true
+	}).then(({ data }) => data)) };
+	adAccount = {
+		updateBrand: (body, options = {}) => this.run(REST_OPERATIONS["adAccount.updateBrand"], options, {}, (signal) => require_sdk_gen.updateAdAccountMethod({
+			body,
+			client: this.client,
+			headers: this.accountHeaders(options),
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		updateNegativeKeywords: (body, options = {}) => this.run(REST_OPERATIONS["adAccount.updateNegativeKeywords"], options, {}, (signal) => require_sdk_gen.updateAdAccountNegativeKeywordsMethod({
+			body,
+			client: this.client,
+			headers: this.accountHeaders(options),
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		activate: (options = {}) => this.run(REST_OPERATIONS["adAccount.activate"], options, {}, (signal) => require_sdk_gen.activateAdAccountMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		pause: (options = {}) => this.run(REST_OPERATIONS["adAccount.pause"], options, {}, (signal) => require_sdk_gen.pauseAdAccountMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		get: (options = {}) => this.run(REST_OPERATIONS["adAccount.get"], options, {}, (signal) => require_sdk_gen.getAdAccountMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		spendLimitWindows: {
+			list: (options = {}) => this.run(REST_OPERATIONS["adAccount.spendLimitWindows.list"], options, {}, (signal) => require_sdk_gen.getAdAccountSpendLimitWindowsMethod({
+				client: this.client,
+				headers: this.accountHeaders(options),
+				signal,
+				throwOnError: true
+			}).then(({ data }) => data)),
+			create: (body, options = {}) => this.run(REST_OPERATIONS["adAccount.spendLimitWindows.create"], options, {}, (signal) => require_sdk_gen.createAdAccountSpendLimitWindowMethod({
+				body,
+				client: this.client,
+				headers: this.accountHeaders(options),
+				signal,
+				throwOnError: true
+			}).then(({ data }) => data)),
+			update: (windowId, body, options = {}) => this.run(REST_OPERATIONS["adAccount.spendLimitWindows.update"], options, { window_id: windowId }, (signal) => require_sdk_gen.updateAdAccountSpendLimitWindowMethod({
+				body,
+				client: this.client,
+				headers: this.accountHeaders(options),
+				path: { window_id: windowId },
+				signal,
+				throwOnError: true
+			}).then(({ data }) => data)),
+			delete: (windowId, options = {}) => this.run(REST_OPERATIONS["adAccount.spendLimitWindows.delete"], options, { window_id: windowId }, (signal) => require_sdk_gen.deleteAdAccountSpendLimitWindowMethod({
+				client: this.client,
+				headers: this.accountHeaders(options),
+				path: { window_id: windowId },
+				signal,
+				throwOnError: true
+			}).then(({ data }) => data))
+		}
+	};
+	adAccounts = { list: (query = {}, options = {}) => this.run(REST_OPERATIONS["adAccounts.list"], options, {}, (signal) => require_sdk_gen.listAdAccountsMethod({
+		client: this.client,
+		query,
+		signal,
+		throwOnError: true
+	}).then(({ data }) => data)) };
+	adAccountCreationSessions = { create: (body, options) => this.run(REST_OPERATIONS["adAccountCreationSessions.create"], options, {}, (signal) => require_sdk_gen.createAdAccountCreationSessionMethod({
+		body,
+		client: this.client,
+		headers: { "Idempotency-Key": options.idempotencyKey },
+		signal,
+		throwOnError: true
+	}).then(({ data }) => data)) };
+	oauth = { getMe: (options = {}) => this.run(REST_OPERATIONS["oauth.getMe"], options, {}, (signal) => require_sdk_gen.getAdsOAuthMeMethod({
+		client: this.client,
+		signal,
+		throwOnError: true
+	}).then(({ data }) => data)) };
+	insights = {
+		adAccount: (query = {}, options = {}) => this.run(REST_OPERATIONS["insights.adAccount"], options, {}, (signal) => require_sdk_gen.getAdAccountInsightsMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			query,
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		campaign: (campaignId, query = {}, options = {}) => this.run(REST_OPERATIONS["insights.campaign"], options, { campaign_id: campaignId }, (signal) => require_sdk_gen.getCampaignInsightsMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { campaign_id: campaignId },
+			query,
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		adGroup: (adGroupId, query = {}, options = {}) => this.run(REST_OPERATIONS["insights.adGroup"], options, { ad_group_id: adGroupId }, (signal) => require_sdk_gen.getAdGroupInsightsMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { ad_group_id: adGroupId },
+			query,
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		ad: (adId, query = {}, options = {}) => this.run(REST_OPERATIONS["insights.ad"], options, { ad_id: adId }, (signal) => require_sdk_gen.getAdInsightsMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { ad_id: adId },
+			query,
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data))
+	};
+	geo = { search: (query, options = {}) => this.run(REST_OPERATIONS["geo.search"], options, {}, (signal) => require_sdk_gen.getGeoLookupMethod({
+		client: this.client,
+		headers: this.accountHeaders(options),
+		query,
+		signal,
+		throwOnError: true
+	}).then(({ data }) => data)) };
+	leadSync = { subscriptions: {
+		create: (body, options) => this.run(REST_OPERATIONS["leadSync.subscriptions.create"], options, {}, (signal) => require_sdk_gen.createLeadSyncSubscriptionMethod({
+			body,
+			client: this.client,
+			headers: this.requiredIdempotencyHeaders(options),
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		list: (query, options = {}) => this.run(REST_OPERATIONS["leadSync.subscriptions.list"], options, {}, (signal) => require_sdk_gen.listLeadSyncSubscriptionsMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			query,
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		get: (subscriptionId, options = {}) => this.run(REST_OPERATIONS["leadSync.subscriptions.get"], options, { subscription_id: subscriptionId }, (signal) => require_sdk_gen.getLeadSyncSubscriptionMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { subscription_id: subscriptionId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		delete: (subscriptionId, options = {}) => this.run(REST_OPERATIONS["leadSync.subscriptions.delete"], options, { subscription_id: subscriptionId }, (signal) => require_sdk_gen.deleteLeadSyncSubscriptionMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { subscription_id: subscriptionId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data))
+	} };
+	conversions = {
+		apiKeys: { create: (body, options = {}) => this.run(REST_OPERATIONS["conversions.apiKeys.create"], options, {}, (signal) => require_sdk_gen.createConversionApiKeyMethod({
+			body,
+			client: this.client,
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)) },
+		eventSettings: {
+			create: (body, options = {}) => this.run(REST_OPERATIONS["conversions.eventSettings.create"], options, {}, (signal) => require_sdk_gen.createConversionEventSettingMethod({
+				body,
+				client: this.client,
+				headers: this.accountHeaders(options),
+				signal,
+				throwOnError: true
+			}).then(({ data }) => data)),
+			list: (query = {}, options = {}) => this.run(REST_OPERATIONS["conversions.eventSettings.list"], options, {}, (signal) => require_sdk_gen.listConversionEventSettingsMethod({
+				client: this.client,
+				headers: this.accountHeaders(options),
+				query,
+				signal,
+				throwOnError: true
+			}).then(({ data }) => data))
+		},
+		pixels: {
+			create: (body, options = {}) => this.run(REST_OPERATIONS["conversions.pixels.create"], options, {}, (signal) => require_sdk_gen.createConversionSourceMethod({
+				body,
+				client: this.client,
+				headers: this.accountHeaders(options),
+				signal,
+				throwOnError: true
+			}).then(({ data }) => data)),
+			list: (query = {}, options = {}) => this.run(REST_OPERATIONS["conversions.pixels.list"], options, {}, (signal) => require_sdk_gen.listConversionSourcesMethod({
+				client: this.client,
+				headers: this.accountHeaders(options),
+				query,
+				signal,
+				throwOnError: true
+			}).then(({ data }) => data))
+		},
+		events: { list: (query, options = {}) => this.run(REST_OPERATIONS["conversions.events.list"], options, {}, (signal) => require_sdk_gen.listConversionEventsMethod({
+			client: this.client,
+			query,
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)) },
+		insights: { query: (body, options = {}) => this.run(REST_OPERATIONS["conversions.insights.query"], options, {}, (signal) => require_sdk_gen.postConversionInsightsMethod({
+			body,
+			client: this.client,
+			headers: this.accountHeaders(options),
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)) }
+	};
+	adGroups = {
+		list: (query = {}, options = {}) => this.run(REST_OPERATIONS["adGroups.list"], options, {}, (signal) => require_sdk_gen.listAdGroupsMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			query,
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		create: (body, options = {}) => this.run(REST_OPERATIONS["adGroups.create"], options, {}, (signal) => require_sdk_gen.createAdGroupMethod({
+			body,
+			client: this.client,
+			headers: this.optionalIdempotencyHeaders(options),
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		get: (adGroupId, query = {}, options = {}) => this.run(REST_OPERATIONS["adGroups.get"], options, { ad_group_id: adGroupId }, (signal) => require_sdk_gen.getAdGroupMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { ad_group_id: adGroupId },
+			query,
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		update: (adGroupId, body, options = {}) => this.run(REST_OPERATIONS["adGroups.update"], options, { ad_group_id: adGroupId }, (signal) => require_sdk_gen.updateAdGroupMethod({
+			body,
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { ad_group_id: adGroupId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		activate: (adGroupId, options = {}) => this.run(REST_OPERATIONS["adGroups.activate"], options, { ad_group_id: adGroupId }, (signal) => require_sdk_gen.activateAdGroupMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { ad_group_id: adGroupId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		pause: (adGroupId, options = {}) => this.run(REST_OPERATIONS["adGroups.pause"], options, { ad_group_id: adGroupId }, (signal) => require_sdk_gen.pauseAdGroupMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { ad_group_id: adGroupId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		archive: (adGroupId, options = {}) => this.run(REST_OPERATIONS["adGroups.archive"], options, { ad_group_id: adGroupId }, (signal) => require_sdk_gen.archiveAdGroupMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { ad_group_id: adGroupId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data))
+	};
+	ads = {
+		list: (query = {}, options = {}) => this.run(REST_OPERATIONS["ads.list"], options, {}, (signal) => require_sdk_gen.listAdsMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			query,
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		create: (body, options = {}) => this.run(REST_OPERATIONS["ads.create"], options, {}, (signal) => require_sdk_gen.createAdMethod({
+			body,
+			client: this.client,
+			headers: this.optionalIdempotencyHeaders(options),
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		get: (adId, query = {}, options = {}) => this.run(REST_OPERATIONS["ads.get"], options, { ad_id: adId }, (signal) => require_sdk_gen.getAdMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { ad_id: adId },
+			query,
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		update: (adId, body, options = {}) => this.run(REST_OPERATIONS["ads.update"], options, { ad_id: adId }, (signal) => require_sdk_gen.updateAdMethod({
+			body,
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { ad_id: adId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		preview: (adId, options = {}) => this.run(REST_OPERATIONS["ads.preview"], options, { ad_id: adId }, (signal) => require_sdk_gen.createAdPreviewMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { ad_id: adId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		activate: (adId, options = {}) => this.run(REST_OPERATIONS["ads.activate"], options, { ad_id: adId }, (signal) => require_sdk_gen.activateAdMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { ad_id: adId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		pause: (adId, options = {}) => this.run(REST_OPERATIONS["ads.pause"], options, { ad_id: adId }, (signal) => require_sdk_gen.pauseAdMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { ad_id: adId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		archive: (adId, options = {}) => this.run(REST_OPERATIONS["ads.archive"], options, { ad_id: adId }, (signal) => require_sdk_gen.archiveAdMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { ad_id: adId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data))
+	};
+	files = {
+		uploadBlob: (body, options = {}) => this.run(REST_OPERATIONS["files.uploadBlob"], options, {}, (signal) => require_sdk_gen.uploadBlobMethod({
+			body,
+			client: this.client,
+			headers: this.accountHeaders(options),
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		uploadImage: (body, options = {}) => this.run(REST_OPERATIONS["files.uploadImage"], options, {}, (signal) => {
+			const multipart = "file" in body;
+			const headers = this.accountHeaders(options);
+			if (multipart) headers["Content-Type"] = null;
+			return require_sdk_gen.uploadImageMethod({
+				...multipart ? require_sdk_gen.formDataBodySerializer : {},
+				body,
+				client: this.client,
+				headers,
+				signal,
+				throwOnError: true
+			}).then(({ data }) => data);
+		})
+	};
+	productFeeds = {
+		archive: (feedId, options = {}) => this.run(REST_OPERATIONS["productFeeds.archive"], options, { feed_id: feedId }, (signal) => require_sdk_gen.archiveProductFeedMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			path: { feed_id: feedId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		create: (body, options = {}) => this.run(REST_OPERATIONS["productFeeds.create"], options, {}, (signal) => require_sdk_gen.createProductFeedMethod({
+			body,
+			client: this.client,
+			headers: this.accountHeaders(options),
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		list: (query = {}, options = {}) => this.run(REST_OPERATIONS["productFeeds.list"], options, {}, (signal) => require_sdk_gen.listProductFeedsMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			query,
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		uploads: { list: (query = {}, options = {}) => this.run(REST_OPERATIONS["productFeeds.uploads.list"], options, {}, (signal) => require_sdk_gen.listProductFeedUploadsMethod({
+			client: this.client,
+			headers: this.accountHeaders(options),
+			query,
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)) },
+		products: {
+			query: (feedId, body, options = {}) => this.run(REST_OPERATIONS["productFeeds.products.query"], options, { feed_id: feedId }, (signal) => require_sdk_gen.queryProductFeedProductsMethod({
+				body,
+				client: this.client,
+				headers: this.accountHeaders(options),
+				path: { feed_id: feedId },
+				signal,
+				throwOnError: true
+			}).then(({ data }) => data)),
+			patch: (feedId, body, options = {}) => this.run(REST_OPERATIONS["productFeeds.products.patch"], options, { feed_id: feedId }, (signal) => require_sdk_gen.patchProductFeedProductsMethod({
+				body,
+				client: this.client,
+				headers: this.accountHeaders(options),
+				path: { feed_id: feedId },
+				signal,
+				throwOnError: true
+			}).then(({ data }) => data))
+		},
+		sftpAccess: {
+			get: (feedId, options = {}) => this.run(REST_OPERATIONS["productFeeds.sftpAccess.get"], options, { feed_id: feedId }, (signal) => require_sdk_gen.getProductFeedSftpAccessMethod({
+				client: this.client,
+				headers: this.accountHeaders(options),
+				path: { feed_id: feedId },
+				signal,
+				throwOnError: true
+			}).then(({ data }) => data)),
+			createOrReplace: (feedId, body, options = {}) => this.run(REST_OPERATIONS["productFeeds.sftpAccess.createOrReplace"], options, { feed_id: feedId }, (signal) => require_sdk_gen.postProductFeedSftpAccessMethod({
+				body,
+				client: this.client,
+				headers: this.accountHeaders(options),
+				path: { feed_id: feedId },
+				signal,
+				throwOnError: true
+			}).then(({ data }) => data)),
+			activate: (feedId, options = {}) => this.run(REST_OPERATIONS["productFeeds.sftpAccess.activate"], options, { feed_id: feedId }, (signal) => require_sdk_gen.postProductFeedSftpAccessActivateMethod({
+				client: this.client,
+				headers: this.accountHeaders(options),
+				path: { feed_id: feedId },
+				signal,
+				throwOnError: true
+			}).then(({ data }) => data)),
+			pause: (feedId, options = {}) => this.run(REST_OPERATIONS["productFeeds.sftpAccess.pause"], options, { feed_id: feedId }, (signal) => require_sdk_gen.postProductFeedSftpAccessPauseMethod({
+				client: this.client,
+				headers: this.accountHeaders(options),
+				path: { feed_id: feedId },
+				signal,
+				throwOnError: true
+			}).then(({ data }) => data))
+		}
+	};
+	partnerData = { uploads: {
+		create: (body, options = {}) => this.run(REST_OPERATIONS["partnerData.uploads.create"], options, {}, (signal) => require_sdk_gen.createPartnerDataUploadMethod({
+			body,
+			client: this.client,
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data)),
+		get: (uploadId, options = {}) => this.run(REST_OPERATIONS["partnerData.uploads.get"], options, { upload_id: uploadId }, (signal) => require_sdk_gen.getPartnerDataUploadMethod({
+			client: this.client,
+			path: { upload_id: uploadId },
+			signal,
+			throwOnError: true
+		}).then(({ data }) => data))
+	} };
+	baseUrl;
+	client;
+	credential;
+	credentialMode;
+	defaultAdAccountId;
+	defaultTimeoutMs;
+	constructor(options) {
+		this.baseUrl = normalizeBaseUrl(options.baseUrl ?? DEFAULT_BASE_URL);
+		this.defaultAdAccountId = options.adAccountId;
+		this.defaultTimeoutMs = validateTimeout(options.timeoutMs);
+		if (options.apiKey === void 0 === (options.accessToken === void 0)) throw new OpenAIAdsConfigurationError("Provide exactly one of apiKey or accessToken");
+		if (options.apiKey !== void 0) {
+			this.credential = options.apiKey;
+			this.credentialMode = "apiKey";
+		} else {
+			this.credential = options.accessToken;
+			this.credentialMode = "accessToken";
+		}
+		validateStaticCredential(this.credential);
+		const baseFetch = options.fetch ?? globalThis.fetch;
+		if (typeof baseFetch !== "function") throw new OpenAIAdsConfigurationError("A Fetch API implementation is required");
+		this.client = require_sdk_gen.createClient({
+			baseUrl: this.baseUrl,
+			fetch: this.authenticatedFetch(baseFetch),
+			responseStyle: "fields",
+			throwOnError: true
+		});
+	}
+	accountHeaders(options) {
+		const adAccountId = options.adAccountId ?? this.defaultAdAccountId;
+		return adAccountId ? { "OpenAI-Ad-Account": adAccountId } : {};
+	}
+	optionalIdempotencyHeaders(options) {
+		return {
+			...this.accountHeaders(options),
+			...options.idempotencyKey ? { "Idempotency-Key": options.idempotencyKey } : {}
+		};
+	}
+	requiredIdempotencyHeaders(options) {
+		return {
+			...this.accountHeaders(options),
+			"Idempotency-Key": options.idempotencyKey
+		};
+	}
+	assertAuthentication(requirement) {
+		if (requirement !== "either" && requirement !== this.credentialMode) throw new OpenAIAdsConfigurationError(requirement === "apiKey" ? "This operation requires an Ads API key" : "This operation requires an Ads OAuth access token");
+	}
+	authenticatedFetch(baseFetch) {
+		return async (input, init) => {
+			const request = new Request(input, init);
+			const credential = await resolveCredential(this.credential);
+			const headers = new Headers(request.headers);
+			headers.set("Authorization", `Bearer ${credential}`);
+			const authenticatedRequest = new Request(request, { headers });
+			const response = await baseFetch(authenticatedRequest);
+			if (!response.ok) throw await createApiError(response, authenticatedRequest);
+			return response;
+		};
+	}
+	async run(operation, options, pathValues, request) {
+		this.assertAuthentication(operation.auth);
+		const timeoutMs = options.timeoutMs === void 0 ? this.defaultTimeoutMs : validateTimeout(options.timeoutMs);
+		if (timeoutMs === void 0) return request(options.signal);
+		const controller = new AbortController();
+		const removeAbortForwarder = forwardAbort(options.signal, controller);
+		const timeoutError = new OpenAIAdsTimeoutError(timeoutMs, {
+			method: operation.method,
+			url: this.operationUrl(operation, pathValues)
+		});
+		let rejectTimeout;
+		const timeout = new Promise((_resolve, reject) => {
+			rejectTimeout = reject;
+		});
+		const timer = setTimeout(() => {
+			controller.abort(timeoutError);
+			rejectTimeout(timeoutError);
+		}, timeoutMs);
+		try {
+			return await Promise.race([request(controller.signal), timeout]);
+		} finally {
+			clearTimeout(timer);
+			removeAbortForwarder();
+		}
+	}
+	operationUrl(operation, pathValues) {
+		const path = operation.path.replaceAll(/\{([^}]+)\}/g, (_match, key) => encodeURIComponent(String(pathValues[key])));
+		return `${this.baseUrl}${path}`;
+	}
+};
+function normalizeBaseUrl(baseUrl) {
+	const normalized = baseUrl.replace(/\/+$/, "");
+	if (!normalized) throw new OpenAIAdsConfigurationError("baseUrl must not be empty");
+	return normalized;
+}
+function validateStaticCredential(credential) {
+	if (typeof credential === "string" && credential.trim().length === 0) throw new OpenAIAdsConfigurationError("The credential must not be empty");
+}
+async function resolveCredential(credential) {
+	const value = typeof credential === "function" ? await credential() : credential;
+	if (value.trim().length === 0) throw new OpenAIAdsConfigurationError("The credential must not be empty");
+	return value;
+}
+function validateTimeout(timeoutMs) {
+	if (timeoutMs === void 0) return;
+	if (!Number.isFinite(timeoutMs) || !Number.isInteger(timeoutMs) || timeoutMs <= 0) throw new OpenAIAdsConfigurationError("timeoutMs must be a positive finite integer");
+	return timeoutMs;
+}
+function forwardAbort(signal, controller) {
+	if (signal === void 0) return () => {};
+	const abort = () => {
+		controller.abort(signal.reason);
+	};
+	if (signal.aborted) {
+		abort();
+		return () => {};
+	}
+	signal.addEventListener("abort", abort, { once: true });
+	return () => {
+		signal.removeEventListener("abort", abort);
+	};
+}
+async function createApiError(response, request) {
+	const text = await response.clone().text();
+	let payload = text;
+	if (text) try {
+		payload = JSON.parse(text);
+	} catch {
+		payload = text;
+	}
+	const envelope = isRecord(payload) ? payload["error"] : void 0;
+	const details = isRecord(envelope) ? envelope : void 0;
+	const message = typeof details?.["message"] === "string" ? details["message"] : `OpenAI Ads API request failed with status ${String(response.status)}`;
+	return new OpenAIAdsApiError({
+		...typeof details?.["code"] === "string" ? { code: details["code"] } : {},
+		message,
+		...details?.["param"] === null || typeof details?.["param"] === "string" ? { param: details["param"] } : {},
+		payload,
+		request: {
+			method: request.method,
+			url: request.url
+		},
+		response,
+		status: response.status,
+		statusText: response.statusText,
+		...typeof details?.["type"] === "string" ? { type: details["type"] } : {}
+	});
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null;
+}
+//#endregion
+exports.OpenAIAds = OpenAIAds;
+exports.OpenAIAdsApiError = OpenAIAdsApiError;
+exports.OpenAIAdsConfigurationError = OpenAIAdsConfigurationError;
+exports.OpenAIAdsTimeoutError = OpenAIAdsTimeoutError;
+
+//# sourceMappingURL=index.cjs.map