autumn-js 1.3.34 → 1.3.35
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/backend/adapters/express.js +10099 -9503
- package/dist/backend/adapters/express.mjs +8 -8
- package/dist/backend/adapters/fetch.js +10099 -9503
- package/dist/backend/adapters/fetch.mjs +8 -8
- package/dist/backend/adapters/hono.js +10099 -9503
- package/dist/backend/adapters/hono.mjs +8 -8
- package/dist/backend/adapters/index.js +10099 -9503
- package/dist/backend/adapters/index.mjs +11 -11
- package/dist/backend/adapters/next.js +10099 -9503
- package/dist/backend/adapters/next.mjs +8 -8
- package/dist/backend/{chunk-LTMWEBRJ.mjs → chunk-73QHDEEQ.mjs} +1 -1
- package/dist/backend/{chunk-H44KPDWX.mjs → chunk-HS4KYMOQ.mjs} +1 -1
- package/dist/backend/{chunk-TQATC7YM.mjs → chunk-I2CKPS5D.mjs} +10090 -9494
- package/dist/backend/{chunk-NZSJPASA.mjs → chunk-JKHG2JZG.mjs} +4 -4
- package/dist/backend/{chunk-DCTJBCHH.mjs → chunk-JSLDOR53.mjs} +1 -1
- package/dist/backend/{chunk-7THFU2HQ.mjs → chunk-LMRT4FAW.mjs} +1 -1
- package/dist/backend/{chunk-2V6DX4RS.mjs → chunk-QLIIZN47.mjs} +6 -6
- package/dist/backend/core/handlers/coreHandler.d.mts +1 -1
- package/dist/backend/core/handlers/coreHandler.d.ts +1 -1
- package/dist/backend/core/handlers/coreHandler.js +10099 -9503
- package/dist/backend/core/handlers/coreHandler.mjs +6 -6
- package/dist/backend/core/handlers/executeRoute.d.mts +1 -1
- package/dist/backend/core/handlers/executeRoute.d.ts +1 -1
- package/dist/backend/core/handlers/executeRoute.mjs +4 -4
- package/dist/backend/core/handlers/handleRouteByName.js +10099 -9503
- package/dist/backend/core/handlers/handleRouteByName.mjs +6 -6
- package/dist/backend/core/handlers/index.d.mts +1 -1
- package/dist/backend/core/handlers/index.d.ts +1 -1
- package/dist/backend/core/handlers/index.js +10099 -9503
- package/dist/backend/core/handlers/index.mjs +10 -10
- package/dist/backend/core/index.d.mts +1 -1
- package/dist/backend/core/index.d.ts +1 -1
- package/dist/backend/core/index.js +10099 -9503
- package/dist/backend/core/index.mjs +9 -9
- package/dist/backend/core/routes/index.d.mts +1 -1
- package/dist/backend/core/routes/index.d.ts +1 -1
- package/dist/backend/core/routes/index.mjs +1 -1
- package/dist/backend/core/routes/routeBuilder.d.mts +1 -1
- package/dist/backend/core/routes/routeBuilder.d.ts +1 -1
- package/dist/backend/core/routes/routeConfigs.d.mts +1 -1
- package/dist/backend/core/routes/routeConfigs.d.ts +1 -1
- package/dist/backend/core/routes/routeConfigs.mjs +1 -1
- package/dist/backend/core/types/handlerTypes.d.mts +1 -1
- package/dist/backend/core/types/handlerTypes.d.ts +1 -1
- package/dist/backend/core/types/index.d.mts +1 -1
- package/dist/backend/core/types/index.d.ts +1 -1
- package/dist/backend/core/types/routeTypes.d.mts +1 -1
- package/dist/backend/core/types/routeTypes.d.ts +1 -1
- package/dist/backend/core/utils/index.mjs +3 -3
- package/dist/backend/index.d.mts +2 -2
- package/dist/backend/index.d.ts +2 -2
- package/dist/backend/index.js +10099 -9503
- package/dist/backend/index.mjs +9 -9
- package/dist/backend/{routeTypes-C3okbAP9.d.ts → routeTypes-CyIHx1ma.d.ts} +495 -0
- package/dist/backend/{routeTypes-B_erVttx.d.mts → routeTypes-DwU6yhOJ.d.mts} +495 -0
- package/dist/better-auth/{chunk-I33YDMLF.mjs → chunk-Y7P5GF2V.mjs} +10090 -9494
- package/dist/better-auth/index.js +10099 -9503
- package/dist/better-auth/index.mjs +1 -1
- package/dist/better-auth/utils/handleBetterAuthRoute.js +10099 -9503
- package/dist/better-auth/utils/handleBetterAuthRoute.mjs +1 -1
- package/dist/better-auth/utils/index.js +10099 -9503
- package/dist/better-auth/utils/index.mjs +1 -1
- package/dist/sdk/index.d.mts +605 -1
- package/dist/sdk/index.d.ts +605 -1
- package/dist/sdk/index.js +904 -175
- package/dist/sdk/index.mjs +853 -176
- package/package.json +2 -2
- package/dist/backend/{chunk-IXUCY7AU.mjs → chunk-MOHYGUMA.mjs} +3 -3
package/dist/sdk/index.js
CHANGED
|
@@ -38896,6 +38896,226 @@ function linkRevenueCatResponseFromJSON(jsonString) {
|
|
|
38896
38896
|
`Failed to parse 'LinkRevenueCatResponse' from JSON`
|
|
38897
38897
|
);
|
|
38898
38898
|
}
|
|
38899
|
+
var ListBalancesStatusRequestBody = {
|
|
38900
|
+
Active: "active",
|
|
38901
|
+
Expired: "expired"
|
|
38902
|
+
};
|
|
38903
|
+
var ListBalancesIntervalEnum = {
|
|
38904
|
+
OneOff: "one_off",
|
|
38905
|
+
Minute: "minute",
|
|
38906
|
+
Hour: "hour",
|
|
38907
|
+
Day: "day",
|
|
38908
|
+
Week: "week",
|
|
38909
|
+
Month: "month",
|
|
38910
|
+
Quarter: "quarter",
|
|
38911
|
+
SemiAnnual: "semi_annual",
|
|
38912
|
+
Year: "year"
|
|
38913
|
+
};
|
|
38914
|
+
var ListBalancesTierBehavior = {
|
|
38915
|
+
Graduated: "graduated",
|
|
38916
|
+
Volume: "volume"
|
|
38917
|
+
};
|
|
38918
|
+
var ListBalancesBillingMethod = {
|
|
38919
|
+
Prepaid: "prepaid",
|
|
38920
|
+
UsageBased: "usage_based"
|
|
38921
|
+
};
|
|
38922
|
+
var ListBalancesListStatus = {
|
|
38923
|
+
Active: "active",
|
|
38924
|
+
Expired: "expired"
|
|
38925
|
+
};
|
|
38926
|
+
var ListBalancesStatusRequestBody$outboundSchema = z35__namespace.enum(ListBalancesStatusRequestBody);
|
|
38927
|
+
var ListBalancesParams$outboundSchema = z35__namespace.pipe(
|
|
38928
|
+
z35__namespace.object({
|
|
38929
|
+
customerId: z35__namespace.optional(z35__namespace.string()),
|
|
38930
|
+
entityId: z35__namespace.optional(z35__namespace.string()),
|
|
38931
|
+
limit: z35__namespace._default(z35__namespace.int(), 50),
|
|
38932
|
+
startCursor: z35__namespace._default(z35__namespace.string(), ""),
|
|
38933
|
+
statuses: z35__namespace.optional(z35__namespace.array(ListBalancesStatusRequestBody$outboundSchema)),
|
|
38934
|
+
planId: z35__namespace.optional(z35__namespace.nullable(z35__namespace.string())),
|
|
38935
|
+
featureId: z35__namespace.optional(z35__namespace.string())
|
|
38936
|
+
}),
|
|
38937
|
+
z35__namespace.transform((v) => {
|
|
38938
|
+
return remap(v, {
|
|
38939
|
+
customerId: "customer_id",
|
|
38940
|
+
entityId: "entity_id",
|
|
38941
|
+
startCursor: "start_cursor",
|
|
38942
|
+
planId: "plan_id",
|
|
38943
|
+
featureId: "feature_id"
|
|
38944
|
+
});
|
|
38945
|
+
})
|
|
38946
|
+
);
|
|
38947
|
+
function listBalancesParamsToJSON(listBalancesParams) {
|
|
38948
|
+
return JSON.stringify(
|
|
38949
|
+
ListBalancesParams$outboundSchema.parse(listBalancesParams)
|
|
38950
|
+
);
|
|
38951
|
+
}
|
|
38952
|
+
var ListBalancesIntervalEnum$inboundSchema = inboundSchema(ListBalancesIntervalEnum);
|
|
38953
|
+
var ListBalancesIntervalUnion$inboundSchema = smartUnion([ListBalancesIntervalEnum$inboundSchema, string5()]);
|
|
38954
|
+
function listBalancesIntervalUnionFromJSON(jsonString) {
|
|
38955
|
+
return safeParse(
|
|
38956
|
+
jsonString,
|
|
38957
|
+
(x) => ListBalancesIntervalUnion$inboundSchema.parse(JSON.parse(x)),
|
|
38958
|
+
`Failed to parse 'ListBalancesIntervalUnion' from JSON`
|
|
38959
|
+
);
|
|
38960
|
+
}
|
|
38961
|
+
var ListBalancesReset$inboundSchema = z35__namespace.pipe(
|
|
38962
|
+
z35__namespace.object({
|
|
38963
|
+
interval: smartUnion([
|
|
38964
|
+
ListBalancesIntervalEnum$inboundSchema,
|
|
38965
|
+
string5()
|
|
38966
|
+
]),
|
|
38967
|
+
interval_count: optional3(number2()),
|
|
38968
|
+
resets_at: nullable(number2())
|
|
38969
|
+
}),
|
|
38970
|
+
z35__namespace.transform((v) => {
|
|
38971
|
+
return remap(v, {
|
|
38972
|
+
"interval_count": "intervalCount",
|
|
38973
|
+
"resets_at": "resetsAt"
|
|
38974
|
+
});
|
|
38975
|
+
})
|
|
38976
|
+
);
|
|
38977
|
+
function listBalancesResetFromJSON(jsonString) {
|
|
38978
|
+
return safeParse(
|
|
38979
|
+
jsonString,
|
|
38980
|
+
(x) => ListBalancesReset$inboundSchema.parse(JSON.parse(x)),
|
|
38981
|
+
`Failed to parse 'ListBalancesReset' from JSON`
|
|
38982
|
+
);
|
|
38983
|
+
}
|
|
38984
|
+
var ListBalancesTo$inboundSchema = smartUnion([number2(), string5()]);
|
|
38985
|
+
function listBalancesToFromJSON(jsonString) {
|
|
38986
|
+
return safeParse(
|
|
38987
|
+
jsonString,
|
|
38988
|
+
(x) => ListBalancesTo$inboundSchema.parse(JSON.parse(x)),
|
|
38989
|
+
`Failed to parse 'ListBalancesTo' from JSON`
|
|
38990
|
+
);
|
|
38991
|
+
}
|
|
38992
|
+
var ListBalancesTier$inboundSchema = z35__namespace.pipe(
|
|
38993
|
+
z35__namespace.object({
|
|
38994
|
+
to: smartUnion([number2(), string5()]),
|
|
38995
|
+
amount: number2(),
|
|
38996
|
+
flat_amount: optional3(number2())
|
|
38997
|
+
}),
|
|
38998
|
+
z35__namespace.transform((v) => {
|
|
38999
|
+
return remap(v, {
|
|
39000
|
+
"flat_amount": "flatAmount"
|
|
39001
|
+
});
|
|
39002
|
+
})
|
|
39003
|
+
);
|
|
39004
|
+
function listBalancesTierFromJSON(jsonString) {
|
|
39005
|
+
return safeParse(
|
|
39006
|
+
jsonString,
|
|
39007
|
+
(x) => ListBalancesTier$inboundSchema.parse(JSON.parse(x)),
|
|
39008
|
+
`Failed to parse 'ListBalancesTier' from JSON`
|
|
39009
|
+
);
|
|
39010
|
+
}
|
|
39011
|
+
var ListBalancesTierBehavior$inboundSchema = inboundSchema(ListBalancesTierBehavior);
|
|
39012
|
+
var ListBalancesBillingMethod$inboundSchema = inboundSchema(ListBalancesBillingMethod);
|
|
39013
|
+
var ListBalancesPrice$inboundSchema = z35__namespace.pipe(
|
|
39014
|
+
z35__namespace.object({
|
|
39015
|
+
amount: optional3(number2()),
|
|
39016
|
+
tiers: optional3(
|
|
39017
|
+
z35__namespace.array(z35__namespace.lazy(() => ListBalancesTier$inboundSchema))
|
|
39018
|
+
),
|
|
39019
|
+
tier_behavior: optional3(ListBalancesTierBehavior$inboundSchema),
|
|
39020
|
+
billing_units: number2(),
|
|
39021
|
+
billing_method: ListBalancesBillingMethod$inboundSchema,
|
|
39022
|
+
max_purchase: nullable(number2())
|
|
39023
|
+
}),
|
|
39024
|
+
z35__namespace.transform((v) => {
|
|
39025
|
+
return remap(v, {
|
|
39026
|
+
"tier_behavior": "tierBehavior",
|
|
39027
|
+
"billing_units": "billingUnits",
|
|
39028
|
+
"billing_method": "billingMethod",
|
|
39029
|
+
"max_purchase": "maxPurchase"
|
|
39030
|
+
});
|
|
39031
|
+
})
|
|
39032
|
+
);
|
|
39033
|
+
function listBalancesPriceFromJSON(jsonString) {
|
|
39034
|
+
return safeParse(
|
|
39035
|
+
jsonString,
|
|
39036
|
+
(x) => ListBalancesPrice$inboundSchema.parse(JSON.parse(x)),
|
|
39037
|
+
`Failed to parse 'ListBalancesPrice' from JSON`
|
|
39038
|
+
);
|
|
39039
|
+
}
|
|
39040
|
+
var ListBalancesListStatus$inboundSchema = inboundSchema(ListBalancesListStatus);
|
|
39041
|
+
var ListBalancesRollover$inboundSchema = z35__namespace.pipe(
|
|
39042
|
+
z35__namespace.object({
|
|
39043
|
+
granted: number2(),
|
|
39044
|
+
balance: number2(),
|
|
39045
|
+
expires_at: number2()
|
|
39046
|
+
}),
|
|
39047
|
+
z35__namespace.transform((v) => {
|
|
39048
|
+
return remap(v, {
|
|
39049
|
+
"expires_at": "expiresAt"
|
|
39050
|
+
});
|
|
39051
|
+
})
|
|
39052
|
+
);
|
|
39053
|
+
function listBalancesRolloverFromJSON(jsonString) {
|
|
39054
|
+
return safeParse(
|
|
39055
|
+
jsonString,
|
|
39056
|
+
(x) => ListBalancesRollover$inboundSchema.parse(JSON.parse(x)),
|
|
39057
|
+
`Failed to parse 'ListBalancesRollover' from JSON`
|
|
39058
|
+
);
|
|
39059
|
+
}
|
|
39060
|
+
var ListBalancesList$inboundSchema = z35__namespace.pipe(
|
|
39061
|
+
z35__namespace.object({
|
|
39062
|
+
id: z35__namespace._default(string5(), ""),
|
|
39063
|
+
plan_id: nullable(string5()),
|
|
39064
|
+
included_grant: number2(),
|
|
39065
|
+
prepaid_grant: number2(),
|
|
39066
|
+
remaining: number2(),
|
|
39067
|
+
usage: number2(),
|
|
39068
|
+
unlimited: boolean2(),
|
|
39069
|
+
reset: nullable(z35__namespace.lazy(() => ListBalancesReset$inboundSchema)),
|
|
39070
|
+
price: nullable(z35__namespace.lazy(() => ListBalancesPrice$inboundSchema)),
|
|
39071
|
+
expires_at: nullable(number2()),
|
|
39072
|
+
feature_id: string5(),
|
|
39073
|
+
status: ListBalancesListStatus$inboundSchema,
|
|
39074
|
+
rollovers: z35__namespace.array(z35__namespace.lazy(() => ListBalancesRollover$inboundSchema)),
|
|
39075
|
+
customer_id: string5(),
|
|
39076
|
+
entity_id: nullable(string5()),
|
|
39077
|
+
created_at: number2()
|
|
39078
|
+
}),
|
|
39079
|
+
z35__namespace.transform((v) => {
|
|
39080
|
+
return remap(v, {
|
|
39081
|
+
"plan_id": "planId",
|
|
39082
|
+
"included_grant": "includedGrant",
|
|
39083
|
+
"prepaid_grant": "prepaidGrant",
|
|
39084
|
+
"expires_at": "expiresAt",
|
|
39085
|
+
"feature_id": "featureId",
|
|
39086
|
+
"customer_id": "customerId",
|
|
39087
|
+
"entity_id": "entityId",
|
|
39088
|
+
"created_at": "createdAt"
|
|
39089
|
+
});
|
|
39090
|
+
})
|
|
39091
|
+
);
|
|
39092
|
+
function listBalancesListFromJSON(jsonString) {
|
|
39093
|
+
return safeParse(
|
|
39094
|
+
jsonString,
|
|
39095
|
+
(x) => ListBalancesList$inboundSchema.parse(JSON.parse(x)),
|
|
39096
|
+
`Failed to parse 'ListBalancesList' from JSON`
|
|
39097
|
+
);
|
|
39098
|
+
}
|
|
39099
|
+
var ListBalancesResponse$inboundSchema = z35__namespace.pipe(
|
|
39100
|
+
z35__namespace.object({
|
|
39101
|
+
list: z35__namespace.array(z35__namespace.lazy(() => ListBalancesList$inboundSchema)),
|
|
39102
|
+
has_more: boolean2(),
|
|
39103
|
+
next_cursor: nullable(string5())
|
|
39104
|
+
}),
|
|
39105
|
+
z35__namespace.transform((v) => {
|
|
39106
|
+
return remap(v, {
|
|
39107
|
+
"has_more": "hasMore",
|
|
39108
|
+
"next_cursor": "nextCursor"
|
|
39109
|
+
});
|
|
39110
|
+
})
|
|
39111
|
+
);
|
|
39112
|
+
function listBalancesResponseFromJSON(jsonString) {
|
|
39113
|
+
return safeParse(
|
|
39114
|
+
jsonString,
|
|
39115
|
+
(x) => ListBalancesResponse$inboundSchema.parse(JSON.parse(x)),
|
|
39116
|
+
`Failed to parse 'ListBalancesResponse' from JSON`
|
|
39117
|
+
);
|
|
39118
|
+
}
|
|
38899
39119
|
var ListCustomersSubscriptionStatus = {
|
|
38900
39120
|
Active: "active",
|
|
38901
39121
|
Scheduled: "scheduled"
|
|
@@ -49525,6 +49745,100 @@ function listPlansResponseFromJSON(jsonString) {
|
|
|
49525
49745
|
`Failed to parse 'ListPlansResponse' from JSON`
|
|
49526
49746
|
);
|
|
49527
49747
|
}
|
|
49748
|
+
var ListPurchasesStatusRequestBody = {
|
|
49749
|
+
Active: "active",
|
|
49750
|
+
Scheduled: "scheduled",
|
|
49751
|
+
PastDue: "past_due",
|
|
49752
|
+
Expired: "expired"
|
|
49753
|
+
};
|
|
49754
|
+
var ListPurchasesScope = {
|
|
49755
|
+
Customer: "customer",
|
|
49756
|
+
Entity: "entity"
|
|
49757
|
+
};
|
|
49758
|
+
var ListPurchasesListStatus = {
|
|
49759
|
+
Active: "active",
|
|
49760
|
+
Scheduled: "scheduled",
|
|
49761
|
+
Expired: "expired"
|
|
49762
|
+
};
|
|
49763
|
+
var ListPurchasesStatusRequestBody$outboundSchema = z35__namespace.enum(ListPurchasesStatusRequestBody);
|
|
49764
|
+
var ListPurchasesParams$outboundSchema = z35__namespace.pipe(
|
|
49765
|
+
z35__namespace.object({
|
|
49766
|
+
customerId: z35__namespace.optional(z35__namespace.string()),
|
|
49767
|
+
entityId: z35__namespace.optional(z35__namespace.string()),
|
|
49768
|
+
limit: z35__namespace._default(z35__namespace.int(), 50),
|
|
49769
|
+
startCursor: z35__namespace._default(z35__namespace.string(), ""),
|
|
49770
|
+
statuses: z35__namespace.optional(
|
|
49771
|
+
z35__namespace.array(ListPurchasesStatusRequestBody$outboundSchema)
|
|
49772
|
+
),
|
|
49773
|
+
planId: z35__namespace.optional(z35__namespace.string())
|
|
49774
|
+
}),
|
|
49775
|
+
z35__namespace.transform((v) => {
|
|
49776
|
+
return remap(v, {
|
|
49777
|
+
customerId: "customer_id",
|
|
49778
|
+
entityId: "entity_id",
|
|
49779
|
+
startCursor: "start_cursor",
|
|
49780
|
+
planId: "plan_id"
|
|
49781
|
+
});
|
|
49782
|
+
})
|
|
49783
|
+
);
|
|
49784
|
+
function listPurchasesParamsToJSON(listPurchasesParams) {
|
|
49785
|
+
return JSON.stringify(
|
|
49786
|
+
ListPurchasesParams$outboundSchema.parse(listPurchasesParams)
|
|
49787
|
+
);
|
|
49788
|
+
}
|
|
49789
|
+
var ListPurchasesScope$inboundSchema = inboundSchema(ListPurchasesScope);
|
|
49790
|
+
var ListPurchasesListStatus$inboundSchema = inboundSchema(ListPurchasesListStatus);
|
|
49791
|
+
var ListPurchasesList$inboundSchema = z35__namespace.pipe(
|
|
49792
|
+
z35__namespace.object({
|
|
49793
|
+
plan_id: string5(),
|
|
49794
|
+
expires_at: nullable(number2()),
|
|
49795
|
+
started_at: number2(),
|
|
49796
|
+
quantity: number2(),
|
|
49797
|
+
scope: optional3(ListPurchasesScope$inboundSchema),
|
|
49798
|
+
id: string5(),
|
|
49799
|
+
status: ListPurchasesListStatus$inboundSchema,
|
|
49800
|
+
customer_id: string5(),
|
|
49801
|
+
entity_id: nullable(string5()),
|
|
49802
|
+
created_at: number2()
|
|
49803
|
+
}),
|
|
49804
|
+
z35__namespace.transform((v) => {
|
|
49805
|
+
return remap(v, {
|
|
49806
|
+
"plan_id": "planId",
|
|
49807
|
+
"expires_at": "expiresAt",
|
|
49808
|
+
"started_at": "startedAt",
|
|
49809
|
+
"customer_id": "customerId",
|
|
49810
|
+
"entity_id": "entityId",
|
|
49811
|
+
"created_at": "createdAt"
|
|
49812
|
+
});
|
|
49813
|
+
})
|
|
49814
|
+
);
|
|
49815
|
+
function listPurchasesListFromJSON(jsonString) {
|
|
49816
|
+
return safeParse(
|
|
49817
|
+
jsonString,
|
|
49818
|
+
(x) => ListPurchasesList$inboundSchema.parse(JSON.parse(x)),
|
|
49819
|
+
`Failed to parse 'ListPurchasesList' from JSON`
|
|
49820
|
+
);
|
|
49821
|
+
}
|
|
49822
|
+
var ListPurchasesResponse$inboundSchema = z35__namespace.pipe(
|
|
49823
|
+
z35__namespace.object({
|
|
49824
|
+
list: z35__namespace.array(z35__namespace.lazy(() => ListPurchasesList$inboundSchema)),
|
|
49825
|
+
has_more: boolean2(),
|
|
49826
|
+
next_cursor: nullable(string5())
|
|
49827
|
+
}),
|
|
49828
|
+
z35__namespace.transform((v) => {
|
|
49829
|
+
return remap(v, {
|
|
49830
|
+
"has_more": "hasMore",
|
|
49831
|
+
"next_cursor": "nextCursor"
|
|
49832
|
+
});
|
|
49833
|
+
})
|
|
49834
|
+
);
|
|
49835
|
+
function listPurchasesResponseFromJSON(jsonString) {
|
|
49836
|
+
return safeParse(
|
|
49837
|
+
jsonString,
|
|
49838
|
+
(x) => ListPurchasesResponse$inboundSchema.parse(JSON.parse(x)),
|
|
49839
|
+
`Failed to parse 'ListPurchasesResponse' from JSON`
|
|
49840
|
+
);
|
|
49841
|
+
}
|
|
49528
49842
|
var ListReferralProgramsRedeemOn = {
|
|
49529
49843
|
CustomerCreation: "customer_creation",
|
|
49530
49844
|
Checkout: "checkout"
|
|
@@ -49804,6 +50118,114 @@ function listSandboxesResponseFromJSON(jsonString) {
|
|
|
49804
50118
|
`Failed to parse 'ListSandboxesResponse' from JSON`
|
|
49805
50119
|
);
|
|
49806
50120
|
}
|
|
50121
|
+
var ListSubscriptionsStatusRequestBody = {
|
|
50122
|
+
Active: "active",
|
|
50123
|
+
Scheduled: "scheduled",
|
|
50124
|
+
PastDue: "past_due",
|
|
50125
|
+
Expired: "expired"
|
|
50126
|
+
};
|
|
50127
|
+
var ListSubscriptionsScope = {
|
|
50128
|
+
Customer: "customer",
|
|
50129
|
+
Entity: "entity"
|
|
50130
|
+
};
|
|
50131
|
+
var ListSubscriptionsListStatus = {
|
|
50132
|
+
Active: "active",
|
|
50133
|
+
Scheduled: "scheduled",
|
|
50134
|
+
Expired: "expired"
|
|
50135
|
+
};
|
|
50136
|
+
var ListSubscriptionsStatusRequestBody$outboundSchema = z35__namespace.enum(ListSubscriptionsStatusRequestBody);
|
|
50137
|
+
var ListSubscriptionsParams$outboundSchema = z35__namespace.pipe(
|
|
50138
|
+
z35__namespace.object({
|
|
50139
|
+
customerId: z35__namespace.optional(z35__namespace.string()),
|
|
50140
|
+
entityId: z35__namespace.optional(z35__namespace.string()),
|
|
50141
|
+
limit: z35__namespace._default(z35__namespace.int(), 50),
|
|
50142
|
+
startCursor: z35__namespace._default(z35__namespace.string(), ""),
|
|
50143
|
+
statuses: z35__namespace.optional(
|
|
50144
|
+
z35__namespace.array(ListSubscriptionsStatusRequestBody$outboundSchema)
|
|
50145
|
+
),
|
|
50146
|
+
planId: z35__namespace.optional(z35__namespace.string())
|
|
50147
|
+
}),
|
|
50148
|
+
z35__namespace.transform((v) => {
|
|
50149
|
+
return remap(v, {
|
|
50150
|
+
customerId: "customer_id",
|
|
50151
|
+
entityId: "entity_id",
|
|
50152
|
+
startCursor: "start_cursor",
|
|
50153
|
+
planId: "plan_id"
|
|
50154
|
+
});
|
|
50155
|
+
})
|
|
50156
|
+
);
|
|
50157
|
+
function listSubscriptionsParamsToJSON(listSubscriptionsParams) {
|
|
50158
|
+
return JSON.stringify(
|
|
50159
|
+
ListSubscriptionsParams$outboundSchema.parse(listSubscriptionsParams)
|
|
50160
|
+
);
|
|
50161
|
+
}
|
|
50162
|
+
var ListSubscriptionsScope$inboundSchema = inboundSchema(ListSubscriptionsScope);
|
|
50163
|
+
var ListSubscriptionsListStatus$inboundSchema = inboundSchema(ListSubscriptionsListStatus);
|
|
50164
|
+
var ListSubscriptionsList$inboundSchema = z35__namespace.pipe(
|
|
50165
|
+
z35__namespace.object({
|
|
50166
|
+
id: string5(),
|
|
50167
|
+
plan_id: string5(),
|
|
50168
|
+
auto_enable: boolean2(),
|
|
50169
|
+
add_on: boolean2(),
|
|
50170
|
+
past_due: boolean2(),
|
|
50171
|
+
canceled_at: nullable(number2()),
|
|
50172
|
+
expires_at: nullable(number2()),
|
|
50173
|
+
trial_ends_at: nullable(number2()),
|
|
50174
|
+
started_at: number2(),
|
|
50175
|
+
current_period_start: nullable(number2()),
|
|
50176
|
+
current_period_end: nullable(number2()),
|
|
50177
|
+
quantity: number2(),
|
|
50178
|
+
scope: optional3(ListSubscriptionsScope$inboundSchema),
|
|
50179
|
+
status: ListSubscriptionsListStatus$inboundSchema,
|
|
50180
|
+
customer_id: string5(),
|
|
50181
|
+
entity_id: nullable(string5()),
|
|
50182
|
+
created_at: number2()
|
|
50183
|
+
}),
|
|
50184
|
+
z35__namespace.transform((v) => {
|
|
50185
|
+
return remap(v, {
|
|
50186
|
+
"plan_id": "planId",
|
|
50187
|
+
"auto_enable": "autoEnable",
|
|
50188
|
+
"add_on": "addOn",
|
|
50189
|
+
"past_due": "pastDue",
|
|
50190
|
+
"canceled_at": "canceledAt",
|
|
50191
|
+
"expires_at": "expiresAt",
|
|
50192
|
+
"trial_ends_at": "trialEndsAt",
|
|
50193
|
+
"started_at": "startedAt",
|
|
50194
|
+
"current_period_start": "currentPeriodStart",
|
|
50195
|
+
"current_period_end": "currentPeriodEnd",
|
|
50196
|
+
"customer_id": "customerId",
|
|
50197
|
+
"entity_id": "entityId",
|
|
50198
|
+
"created_at": "createdAt"
|
|
50199
|
+
});
|
|
50200
|
+
})
|
|
50201
|
+
);
|
|
50202
|
+
function listSubscriptionsListFromJSON(jsonString) {
|
|
50203
|
+
return safeParse(
|
|
50204
|
+
jsonString,
|
|
50205
|
+
(x) => ListSubscriptionsList$inboundSchema.parse(JSON.parse(x)),
|
|
50206
|
+
`Failed to parse 'ListSubscriptionsList' from JSON`
|
|
50207
|
+
);
|
|
50208
|
+
}
|
|
50209
|
+
var ListSubscriptionsResponse$inboundSchema = z35__namespace.pipe(
|
|
50210
|
+
z35__namespace.object({
|
|
50211
|
+
list: z35__namespace.array(z35__namespace.lazy(() => ListSubscriptionsList$inboundSchema)),
|
|
50212
|
+
has_more: boolean2(),
|
|
50213
|
+
next_cursor: nullable(string5())
|
|
50214
|
+
}),
|
|
50215
|
+
z35__namespace.transform((v) => {
|
|
50216
|
+
return remap(v, {
|
|
50217
|
+
"has_more": "hasMore",
|
|
50218
|
+
"next_cursor": "nextCursor"
|
|
50219
|
+
});
|
|
50220
|
+
})
|
|
50221
|
+
);
|
|
50222
|
+
function listSubscriptionsResponseFromJSON(jsonString) {
|
|
50223
|
+
return safeParse(
|
|
50224
|
+
jsonString,
|
|
50225
|
+
(x) => ListSubscriptionsResponse$inboundSchema.parse(JSON.parse(x)),
|
|
50226
|
+
`Failed to parse 'ListSubscriptionsResponse' from JSON`
|
|
50227
|
+
);
|
|
50228
|
+
}
|
|
49807
50229
|
var ListWebhooksParams$outboundSchema = z35__namespace.object({});
|
|
49808
50230
|
function listWebhooksParamsToJSON(listWebhooksParams) {
|
|
49809
50231
|
return JSON.stringify(
|
|
@@ -79926,7 +80348,7 @@ async function $do7(client, request, options) {
|
|
|
79926
80348
|
}
|
|
79927
80349
|
return [result, { status: "complete", request: req, response }];
|
|
79928
80350
|
}
|
|
79929
|
-
function
|
|
80351
|
+
function balancesList(client, request, options) {
|
|
79930
80352
|
return new APIPromise($do8(
|
|
79931
80353
|
client,
|
|
79932
80354
|
request,
|
|
@@ -79934,6 +80356,81 @@ function balancesUpdate(client, request, options) {
|
|
|
79934
80356
|
));
|
|
79935
80357
|
}
|
|
79936
80358
|
async function $do8(client, request, options) {
|
|
80359
|
+
const parsed = safeParse(
|
|
80360
|
+
request,
|
|
80361
|
+
(value) => z35__namespace.parse(ListBalancesParams$outboundSchema, value),
|
|
80362
|
+
"Input validation failed"
|
|
80363
|
+
);
|
|
80364
|
+
if (!parsed.ok) {
|
|
80365
|
+
return [parsed, { status: "invalid" }];
|
|
80366
|
+
}
|
|
80367
|
+
const payload = parsed.value;
|
|
80368
|
+
const body = encodeJSON("body", payload, { explode: true });
|
|
80369
|
+
const path = pathToFunc("/v1/balances.list")();
|
|
80370
|
+
const headers = new Headers(compactMap({
|
|
80371
|
+
"Content-Type": "application/json",
|
|
80372
|
+
Accept: "application/json",
|
|
80373
|
+
"x-api-version": encodeSimple(
|
|
80374
|
+
"x-api-version",
|
|
80375
|
+
client._options.xApiVersion,
|
|
80376
|
+
{ explode: false, charEncoding: "none" }
|
|
80377
|
+
)
|
|
80378
|
+
}));
|
|
80379
|
+
const secConfig = await extractSecurity(client._options.secretKey);
|
|
80380
|
+
const securityInput = secConfig == null ? {} : { secretKey: secConfig };
|
|
80381
|
+
const requestSecurity = resolveGlobalSecurity(securityInput);
|
|
80382
|
+
const context = {
|
|
80383
|
+
options: client._options,
|
|
80384
|
+
baseURL: options?.serverURL ?? client._baseURL ?? "",
|
|
80385
|
+
operationID: "listBalances",
|
|
80386
|
+
oAuth2Scopes: null,
|
|
80387
|
+
resolvedSecurity: requestSecurity,
|
|
80388
|
+
securitySource: client._options.secretKey,
|
|
80389
|
+
retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
|
|
80390
|
+
retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
|
|
80391
|
+
};
|
|
80392
|
+
const requestRes = client._createRequest(context, {
|
|
80393
|
+
security: requestSecurity,
|
|
80394
|
+
method: "POST",
|
|
80395
|
+
baseURL: options?.serverURL,
|
|
80396
|
+
path,
|
|
80397
|
+
headers,
|
|
80398
|
+
body,
|
|
80399
|
+
userAgent: client._options.userAgent,
|
|
80400
|
+
timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
|
|
80401
|
+
}, options);
|
|
80402
|
+
if (!requestRes.ok) {
|
|
80403
|
+
return [requestRes, { status: "invalid" }];
|
|
80404
|
+
}
|
|
80405
|
+
const req = requestRes.value;
|
|
80406
|
+
const doResult = await client._do(req, {
|
|
80407
|
+
context,
|
|
80408
|
+
isErrorStatusCode: (statusCode) => matchStatusCode({ status: statusCode }, ["4XX", "5XX"]),
|
|
80409
|
+
retryConfig: context.retryConfig,
|
|
80410
|
+
retryCodes: context.retryCodes
|
|
80411
|
+
});
|
|
80412
|
+
if (!doResult.ok) {
|
|
80413
|
+
return [doResult, { status: "request-error", request: req }];
|
|
80414
|
+
}
|
|
80415
|
+
const response = doResult.value;
|
|
80416
|
+
const [result] = await match(
|
|
80417
|
+
json(200, ListBalancesResponse$inboundSchema),
|
|
80418
|
+
fail("4XX"),
|
|
80419
|
+
fail("5XX")
|
|
80420
|
+
)(response, req);
|
|
80421
|
+
if (!result.ok) {
|
|
80422
|
+
return [result, { status: "complete", request: req, response }];
|
|
80423
|
+
}
|
|
80424
|
+
return [result, { status: "complete", request: req, response }];
|
|
80425
|
+
}
|
|
80426
|
+
function balancesUpdate(client, request, options) {
|
|
80427
|
+
return new APIPromise($do9(
|
|
80428
|
+
client,
|
|
80429
|
+
request,
|
|
80430
|
+
options
|
|
80431
|
+
));
|
|
80432
|
+
}
|
|
80433
|
+
async function $do9(client, request, options) {
|
|
79937
80434
|
const parsed = safeParse(
|
|
79938
80435
|
request,
|
|
79939
80436
|
(value) => z35__namespace.parse(UpdateBalanceParams$outboundSchema, value),
|
|
@@ -80014,6 +80511,16 @@ var Balances = class extends ClientSDK {
|
|
|
80014
80511
|
options
|
|
80015
80512
|
));
|
|
80016
80513
|
}
|
|
80514
|
+
/**
|
|
80515
|
+
* Lists individual balances (one row per grant) across customers, live or expired: plan balances, standalone balances, top-ups, and pooled balances. Pages may hold fewer than `limit` rows while `has_more` is true.
|
|
80516
|
+
*/
|
|
80517
|
+
async list(request, options) {
|
|
80518
|
+
return unwrapAsync(balancesList(
|
|
80519
|
+
this,
|
|
80520
|
+
request,
|
|
80521
|
+
options
|
|
80522
|
+
));
|
|
80523
|
+
}
|
|
80017
80524
|
/**
|
|
80018
80525
|
* Update a customer balance.
|
|
80019
80526
|
*/
|
|
@@ -80046,13 +80553,13 @@ var Balances = class extends ClientSDK {
|
|
|
80046
80553
|
}
|
|
80047
80554
|
};
|
|
80048
80555
|
function billingAttach(client, request, options) {
|
|
80049
|
-
return new APIPromise($
|
|
80556
|
+
return new APIPromise($do10(
|
|
80050
80557
|
client,
|
|
80051
80558
|
request,
|
|
80052
80559
|
options
|
|
80053
80560
|
));
|
|
80054
80561
|
}
|
|
80055
|
-
async function $
|
|
80562
|
+
async function $do10(client, request, options) {
|
|
80056
80563
|
const parsed = safeParse(
|
|
80057
80564
|
request,
|
|
80058
80565
|
(value) => z35__namespace.parse(AttachParams$outboundSchema, value),
|
|
@@ -80121,13 +80628,13 @@ async function $do9(client, request, options) {
|
|
|
80121
80628
|
return [result, { status: "complete", request: req, response }];
|
|
80122
80629
|
}
|
|
80123
80630
|
function billingCreateSchedule(client, request, options) {
|
|
80124
|
-
return new APIPromise($
|
|
80631
|
+
return new APIPromise($do11(
|
|
80125
80632
|
client,
|
|
80126
80633
|
request,
|
|
80127
80634
|
options
|
|
80128
80635
|
));
|
|
80129
80636
|
}
|
|
80130
|
-
async function $
|
|
80637
|
+
async function $do11(client, request, options) {
|
|
80131
80638
|
const parsed = safeParse(
|
|
80132
80639
|
request,
|
|
80133
80640
|
(value) => z35__namespace.parse(CreateScheduleParams$outboundSchema, value),
|
|
@@ -80196,13 +80703,13 @@ async function $do10(client, request, options) {
|
|
|
80196
80703
|
return [result, { status: "complete", request: req, response }];
|
|
80197
80704
|
}
|
|
80198
80705
|
function billingImport(client, request, options) {
|
|
80199
|
-
return new APIPromise($
|
|
80706
|
+
return new APIPromise($do12(
|
|
80200
80707
|
client,
|
|
80201
80708
|
request,
|
|
80202
80709
|
options
|
|
80203
80710
|
));
|
|
80204
80711
|
}
|
|
80205
|
-
async function $
|
|
80712
|
+
async function $do12(client, request, options) {
|
|
80206
80713
|
const parsed = safeParse(
|
|
80207
80714
|
request,
|
|
80208
80715
|
(value) => z35__namespace.parse(DfuFlashParams$outboundSchema, value),
|
|
@@ -80271,13 +80778,13 @@ async function $do11(client, request, options) {
|
|
|
80271
80778
|
return [result, { status: "complete", request: req, response }];
|
|
80272
80779
|
}
|
|
80273
80780
|
function billingMultiAttach(client, request, options) {
|
|
80274
|
-
return new APIPromise($
|
|
80781
|
+
return new APIPromise($do13(
|
|
80275
80782
|
client,
|
|
80276
80783
|
request,
|
|
80277
80784
|
options
|
|
80278
80785
|
));
|
|
80279
80786
|
}
|
|
80280
|
-
async function $
|
|
80787
|
+
async function $do13(client, request, options) {
|
|
80281
80788
|
const parsed = safeParse(
|
|
80282
80789
|
request,
|
|
80283
80790
|
(value) => z35__namespace.parse(MultiAttachParams$outboundSchema, value),
|
|
@@ -80346,13 +80853,13 @@ async function $do12(client, request, options) {
|
|
|
80346
80853
|
return [result, { status: "complete", request: req, response }];
|
|
80347
80854
|
}
|
|
80348
80855
|
function billingMultiUpdate(client, request, options) {
|
|
80349
|
-
return new APIPromise($
|
|
80856
|
+
return new APIPromise($do14(
|
|
80350
80857
|
client,
|
|
80351
80858
|
request,
|
|
80352
80859
|
options
|
|
80353
80860
|
));
|
|
80354
80861
|
}
|
|
80355
|
-
async function $
|
|
80862
|
+
async function $do14(client, request, options) {
|
|
80356
80863
|
const parsed = safeParse(
|
|
80357
80864
|
request,
|
|
80358
80865
|
(value) => z35__namespace.parse(MultiUpdateParams$outboundSchema, value),
|
|
@@ -80421,13 +80928,13 @@ async function $do13(client, request, options) {
|
|
|
80421
80928
|
return [result, { status: "complete", request: req, response }];
|
|
80422
80929
|
}
|
|
80423
80930
|
function billingOpenCustomerPortal(client, request, options) {
|
|
80424
|
-
return new APIPromise($
|
|
80931
|
+
return new APIPromise($do15(
|
|
80425
80932
|
client,
|
|
80426
80933
|
request,
|
|
80427
80934
|
options
|
|
80428
80935
|
));
|
|
80429
80936
|
}
|
|
80430
|
-
async function $
|
|
80937
|
+
async function $do15(client, request, options) {
|
|
80431
80938
|
const parsed = safeParse(
|
|
80432
80939
|
request,
|
|
80433
80940
|
(value) => z35__namespace.parse(OpenCustomerPortalParams$outboundSchema, value),
|
|
@@ -80496,13 +81003,13 @@ async function $do14(client, request, options) {
|
|
|
80496
81003
|
return [result, { status: "complete", request: req, response }];
|
|
80497
81004
|
}
|
|
80498
81005
|
function billingPreviewAttach(client, request, options) {
|
|
80499
|
-
return new APIPromise($
|
|
81006
|
+
return new APIPromise($do16(
|
|
80500
81007
|
client,
|
|
80501
81008
|
request,
|
|
80502
81009
|
options
|
|
80503
81010
|
));
|
|
80504
81011
|
}
|
|
80505
|
-
async function $
|
|
81012
|
+
async function $do16(client, request, options) {
|
|
80506
81013
|
const parsed = safeParse(
|
|
80507
81014
|
request,
|
|
80508
81015
|
(value) => z35__namespace.parse(PreviewAttachParams$outboundSchema, value),
|
|
@@ -80571,13 +81078,13 @@ async function $do15(client, request, options) {
|
|
|
80571
81078
|
return [result, { status: "complete", request: req, response }];
|
|
80572
81079
|
}
|
|
80573
81080
|
function billingPreviewMultiAttach(client, request, options) {
|
|
80574
|
-
return new APIPromise($
|
|
81081
|
+
return new APIPromise($do17(
|
|
80575
81082
|
client,
|
|
80576
81083
|
request,
|
|
80577
81084
|
options
|
|
80578
81085
|
));
|
|
80579
81086
|
}
|
|
80580
|
-
async function $
|
|
81087
|
+
async function $do17(client, request, options) {
|
|
80581
81088
|
const parsed = safeParse(
|
|
80582
81089
|
request,
|
|
80583
81090
|
(value) => z35__namespace.parse(PreviewMultiAttachParams$outboundSchema, value),
|
|
@@ -80646,13 +81153,13 @@ async function $do16(client, request, options) {
|
|
|
80646
81153
|
return [result, { status: "complete", request: req, response }];
|
|
80647
81154
|
}
|
|
80648
81155
|
function billingPreviewMultiUpdate(client, request, options) {
|
|
80649
|
-
return new APIPromise($
|
|
81156
|
+
return new APIPromise($do18(
|
|
80650
81157
|
client,
|
|
80651
81158
|
request,
|
|
80652
81159
|
options
|
|
80653
81160
|
));
|
|
80654
81161
|
}
|
|
80655
|
-
async function $
|
|
81162
|
+
async function $do18(client, request, options) {
|
|
80656
81163
|
const parsed = safeParse(
|
|
80657
81164
|
request,
|
|
80658
81165
|
(value) => z35__namespace.parse(PreviewMultiUpdateParams$outboundSchema, value),
|
|
@@ -80721,13 +81228,13 @@ async function $do17(client, request, options) {
|
|
|
80721
81228
|
return [result, { status: "complete", request: req, response }];
|
|
80722
81229
|
}
|
|
80723
81230
|
function billingPreviewUpdate(client, request, options) {
|
|
80724
|
-
return new APIPromise($
|
|
81231
|
+
return new APIPromise($do19(
|
|
80725
81232
|
client,
|
|
80726
81233
|
request,
|
|
80727
81234
|
options
|
|
80728
81235
|
));
|
|
80729
81236
|
}
|
|
80730
|
-
async function $
|
|
81237
|
+
async function $do19(client, request, options) {
|
|
80731
81238
|
const parsed = safeParse(
|
|
80732
81239
|
request,
|
|
80733
81240
|
(value) => z35__namespace.parse(PreviewUpdateParams$outboundSchema, value),
|
|
@@ -80796,13 +81303,13 @@ async function $do18(client, request, options) {
|
|
|
80796
81303
|
return [result, { status: "complete", request: req, response }];
|
|
80797
81304
|
}
|
|
80798
81305
|
function billingSetupPayment(client, request, options) {
|
|
80799
|
-
return new APIPromise($
|
|
81306
|
+
return new APIPromise($do20(
|
|
80800
81307
|
client,
|
|
80801
81308
|
request,
|
|
80802
81309
|
options
|
|
80803
81310
|
));
|
|
80804
81311
|
}
|
|
80805
|
-
async function $
|
|
81312
|
+
async function $do20(client, request, options) {
|
|
80806
81313
|
const parsed = safeParse(
|
|
80807
81314
|
request,
|
|
80808
81315
|
(value) => z35__namespace.parse(SetupPaymentParams$outboundSchema, value),
|
|
@@ -80871,13 +81378,13 @@ async function $do19(client, request, options) {
|
|
|
80871
81378
|
return [result, { status: "complete", request: req, response }];
|
|
80872
81379
|
}
|
|
80873
81380
|
function billingUpdate(client, request, options) {
|
|
80874
|
-
return new APIPromise($
|
|
81381
|
+
return new APIPromise($do21(
|
|
80875
81382
|
client,
|
|
80876
81383
|
request,
|
|
80877
81384
|
options
|
|
80878
81385
|
));
|
|
80879
81386
|
}
|
|
80880
|
-
async function $
|
|
81387
|
+
async function $do21(client, request, options) {
|
|
80881
81388
|
const parsed = safeParse(
|
|
80882
81389
|
request,
|
|
80883
81390
|
(value) => z35__namespace.parse(UpdateSubscriptionParams$outboundSchema, value),
|
|
@@ -80946,13 +81453,13 @@ async function $do20(client, request, options) {
|
|
|
80946
81453
|
return [result, { status: "complete", request: req, response }];
|
|
80947
81454
|
}
|
|
80948
81455
|
function billingVerify(client, request, options) {
|
|
80949
|
-
return new APIPromise($
|
|
81456
|
+
return new APIPromise($do22(
|
|
80950
81457
|
client,
|
|
80951
81458
|
request,
|
|
80952
81459
|
options
|
|
80953
81460
|
));
|
|
80954
81461
|
}
|
|
80955
|
-
async function $
|
|
81462
|
+
async function $do22(client, request, options) {
|
|
80956
81463
|
const parsed = safeParse(
|
|
80957
81464
|
request,
|
|
80958
81465
|
(value) => z35__namespace.parse(VerifyParams$outboundSchema, value),
|
|
@@ -81483,13 +81990,13 @@ var Billing = class extends ClientSDK {
|
|
|
81483
81990
|
}
|
|
81484
81991
|
};
|
|
81485
81992
|
function customersAdvanceTestClock(client, request, options) {
|
|
81486
|
-
return new APIPromise($
|
|
81993
|
+
return new APIPromise($do23(
|
|
81487
81994
|
client,
|
|
81488
81995
|
request,
|
|
81489
81996
|
options
|
|
81490
81997
|
));
|
|
81491
81998
|
}
|
|
81492
|
-
async function $
|
|
81999
|
+
async function $do23(client, request, options) {
|
|
81493
82000
|
const parsed = safeParse(
|
|
81494
82001
|
request,
|
|
81495
82002
|
(value) => z35__namespace.parse(AdvanceTestClockParams$outboundSchema, value),
|
|
@@ -81548,7 +82055,157 @@ async function $do22(client, request, options) {
|
|
|
81548
82055
|
}
|
|
81549
82056
|
const response = doResult.value;
|
|
81550
82057
|
const [result] = await match(
|
|
81551
|
-
json(200, AdvanceTestClockResponse$inboundSchema),
|
|
82058
|
+
json(200, AdvanceTestClockResponse$inboundSchema),
|
|
82059
|
+
fail("4XX"),
|
|
82060
|
+
fail("5XX")
|
|
82061
|
+
)(response, req);
|
|
82062
|
+
if (!result.ok) {
|
|
82063
|
+
return [result, { status: "complete", request: req, response }];
|
|
82064
|
+
}
|
|
82065
|
+
return [result, { status: "complete", request: req, response }];
|
|
82066
|
+
}
|
|
82067
|
+
function customersDelete(client, request, options) {
|
|
82068
|
+
return new APIPromise($do24(
|
|
82069
|
+
client,
|
|
82070
|
+
request,
|
|
82071
|
+
options
|
|
82072
|
+
));
|
|
82073
|
+
}
|
|
82074
|
+
async function $do24(client, request, options) {
|
|
82075
|
+
const parsed = safeParse(
|
|
82076
|
+
request,
|
|
82077
|
+
(value) => z35__namespace.parse(DeleteCustomerParams$outboundSchema, value),
|
|
82078
|
+
"Input validation failed"
|
|
82079
|
+
);
|
|
82080
|
+
if (!parsed.ok) {
|
|
82081
|
+
return [parsed, { status: "invalid" }];
|
|
82082
|
+
}
|
|
82083
|
+
const payload = parsed.value;
|
|
82084
|
+
const body = encodeJSON("body", payload, { explode: true });
|
|
82085
|
+
const path = pathToFunc("/v1/customers.delete")();
|
|
82086
|
+
const headers = new Headers(compactMap({
|
|
82087
|
+
"Content-Type": "application/json",
|
|
82088
|
+
Accept: "application/json",
|
|
82089
|
+
"x-api-version": encodeSimple(
|
|
82090
|
+
"x-api-version",
|
|
82091
|
+
client._options.xApiVersion,
|
|
82092
|
+
{ explode: false, charEncoding: "none" }
|
|
82093
|
+
)
|
|
82094
|
+
}));
|
|
82095
|
+
const secConfig = await extractSecurity(client._options.secretKey);
|
|
82096
|
+
const securityInput = secConfig == null ? {} : { secretKey: secConfig };
|
|
82097
|
+
const requestSecurity = resolveGlobalSecurity(securityInput);
|
|
82098
|
+
const context = {
|
|
82099
|
+
options: client._options,
|
|
82100
|
+
baseURL: options?.serverURL ?? client._baseURL ?? "",
|
|
82101
|
+
operationID: "deleteCustomer",
|
|
82102
|
+
oAuth2Scopes: null,
|
|
82103
|
+
resolvedSecurity: requestSecurity,
|
|
82104
|
+
securitySource: client._options.secretKey,
|
|
82105
|
+
retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
|
|
82106
|
+
retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
|
|
82107
|
+
};
|
|
82108
|
+
const requestRes = client._createRequest(context, {
|
|
82109
|
+
security: requestSecurity,
|
|
82110
|
+
method: "POST",
|
|
82111
|
+
baseURL: options?.serverURL,
|
|
82112
|
+
path,
|
|
82113
|
+
headers,
|
|
82114
|
+
body,
|
|
82115
|
+
userAgent: client._options.userAgent,
|
|
82116
|
+
timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
|
|
82117
|
+
}, options);
|
|
82118
|
+
if (!requestRes.ok) {
|
|
82119
|
+
return [requestRes, { status: "invalid" }];
|
|
82120
|
+
}
|
|
82121
|
+
const req = requestRes.value;
|
|
82122
|
+
const doResult = await client._do(req, {
|
|
82123
|
+
context,
|
|
82124
|
+
isErrorStatusCode: (statusCode) => matchStatusCode({ status: statusCode }, ["4XX", "5XX"]),
|
|
82125
|
+
retryConfig: context.retryConfig,
|
|
82126
|
+
retryCodes: context.retryCodes
|
|
82127
|
+
});
|
|
82128
|
+
if (!doResult.ok) {
|
|
82129
|
+
return [doResult, { status: "request-error", request: req }];
|
|
82130
|
+
}
|
|
82131
|
+
const response = doResult.value;
|
|
82132
|
+
const [result] = await match(
|
|
82133
|
+
json(200, DeleteCustomerResponse$inboundSchema),
|
|
82134
|
+
fail("4XX"),
|
|
82135
|
+
fail("5XX")
|
|
82136
|
+
)(response, req);
|
|
82137
|
+
if (!result.ok) {
|
|
82138
|
+
return [result, { status: "complete", request: req, response }];
|
|
82139
|
+
}
|
|
82140
|
+
return [result, { status: "complete", request: req, response }];
|
|
82141
|
+
}
|
|
82142
|
+
function customersGetOrCreate(client, request, options) {
|
|
82143
|
+
return new APIPromise($do25(
|
|
82144
|
+
client,
|
|
82145
|
+
request,
|
|
82146
|
+
options
|
|
82147
|
+
));
|
|
82148
|
+
}
|
|
82149
|
+
async function $do25(client, request, options) {
|
|
82150
|
+
const parsed = safeParse(
|
|
82151
|
+
request,
|
|
82152
|
+
(value) => z35__namespace.parse(GetOrCreateCustomerParams$outboundSchema, value),
|
|
82153
|
+
"Input validation failed"
|
|
82154
|
+
);
|
|
82155
|
+
if (!parsed.ok) {
|
|
82156
|
+
return [parsed, { status: "invalid" }];
|
|
82157
|
+
}
|
|
82158
|
+
const payload = parsed.value;
|
|
82159
|
+
const body = encodeJSON("body", payload, { explode: true });
|
|
82160
|
+
const path = pathToFunc("/v1/customers.get_or_create")();
|
|
82161
|
+
const headers = new Headers(compactMap({
|
|
82162
|
+
"Content-Type": "application/json",
|
|
82163
|
+
Accept: "application/json",
|
|
82164
|
+
"x-api-version": encodeSimple(
|
|
82165
|
+
"x-api-version",
|
|
82166
|
+
client._options.xApiVersion,
|
|
82167
|
+
{ explode: false, charEncoding: "none" }
|
|
82168
|
+
)
|
|
82169
|
+
}));
|
|
82170
|
+
const secConfig = await extractSecurity(client._options.secretKey);
|
|
82171
|
+
const securityInput = secConfig == null ? {} : { secretKey: secConfig };
|
|
82172
|
+
const requestSecurity = resolveGlobalSecurity(securityInput);
|
|
82173
|
+
const context = {
|
|
82174
|
+
options: client._options,
|
|
82175
|
+
baseURL: options?.serverURL ?? client._baseURL ?? "",
|
|
82176
|
+
operationID: "getOrCreateCustomer",
|
|
82177
|
+
oAuth2Scopes: null,
|
|
82178
|
+
resolvedSecurity: requestSecurity,
|
|
82179
|
+
securitySource: client._options.secretKey,
|
|
82180
|
+
retryConfig: options?.retries || client._options.retryConfig || { strategy: "none" },
|
|
82181
|
+
retryCodes: options?.retryCodes || ["429", "500", "502", "503", "504"]
|
|
82182
|
+
};
|
|
82183
|
+
const requestRes = client._createRequest(context, {
|
|
82184
|
+
security: requestSecurity,
|
|
82185
|
+
method: "POST",
|
|
82186
|
+
baseURL: options?.serverURL,
|
|
82187
|
+
path,
|
|
82188
|
+
headers,
|
|
82189
|
+
body,
|
|
82190
|
+
userAgent: client._options.userAgent,
|
|
82191
|
+
timeoutMs: options?.timeoutMs || client._options.timeoutMs || -1
|
|
82192
|
+
}, options);
|
|
82193
|
+
if (!requestRes.ok) {
|
|
82194
|
+
return [requestRes, { status: "invalid" }];
|
|
82195
|
+
}
|
|
82196
|
+
const req = requestRes.value;
|
|
82197
|
+
const doResult = await client._do(req, {
|
|
82198
|
+
context,
|
|
82199
|
+
isErrorStatusCode: (statusCode) => matchStatusCode({ status: statusCode }, ["4XX", "5XX"]),
|
|
82200
|
+
retryConfig: context.retryConfig,
|
|
82201
|
+
retryCodes: context.retryCodes
|
|
82202
|
+
});
|
|
82203
|
+
if (!doResult.ok) {
|
|
82204
|
+
return [doResult, { status: "request-error", request: req }];
|
|
82205
|
+
}
|
|
82206
|
+
const response = doResult.value;
|
|
82207
|
+
const [result] = await match(
|
|
82208
|
+
json(200, Customer$inboundSchema),
|
|
81552
82209
|
fail("4XX"),
|
|
81553
82210
|
fail("5XX")
|
|
81554
82211
|
)(response, req);
|
|
@@ -81557,17 +82214,17 @@ async function $do22(client, request, options) {
|
|
|
81557
82214
|
}
|
|
81558
82215
|
return [result, { status: "complete", request: req, response }];
|
|
81559
82216
|
}
|
|
81560
|
-
function
|
|
81561
|
-
return new APIPromise($
|
|
82217
|
+
function customersGet(client, request, options) {
|
|
82218
|
+
return new APIPromise($do26(
|
|
81562
82219
|
client,
|
|
81563
82220
|
request,
|
|
81564
82221
|
options
|
|
81565
82222
|
));
|
|
81566
82223
|
}
|
|
81567
|
-
async function $
|
|
82224
|
+
async function $do26(client, request, options) {
|
|
81568
82225
|
const parsed = safeParse(
|
|
81569
82226
|
request,
|
|
81570
|
-
(value) => z35__namespace.parse(
|
|
82227
|
+
(value) => z35__namespace.parse(GetCustomerParams$outboundSchema, value),
|
|
81571
82228
|
"Input validation failed"
|
|
81572
82229
|
);
|
|
81573
82230
|
if (!parsed.ok) {
|
|
@@ -81575,7 +82232,7 @@ async function $do23(client, request, options) {
|
|
|
81575
82232
|
}
|
|
81576
82233
|
const payload = parsed.value;
|
|
81577
82234
|
const body = encodeJSON("body", payload, { explode: true });
|
|
81578
|
-
const path = pathToFunc("/v1/customers.
|
|
82235
|
+
const path = pathToFunc("/v1/customers.get")();
|
|
81579
82236
|
const headers = new Headers(compactMap({
|
|
81580
82237
|
"Content-Type": "application/json",
|
|
81581
82238
|
Accept: "application/json",
|
|
@@ -81591,7 +82248,7 @@ async function $do23(client, request, options) {
|
|
|
81591
82248
|
const context = {
|
|
81592
82249
|
options: client._options,
|
|
81593
82250
|
baseURL: options?.serverURL ?? client._baseURL ?? "",
|
|
81594
|
-
operationID: "
|
|
82251
|
+
operationID: "getCustomer",
|
|
81595
82252
|
oAuth2Scopes: null,
|
|
81596
82253
|
resolvedSecurity: requestSecurity,
|
|
81597
82254
|
securitySource: client._options.secretKey,
|
|
@@ -81623,7 +82280,7 @@ async function $do23(client, request, options) {
|
|
|
81623
82280
|
}
|
|
81624
82281
|
const response = doResult.value;
|
|
81625
82282
|
const [result] = await match(
|
|
81626
|
-
json(200,
|
|
82283
|
+
json(200, GetCustomerResponse$inboundSchema),
|
|
81627
82284
|
fail("4XX"),
|
|
81628
82285
|
fail("5XX")
|
|
81629
82286
|
)(response, req);
|
|
@@ -81632,17 +82289,17 @@ async function $do23(client, request, options) {
|
|
|
81632
82289
|
}
|
|
81633
82290
|
return [result, { status: "complete", request: req, response }];
|
|
81634
82291
|
}
|
|
81635
|
-
function
|
|
81636
|
-
return new APIPromise($
|
|
82292
|
+
function customersListPurchases(client, request, options) {
|
|
82293
|
+
return new APIPromise($do27(
|
|
81637
82294
|
client,
|
|
81638
82295
|
request,
|
|
81639
82296
|
options
|
|
81640
82297
|
));
|
|
81641
82298
|
}
|
|
81642
|
-
async function $
|
|
82299
|
+
async function $do27(client, request, options) {
|
|
81643
82300
|
const parsed = safeParse(
|
|
81644
82301
|
request,
|
|
81645
|
-
(value) => z35__namespace.parse(
|
|
82302
|
+
(value) => z35__namespace.parse(ListPurchasesParams$outboundSchema, value),
|
|
81646
82303
|
"Input validation failed"
|
|
81647
82304
|
);
|
|
81648
82305
|
if (!parsed.ok) {
|
|
@@ -81650,7 +82307,7 @@ async function $do24(client, request, options) {
|
|
|
81650
82307
|
}
|
|
81651
82308
|
const payload = parsed.value;
|
|
81652
82309
|
const body = encodeJSON("body", payload, { explode: true });
|
|
81653
|
-
const path = pathToFunc("/v1/
|
|
82310
|
+
const path = pathToFunc("/v1/purchases.list")();
|
|
81654
82311
|
const headers = new Headers(compactMap({
|
|
81655
82312
|
"Content-Type": "application/json",
|
|
81656
82313
|
Accept: "application/json",
|
|
@@ -81666,7 +82323,7 @@ async function $do24(client, request, options) {
|
|
|
81666
82323
|
const context = {
|
|
81667
82324
|
options: client._options,
|
|
81668
82325
|
baseURL: options?.serverURL ?? client._baseURL ?? "",
|
|
81669
|
-
operationID: "
|
|
82326
|
+
operationID: "listPurchases",
|
|
81670
82327
|
oAuth2Scopes: null,
|
|
81671
82328
|
resolvedSecurity: requestSecurity,
|
|
81672
82329
|
securitySource: client._options.secretKey,
|
|
@@ -81698,7 +82355,7 @@ async function $do24(client, request, options) {
|
|
|
81698
82355
|
}
|
|
81699
82356
|
const response = doResult.value;
|
|
81700
82357
|
const [result] = await match(
|
|
81701
|
-
json(200,
|
|
82358
|
+
json(200, ListPurchasesResponse$inboundSchema),
|
|
81702
82359
|
fail("4XX"),
|
|
81703
82360
|
fail("5XX")
|
|
81704
82361
|
)(response, req);
|
|
@@ -81707,17 +82364,17 @@ async function $do24(client, request, options) {
|
|
|
81707
82364
|
}
|
|
81708
82365
|
return [result, { status: "complete", request: req, response }];
|
|
81709
82366
|
}
|
|
81710
|
-
function
|
|
81711
|
-
return new APIPromise($
|
|
82367
|
+
function customersListSubscriptions(client, request, options) {
|
|
82368
|
+
return new APIPromise($do28(
|
|
81712
82369
|
client,
|
|
81713
82370
|
request,
|
|
81714
82371
|
options
|
|
81715
82372
|
));
|
|
81716
82373
|
}
|
|
81717
|
-
async function $
|
|
82374
|
+
async function $do28(client, request, options) {
|
|
81718
82375
|
const parsed = safeParse(
|
|
81719
82376
|
request,
|
|
81720
|
-
(value) => z35__namespace.parse(
|
|
82377
|
+
(value) => z35__namespace.parse(ListSubscriptionsParams$outboundSchema, value),
|
|
81721
82378
|
"Input validation failed"
|
|
81722
82379
|
);
|
|
81723
82380
|
if (!parsed.ok) {
|
|
@@ -81725,7 +82382,7 @@ async function $do25(client, request, options) {
|
|
|
81725
82382
|
}
|
|
81726
82383
|
const payload = parsed.value;
|
|
81727
82384
|
const body = encodeJSON("body", payload, { explode: true });
|
|
81728
|
-
const path = pathToFunc("/v1/
|
|
82385
|
+
const path = pathToFunc("/v1/subscriptions.list")();
|
|
81729
82386
|
const headers = new Headers(compactMap({
|
|
81730
82387
|
"Content-Type": "application/json",
|
|
81731
82388
|
Accept: "application/json",
|
|
@@ -81741,7 +82398,7 @@ async function $do25(client, request, options) {
|
|
|
81741
82398
|
const context = {
|
|
81742
82399
|
options: client._options,
|
|
81743
82400
|
baseURL: options?.serverURL ?? client._baseURL ?? "",
|
|
81744
|
-
operationID: "
|
|
82401
|
+
operationID: "listSubscriptions",
|
|
81745
82402
|
oAuth2Scopes: null,
|
|
81746
82403
|
resolvedSecurity: requestSecurity,
|
|
81747
82404
|
securitySource: client._options.secretKey,
|
|
@@ -81773,7 +82430,7 @@ async function $do25(client, request, options) {
|
|
|
81773
82430
|
}
|
|
81774
82431
|
const response = doResult.value;
|
|
81775
82432
|
const [result] = await match(
|
|
81776
|
-
json(200,
|
|
82433
|
+
json(200, ListSubscriptionsResponse$inboundSchema),
|
|
81777
82434
|
fail("4XX"),
|
|
81778
82435
|
fail("5XX")
|
|
81779
82436
|
)(response, req);
|
|
@@ -81783,13 +82440,13 @@ async function $do25(client, request, options) {
|
|
|
81783
82440
|
return [result, { status: "complete", request: req, response }];
|
|
81784
82441
|
}
|
|
81785
82442
|
function customersList(client, request, options) {
|
|
81786
|
-
return new APIPromise($
|
|
82443
|
+
return new APIPromise($do29(
|
|
81787
82444
|
client,
|
|
81788
82445
|
request,
|
|
81789
82446
|
options
|
|
81790
82447
|
));
|
|
81791
82448
|
}
|
|
81792
|
-
async function $
|
|
82449
|
+
async function $do29(client, request, options) {
|
|
81793
82450
|
const parsed = safeParse(
|
|
81794
82451
|
request,
|
|
81795
82452
|
(value) => z35__namespace.parse(ListCustomersParams$outboundSchema, value),
|
|
@@ -81858,13 +82515,13 @@ async function $do26(client, request, options) {
|
|
|
81858
82515
|
return [result, { status: "complete", request: req, response }];
|
|
81859
82516
|
}
|
|
81860
82517
|
function customersUpdate(client, request, options) {
|
|
81861
|
-
return new APIPromise($
|
|
82518
|
+
return new APIPromise($do30(
|
|
81862
82519
|
client,
|
|
81863
82520
|
request,
|
|
81864
82521
|
options
|
|
81865
82522
|
));
|
|
81866
82523
|
}
|
|
81867
|
-
async function $
|
|
82524
|
+
async function $do30(client, request, options) {
|
|
81868
82525
|
const parsed = safeParse(
|
|
81869
82526
|
request,
|
|
81870
82527
|
(value) => z35__namespace.parse(UpdateCustomerParams$outboundSchema, value),
|
|
@@ -82035,15 +82692,35 @@ var Customers = class extends ClientSDK {
|
|
|
82035
82692
|
options
|
|
82036
82693
|
));
|
|
82037
82694
|
}
|
|
82695
|
+
/**
|
|
82696
|
+
* Lists recurring plans (including add-ons) across customers, live or expired. Filter by customer, entity, plan, or status. Pages may hold fewer than `limit` rows while `has_more` is true.
|
|
82697
|
+
*/
|
|
82698
|
+
async listSubscriptions(request, options) {
|
|
82699
|
+
return unwrapAsync(customersListSubscriptions(
|
|
82700
|
+
this,
|
|
82701
|
+
request,
|
|
82702
|
+
options
|
|
82703
|
+
));
|
|
82704
|
+
}
|
|
82705
|
+
/**
|
|
82706
|
+
* Lists one-off plan purchases across customers, live or expired. Filter by customer, entity, plan, or status. Pages may hold fewer than `limit` rows while `has_more` is true.
|
|
82707
|
+
*/
|
|
82708
|
+
async listPurchases(request, options) {
|
|
82709
|
+
return unwrapAsync(customersListPurchases(
|
|
82710
|
+
this,
|
|
82711
|
+
request,
|
|
82712
|
+
options
|
|
82713
|
+
));
|
|
82714
|
+
}
|
|
82038
82715
|
};
|
|
82039
82716
|
function entitiesCreate(client, request, options) {
|
|
82040
|
-
return new APIPromise($
|
|
82717
|
+
return new APIPromise($do31(
|
|
82041
82718
|
client,
|
|
82042
82719
|
request,
|
|
82043
82720
|
options
|
|
82044
82721
|
));
|
|
82045
82722
|
}
|
|
82046
|
-
async function $
|
|
82723
|
+
async function $do31(client, request, options) {
|
|
82047
82724
|
const parsed = safeParse(
|
|
82048
82725
|
request,
|
|
82049
82726
|
(value) => z35__namespace.parse(CreateEntityParams$outboundSchema, value),
|
|
@@ -82112,13 +82789,13 @@ async function $do28(client, request, options) {
|
|
|
82112
82789
|
return [result, { status: "complete", request: req, response }];
|
|
82113
82790
|
}
|
|
82114
82791
|
function entitiesDelete(client, request, options) {
|
|
82115
|
-
return new APIPromise($
|
|
82792
|
+
return new APIPromise($do32(
|
|
82116
82793
|
client,
|
|
82117
82794
|
request,
|
|
82118
82795
|
options
|
|
82119
82796
|
));
|
|
82120
82797
|
}
|
|
82121
|
-
async function $
|
|
82798
|
+
async function $do32(client, request, options) {
|
|
82122
82799
|
const parsed = safeParse(
|
|
82123
82800
|
request,
|
|
82124
82801
|
(value) => z35__namespace.parse(DeleteEntityParams$outboundSchema, value),
|
|
@@ -82187,13 +82864,13 @@ async function $do29(client, request, options) {
|
|
|
82187
82864
|
return [result, { status: "complete", request: req, response }];
|
|
82188
82865
|
}
|
|
82189
82866
|
function entitiesGet(client, request, options) {
|
|
82190
|
-
return new APIPromise($
|
|
82867
|
+
return new APIPromise($do33(
|
|
82191
82868
|
client,
|
|
82192
82869
|
request,
|
|
82193
82870
|
options
|
|
82194
82871
|
));
|
|
82195
82872
|
}
|
|
82196
|
-
async function $
|
|
82873
|
+
async function $do33(client, request, options) {
|
|
82197
82874
|
const parsed = safeParse(
|
|
82198
82875
|
request,
|
|
82199
82876
|
(value) => z35__namespace.parse(GetEntityParams$outboundSchema, value),
|
|
@@ -82262,13 +82939,13 @@ async function $do30(client, request, options) {
|
|
|
82262
82939
|
return [result, { status: "complete", request: req, response }];
|
|
82263
82940
|
}
|
|
82264
82941
|
function entitiesList(client, request, options) {
|
|
82265
|
-
return new APIPromise($
|
|
82942
|
+
return new APIPromise($do34(
|
|
82266
82943
|
client,
|
|
82267
82944
|
request,
|
|
82268
82945
|
options
|
|
82269
82946
|
));
|
|
82270
82947
|
}
|
|
82271
|
-
async function $
|
|
82948
|
+
async function $do34(client, request, options) {
|
|
82272
82949
|
const parsed = safeParse(
|
|
82273
82950
|
request,
|
|
82274
82951
|
(value) => z35__namespace.parse(ListEntitiesParams$outboundSchema, value),
|
|
@@ -82337,13 +83014,13 @@ async function $do31(client, request, options) {
|
|
|
82337
83014
|
return [result, { status: "complete", request: req, response }];
|
|
82338
83015
|
}
|
|
82339
83016
|
function entitiesUpdate(client, request, options) {
|
|
82340
|
-
return new APIPromise($
|
|
83017
|
+
return new APIPromise($do35(
|
|
82341
83018
|
client,
|
|
82342
83019
|
request,
|
|
82343
83020
|
options
|
|
82344
83021
|
));
|
|
82345
83022
|
}
|
|
82346
|
-
async function $
|
|
83023
|
+
async function $do35(client, request, options) {
|
|
82347
83024
|
const parsed = safeParse(
|
|
82348
83025
|
request,
|
|
82349
83026
|
(value) => z35__namespace.parse(UpdateEntityParams$outboundSchema, value),
|
|
@@ -82559,13 +83236,13 @@ var Entities = class extends ClientSDK {
|
|
|
82559
83236
|
}
|
|
82560
83237
|
};
|
|
82561
83238
|
function eventsAggregate(client, request, options) {
|
|
82562
|
-
return new APIPromise($
|
|
83239
|
+
return new APIPromise($do36(
|
|
82563
83240
|
client,
|
|
82564
83241
|
request,
|
|
82565
83242
|
options
|
|
82566
83243
|
));
|
|
82567
83244
|
}
|
|
82568
|
-
async function $
|
|
83245
|
+
async function $do36(client, request, options) {
|
|
82569
83246
|
const parsed = safeParse(
|
|
82570
83247
|
request,
|
|
82571
83248
|
(value) => z35__namespace.parse(EventsAggregateParams$outboundSchema, value),
|
|
@@ -82634,13 +83311,13 @@ async function $do33(client, request, options) {
|
|
|
82634
83311
|
return [result, { status: "complete", request: req, response }];
|
|
82635
83312
|
}
|
|
82636
83313
|
function eventsList(client, request, options) {
|
|
82637
|
-
return new APIPromise($
|
|
83314
|
+
return new APIPromise($do37(
|
|
82638
83315
|
client,
|
|
82639
83316
|
request,
|
|
82640
83317
|
options
|
|
82641
83318
|
));
|
|
82642
83319
|
}
|
|
82643
|
-
async function $
|
|
83320
|
+
async function $do37(client, request, options) {
|
|
82644
83321
|
const parsed = safeParse(
|
|
82645
83322
|
request,
|
|
82646
83323
|
(value) => z35__namespace.parse(EventsListParams$outboundSchema, value),
|
|
@@ -82733,13 +83410,13 @@ var Events = class extends ClientSDK {
|
|
|
82733
83410
|
}
|
|
82734
83411
|
};
|
|
82735
83412
|
function featuresCreate(client, request, options) {
|
|
82736
|
-
return new APIPromise($
|
|
83413
|
+
return new APIPromise($do38(
|
|
82737
83414
|
client,
|
|
82738
83415
|
request,
|
|
82739
83416
|
options
|
|
82740
83417
|
));
|
|
82741
83418
|
}
|
|
82742
|
-
async function $
|
|
83419
|
+
async function $do38(client, request, options) {
|
|
82743
83420
|
const parsed = safeParse(
|
|
82744
83421
|
request,
|
|
82745
83422
|
(value) => z35__namespace.parse(CreateFeatureParams$outboundSchema, value),
|
|
@@ -82808,13 +83485,13 @@ async function $do35(client, request, options) {
|
|
|
82808
83485
|
return [result, { status: "complete", request: req, response }];
|
|
82809
83486
|
}
|
|
82810
83487
|
function featuresDelete(client, request, options) {
|
|
82811
|
-
return new APIPromise($
|
|
83488
|
+
return new APIPromise($do39(
|
|
82812
83489
|
client,
|
|
82813
83490
|
request,
|
|
82814
83491
|
options
|
|
82815
83492
|
));
|
|
82816
83493
|
}
|
|
82817
|
-
async function $
|
|
83494
|
+
async function $do39(client, request, options) {
|
|
82818
83495
|
const parsed = safeParse(
|
|
82819
83496
|
request,
|
|
82820
83497
|
(value) => z35__namespace.parse(DeleteFeatureParams$outboundSchema, value),
|
|
@@ -82883,13 +83560,13 @@ async function $do36(client, request, options) {
|
|
|
82883
83560
|
return [result, { status: "complete", request: req, response }];
|
|
82884
83561
|
}
|
|
82885
83562
|
function featuresGet(client, request, options) {
|
|
82886
|
-
return new APIPromise($
|
|
83563
|
+
return new APIPromise($do40(
|
|
82887
83564
|
client,
|
|
82888
83565
|
request,
|
|
82889
83566
|
options
|
|
82890
83567
|
));
|
|
82891
83568
|
}
|
|
82892
|
-
async function $
|
|
83569
|
+
async function $do40(client, request, options) {
|
|
82893
83570
|
const parsed = safeParse(
|
|
82894
83571
|
request,
|
|
82895
83572
|
(value) => z35__namespace.parse(GetFeatureParams$outboundSchema, value),
|
|
@@ -82960,13 +83637,13 @@ async function $do37(client, request, options) {
|
|
|
82960
83637
|
|
|
82961
83638
|
// ../sdk/src/funcs/features-list.ts
|
|
82962
83639
|
function featuresList(client, _request, options) {
|
|
82963
|
-
return new APIPromise($
|
|
83640
|
+
return new APIPromise($do41(
|
|
82964
83641
|
client,
|
|
82965
83642
|
_request,
|
|
82966
83643
|
options
|
|
82967
83644
|
));
|
|
82968
83645
|
}
|
|
82969
|
-
async function $
|
|
83646
|
+
async function $do41(client, _request, options) {
|
|
82970
83647
|
const path = pathToFunc("/v1/features.list")();
|
|
82971
83648
|
const headers = new Headers(compactMap({
|
|
82972
83649
|
Accept: "application/json",
|
|
@@ -83023,13 +83700,13 @@ async function $do38(client, _request, options) {
|
|
|
83023
83700
|
return [result, { status: "complete", request: req, response }];
|
|
83024
83701
|
}
|
|
83025
83702
|
function featuresUpdate(client, request, options) {
|
|
83026
|
-
return new APIPromise($
|
|
83703
|
+
return new APIPromise($do42(
|
|
83027
83704
|
client,
|
|
83028
83705
|
request,
|
|
83029
83706
|
options
|
|
83030
83707
|
));
|
|
83031
83708
|
}
|
|
83032
|
-
async function $
|
|
83709
|
+
async function $do42(client, request, options) {
|
|
83033
83710
|
const parsed = safeParse(
|
|
83034
83711
|
request,
|
|
83035
83712
|
(value) => z35__namespace.parse(UpdateFeatureParams$outboundSchema, value),
|
|
@@ -83240,13 +83917,13 @@ var Features = class extends ClientSDK {
|
|
|
83240
83917
|
}
|
|
83241
83918
|
};
|
|
83242
83919
|
function invoicesCreate(client, request, options) {
|
|
83243
|
-
return new APIPromise($
|
|
83920
|
+
return new APIPromise($do43(
|
|
83244
83921
|
client,
|
|
83245
83922
|
request,
|
|
83246
83923
|
options
|
|
83247
83924
|
));
|
|
83248
83925
|
}
|
|
83249
|
-
async function $
|
|
83926
|
+
async function $do43(client, request, options) {
|
|
83250
83927
|
const parsed = safeParse(
|
|
83251
83928
|
request,
|
|
83252
83929
|
(value) => z35__namespace.parse(CreateInvoiceParams$outboundSchema, value),
|
|
@@ -83315,13 +83992,13 @@ async function $do40(client, request, options) {
|
|
|
83315
83992
|
return [result, { status: "complete", request: req, response }];
|
|
83316
83993
|
}
|
|
83317
83994
|
function invoicesFinalize(client, request, options) {
|
|
83318
|
-
return new APIPromise($
|
|
83995
|
+
return new APIPromise($do44(
|
|
83319
83996
|
client,
|
|
83320
83997
|
request,
|
|
83321
83998
|
options
|
|
83322
83999
|
));
|
|
83323
84000
|
}
|
|
83324
|
-
async function $
|
|
84001
|
+
async function $do44(client, request, options) {
|
|
83325
84002
|
const parsed = safeParse(
|
|
83326
84003
|
request,
|
|
83327
84004
|
(value) => z35__namespace.parse(FinalizeInvoiceParams$outboundSchema, value),
|
|
@@ -83390,13 +84067,13 @@ async function $do41(client, request, options) {
|
|
|
83390
84067
|
return [result, { status: "complete", request: req, response }];
|
|
83391
84068
|
}
|
|
83392
84069
|
function invoicesInsert(client, request, options) {
|
|
83393
|
-
return new APIPromise($
|
|
84070
|
+
return new APIPromise($do45(
|
|
83394
84071
|
client,
|
|
83395
84072
|
request,
|
|
83396
84073
|
options
|
|
83397
84074
|
));
|
|
83398
84075
|
}
|
|
83399
|
-
async function $
|
|
84076
|
+
async function $do45(client, request, options) {
|
|
83400
84077
|
const parsed = safeParse(
|
|
83401
84078
|
request,
|
|
83402
84079
|
(value) => z35__namespace.parse(InsertInvoicesParams$outboundSchema, value),
|
|
@@ -83465,13 +84142,13 @@ async function $do42(client, request, options) {
|
|
|
83465
84142
|
return [result, { status: "complete", request: req, response }];
|
|
83466
84143
|
}
|
|
83467
84144
|
function invoicesListTemplates(client, request, options) {
|
|
83468
|
-
return new APIPromise($
|
|
84145
|
+
return new APIPromise($do46(
|
|
83469
84146
|
client,
|
|
83470
84147
|
request,
|
|
83471
84148
|
options
|
|
83472
84149
|
));
|
|
83473
84150
|
}
|
|
83474
|
-
async function $
|
|
84151
|
+
async function $do46(client, request, options) {
|
|
83475
84152
|
const parsed = safeParse(
|
|
83476
84153
|
request,
|
|
83477
84154
|
(value) => z35__namespace.parse(ListInvoiceTemplatesParams$outboundSchema, value),
|
|
@@ -83540,13 +84217,13 @@ async function $do43(client, request, options) {
|
|
|
83540
84217
|
return [result, { status: "complete", request: req, response }];
|
|
83541
84218
|
}
|
|
83542
84219
|
function invoicesList(client, request, options) {
|
|
83543
|
-
return new APIPromise($
|
|
84220
|
+
return new APIPromise($do47(
|
|
83544
84221
|
client,
|
|
83545
84222
|
request,
|
|
83546
84223
|
options
|
|
83547
84224
|
));
|
|
83548
84225
|
}
|
|
83549
|
-
async function $
|
|
84226
|
+
async function $do47(client, request, options) {
|
|
83550
84227
|
const parsed = safeParse(
|
|
83551
84228
|
request,
|
|
83552
84229
|
(value) => z35__namespace.parse(ListInvoicesParams$outboundSchema, value),
|
|
@@ -83615,13 +84292,13 @@ async function $do44(client, request, options) {
|
|
|
83615
84292
|
return [result, { status: "complete", request: req, response }];
|
|
83616
84293
|
}
|
|
83617
84294
|
function invoicesPay(client, request, options) {
|
|
83618
|
-
return new APIPromise($
|
|
84295
|
+
return new APIPromise($do48(
|
|
83619
84296
|
client,
|
|
83620
84297
|
request,
|
|
83621
84298
|
options
|
|
83622
84299
|
));
|
|
83623
84300
|
}
|
|
83624
|
-
async function $
|
|
84301
|
+
async function $do48(client, request, options) {
|
|
83625
84302
|
const parsed = safeParse(
|
|
83626
84303
|
request,
|
|
83627
84304
|
(value) => z35__namespace.parse(PayInvoiceParams$outboundSchema, value),
|
|
@@ -83690,13 +84367,13 @@ async function $do45(client, request, options) {
|
|
|
83690
84367
|
return [result, { status: "complete", request: req, response }];
|
|
83691
84368
|
}
|
|
83692
84369
|
function invoicesReissue(client, request, options) {
|
|
83693
|
-
return new APIPromise($
|
|
84370
|
+
return new APIPromise($do49(
|
|
83694
84371
|
client,
|
|
83695
84372
|
request,
|
|
83696
84373
|
options
|
|
83697
84374
|
));
|
|
83698
84375
|
}
|
|
83699
|
-
async function $
|
|
84376
|
+
async function $do49(client, request, options) {
|
|
83700
84377
|
const parsed = safeParse(
|
|
83701
84378
|
request,
|
|
83702
84379
|
(value) => z35__namespace.parse(ReissueInvoiceParams$outboundSchema, value),
|
|
@@ -83765,13 +84442,13 @@ async function $do46(client, request, options) {
|
|
|
83765
84442
|
return [result, { status: "complete", request: req, response }];
|
|
83766
84443
|
}
|
|
83767
84444
|
function invoicesVoid(client, request, options) {
|
|
83768
|
-
return new APIPromise($
|
|
84445
|
+
return new APIPromise($do50(
|
|
83769
84446
|
client,
|
|
83770
84447
|
request,
|
|
83771
84448
|
options
|
|
83772
84449
|
));
|
|
83773
84450
|
}
|
|
83774
|
-
async function $
|
|
84451
|
+
async function $do50(client, request, options) {
|
|
83775
84452
|
const parsed = safeParse(
|
|
83776
84453
|
request,
|
|
83777
84454
|
(value) => z35__namespace.parse(VoidInvoiceParams$outboundSchema, value),
|
|
@@ -83924,13 +84601,13 @@ var Invoices = class extends ClientSDK {
|
|
|
83924
84601
|
}
|
|
83925
84602
|
};
|
|
83926
84603
|
function keysMint(client, request, options) {
|
|
83927
|
-
return new APIPromise($
|
|
84604
|
+
return new APIPromise($do51(
|
|
83928
84605
|
client,
|
|
83929
84606
|
request,
|
|
83930
84607
|
options
|
|
83931
84608
|
));
|
|
83932
84609
|
}
|
|
83933
|
-
async function $
|
|
84610
|
+
async function $do51(client, request, options) {
|
|
83934
84611
|
const parsed = safeParse(
|
|
83935
84612
|
request,
|
|
83936
84613
|
(value) => z35__namespace.parse(MintKeyParams$outboundSchema, value),
|
|
@@ -84001,13 +84678,13 @@ async function $do48(client, request, options) {
|
|
|
84001
84678
|
|
|
84002
84679
|
// ../sdk/src/funcs/keys-refresh.ts
|
|
84003
84680
|
function keysRefresh(client, _request, options) {
|
|
84004
|
-
return new APIPromise($
|
|
84681
|
+
return new APIPromise($do52(
|
|
84005
84682
|
client,
|
|
84006
84683
|
_request,
|
|
84007
84684
|
options
|
|
84008
84685
|
));
|
|
84009
84686
|
}
|
|
84010
|
-
async function $
|
|
84687
|
+
async function $do52(client, _request, options) {
|
|
84011
84688
|
const path = pathToFunc("/v1/keys.refresh")();
|
|
84012
84689
|
const headers = new Headers(compactMap({
|
|
84013
84690
|
"Content-Type": "application/json",
|
|
@@ -84065,13 +84742,13 @@ async function $do49(client, _request, options) {
|
|
|
84065
84742
|
return [result, { status: "complete", request: req, response }];
|
|
84066
84743
|
}
|
|
84067
84744
|
function keysRevoke(client, request, options) {
|
|
84068
|
-
return new APIPromise($
|
|
84745
|
+
return new APIPromise($do53(
|
|
84069
84746
|
client,
|
|
84070
84747
|
request,
|
|
84071
84748
|
options
|
|
84072
84749
|
));
|
|
84073
84750
|
}
|
|
84074
|
-
async function $
|
|
84751
|
+
async function $do53(client, request, options) {
|
|
84075
84752
|
const parsed = safeParse(
|
|
84076
84753
|
request,
|
|
84077
84754
|
(value) => z35__namespace.parse(RevokeKeyParams$outboundSchema, value),
|
|
@@ -84174,13 +84851,13 @@ var Keys = class extends ClientSDK {
|
|
|
84174
84851
|
}
|
|
84175
84852
|
};
|
|
84176
84853
|
function licensesAttach(client, request, options) {
|
|
84177
|
-
return new APIPromise($
|
|
84854
|
+
return new APIPromise($do54(
|
|
84178
84855
|
client,
|
|
84179
84856
|
request,
|
|
84180
84857
|
options
|
|
84181
84858
|
));
|
|
84182
84859
|
}
|
|
84183
|
-
async function $
|
|
84860
|
+
async function $do54(client, request, options) {
|
|
84184
84861
|
const parsed = safeParse(
|
|
84185
84862
|
request,
|
|
84186
84863
|
(value) => z35__namespace.parse(AttachLicenseParams$outboundSchema, value),
|
|
@@ -84249,13 +84926,13 @@ async function $do51(client, request, options) {
|
|
|
84249
84926
|
return [result, { status: "complete", request: req, response }];
|
|
84250
84927
|
}
|
|
84251
84928
|
function licensesRelease(client, request, options) {
|
|
84252
|
-
return new APIPromise($
|
|
84929
|
+
return new APIPromise($do55(
|
|
84253
84930
|
client,
|
|
84254
84931
|
request,
|
|
84255
84932
|
options
|
|
84256
84933
|
));
|
|
84257
84934
|
}
|
|
84258
|
-
async function $
|
|
84935
|
+
async function $do55(client, request, options) {
|
|
84259
84936
|
const parsed = safeParse(
|
|
84260
84937
|
request,
|
|
84261
84938
|
(value) => z35__namespace.parse(ReleaseLicenseParams$outboundSchema, value),
|
|
@@ -84348,13 +85025,13 @@ var Licenses = class extends ClientSDK {
|
|
|
84348
85025
|
}
|
|
84349
85026
|
};
|
|
84350
85027
|
function logsSearch(client, request, options) {
|
|
84351
|
-
return new APIPromise($
|
|
85028
|
+
return new APIPromise($do56(
|
|
84352
85029
|
client,
|
|
84353
85030
|
request,
|
|
84354
85031
|
options
|
|
84355
85032
|
));
|
|
84356
85033
|
}
|
|
84357
|
-
async function $
|
|
85034
|
+
async function $do56(client, request, options) {
|
|
84358
85035
|
const parsed = safeParse(
|
|
84359
85036
|
request,
|
|
84360
85037
|
(value) => z35__namespace.parse(SearchRequestLogsParams$outboundSchema, value),
|
|
@@ -84437,13 +85114,13 @@ var Logs = class extends ClientSDK {
|
|
|
84437
85114
|
}
|
|
84438
85115
|
};
|
|
84439
85116
|
function plansCreate(client, request, options) {
|
|
84440
|
-
return new APIPromise($
|
|
85117
|
+
return new APIPromise($do57(
|
|
84441
85118
|
client,
|
|
84442
85119
|
request,
|
|
84443
85120
|
options
|
|
84444
85121
|
));
|
|
84445
85122
|
}
|
|
84446
|
-
async function $
|
|
85123
|
+
async function $do57(client, request, options) {
|
|
84447
85124
|
const parsed = safeParse(
|
|
84448
85125
|
request,
|
|
84449
85126
|
(value) => z35__namespace.parse(CreatePlanParams$outboundSchema, value),
|
|
@@ -84512,13 +85189,13 @@ async function $do54(client, request, options) {
|
|
|
84512
85189
|
return [result, { status: "complete", request: req, response }];
|
|
84513
85190
|
}
|
|
84514
85191
|
function plansDelete(client, request, options) {
|
|
84515
|
-
return new APIPromise($
|
|
85192
|
+
return new APIPromise($do58(
|
|
84516
85193
|
client,
|
|
84517
85194
|
request,
|
|
84518
85195
|
options
|
|
84519
85196
|
));
|
|
84520
85197
|
}
|
|
84521
|
-
async function $
|
|
85198
|
+
async function $do58(client, request, options) {
|
|
84522
85199
|
const parsed = safeParse(
|
|
84523
85200
|
request,
|
|
84524
85201
|
(value) => z35__namespace.parse(DeletePlanParams$outboundSchema, value),
|
|
@@ -84587,13 +85264,13 @@ async function $do55(client, request, options) {
|
|
|
84587
85264
|
return [result, { status: "complete", request: req, response }];
|
|
84588
85265
|
}
|
|
84589
85266
|
function plansGet(client, request, options) {
|
|
84590
|
-
return new APIPromise($
|
|
85267
|
+
return new APIPromise($do59(
|
|
84591
85268
|
client,
|
|
84592
85269
|
request,
|
|
84593
85270
|
options
|
|
84594
85271
|
));
|
|
84595
85272
|
}
|
|
84596
|
-
async function $
|
|
85273
|
+
async function $do59(client, request, options) {
|
|
84597
85274
|
const parsed = safeParse(
|
|
84598
85275
|
request,
|
|
84599
85276
|
(value) => z35__namespace.parse(GetPlanParams$outboundSchema, value),
|
|
@@ -84662,13 +85339,13 @@ async function $do56(client, request, options) {
|
|
|
84662
85339
|
return [result, { status: "complete", request: req, response }];
|
|
84663
85340
|
}
|
|
84664
85341
|
function plansList(client, request, options) {
|
|
84665
|
-
return new APIPromise($
|
|
85342
|
+
return new APIPromise($do60(
|
|
84666
85343
|
client,
|
|
84667
85344
|
request,
|
|
84668
85345
|
options
|
|
84669
85346
|
));
|
|
84670
85347
|
}
|
|
84671
|
-
async function $
|
|
85348
|
+
async function $do60(client, request, options) {
|
|
84672
85349
|
const parsed = safeParse(
|
|
84673
85350
|
request,
|
|
84674
85351
|
(value) => z35__namespace.parse(z35__namespace.optional(ListPlansParams$outboundSchema), value),
|
|
@@ -84737,13 +85414,13 @@ async function $do57(client, request, options) {
|
|
|
84737
85414
|
return [result, { status: "complete", request: req, response }];
|
|
84738
85415
|
}
|
|
84739
85416
|
function plansUpdate(client, request, options) {
|
|
84740
|
-
return new APIPromise($
|
|
85417
|
+
return new APIPromise($do61(
|
|
84741
85418
|
client,
|
|
84742
85419
|
request,
|
|
84743
85420
|
options
|
|
84744
85421
|
));
|
|
84745
85422
|
}
|
|
84746
|
-
async function $
|
|
85423
|
+
async function $do61(client, request, options) {
|
|
84747
85424
|
const parsed = safeParse(
|
|
84748
85425
|
request,
|
|
84749
85426
|
(value) => z35__namespace.parse(UpdatePlanParams$outboundSchema, value),
|
|
@@ -85054,13 +85731,13 @@ var Plans = class extends ClientSDK {
|
|
|
85054
85731
|
}
|
|
85055
85732
|
};
|
|
85056
85733
|
function platformDisconnectStripe(client, request, options) {
|
|
85057
|
-
return new APIPromise($
|
|
85734
|
+
return new APIPromise($do62(
|
|
85058
85735
|
client,
|
|
85059
85736
|
request,
|
|
85060
85737
|
options
|
|
85061
85738
|
));
|
|
85062
85739
|
}
|
|
85063
|
-
async function $
|
|
85740
|
+
async function $do62(client, request, options) {
|
|
85064
85741
|
const parsed = safeParse(
|
|
85065
85742
|
request,
|
|
85066
85743
|
(value) => z35__namespace.parse(DisconnectStripeParams$outboundSchema, value),
|
|
@@ -85129,13 +85806,13 @@ async function $do59(client, request, options) {
|
|
|
85129
85806
|
return [result, { status: "complete", request: req, response }];
|
|
85130
85807
|
}
|
|
85131
85808
|
function platformGetRevenueCatKeys(client, request, options) {
|
|
85132
|
-
return new APIPromise($
|
|
85809
|
+
return new APIPromise($do63(
|
|
85133
85810
|
client,
|
|
85134
85811
|
request,
|
|
85135
85812
|
options
|
|
85136
85813
|
));
|
|
85137
85814
|
}
|
|
85138
|
-
async function $
|
|
85815
|
+
async function $do63(client, request, options) {
|
|
85139
85816
|
const parsed = safeParse(
|
|
85140
85817
|
request,
|
|
85141
85818
|
(value) => z35__namespace.parse(GetRevenueCatKeysParams$outboundSchema, value),
|
|
@@ -85204,13 +85881,13 @@ async function $do60(client, request, options) {
|
|
|
85204
85881
|
return [result, { status: "complete", request: req, response }];
|
|
85205
85882
|
}
|
|
85206
85883
|
function platformGetStripeConnection(client, request, options) {
|
|
85207
|
-
return new APIPromise($
|
|
85884
|
+
return new APIPromise($do64(
|
|
85208
85885
|
client,
|
|
85209
85886
|
request,
|
|
85210
85887
|
options
|
|
85211
85888
|
));
|
|
85212
85889
|
}
|
|
85213
|
-
async function $
|
|
85890
|
+
async function $do64(client, request, options) {
|
|
85214
85891
|
const parsed = safeParse(
|
|
85215
85892
|
request,
|
|
85216
85893
|
(value) => z35__namespace.parse(GetStripeConnectionParams$outboundSchema, value),
|
|
@@ -85279,13 +85956,13 @@ async function $do61(client, request, options) {
|
|
|
85279
85956
|
return [result, { status: "complete", request: req, response }];
|
|
85280
85957
|
}
|
|
85281
85958
|
function platformLinkRevenueCat(client, request, options) {
|
|
85282
|
-
return new APIPromise($
|
|
85959
|
+
return new APIPromise($do65(
|
|
85283
85960
|
client,
|
|
85284
85961
|
request,
|
|
85285
85962
|
options
|
|
85286
85963
|
));
|
|
85287
85964
|
}
|
|
85288
|
-
async function $
|
|
85965
|
+
async function $do65(client, request, options) {
|
|
85289
85966
|
const parsed = safeParse(
|
|
85290
85967
|
request,
|
|
85291
85968
|
(value) => z35__namespace.parse(LinkRevenueCatParams$outboundSchema, value),
|
|
@@ -85354,13 +86031,13 @@ async function $do62(client, request, options) {
|
|
|
85354
86031
|
return [result, { status: "complete", request: req, response }];
|
|
85355
86032
|
}
|
|
85356
86033
|
function platformSyncRevenueCat(client, request, options) {
|
|
85357
|
-
return new APIPromise($
|
|
86034
|
+
return new APIPromise($do66(
|
|
85358
86035
|
client,
|
|
85359
86036
|
request,
|
|
85360
86037
|
options
|
|
85361
86038
|
));
|
|
85362
86039
|
}
|
|
85363
|
-
async function $
|
|
86040
|
+
async function $do66(client, request, options) {
|
|
85364
86041
|
const parsed = safeParse(
|
|
85365
86042
|
request,
|
|
85366
86043
|
(value) => z35__namespace.parse(SyncRevenueCatParams$outboundSchema, value),
|
|
@@ -85483,13 +86160,13 @@ var Platform = class extends ClientSDK {
|
|
|
85483
86160
|
}
|
|
85484
86161
|
};
|
|
85485
86162
|
function referralsCreateCode(client, request, options) {
|
|
85486
|
-
return new APIPromise($
|
|
86163
|
+
return new APIPromise($do67(
|
|
85487
86164
|
client,
|
|
85488
86165
|
request,
|
|
85489
86166
|
options
|
|
85490
86167
|
));
|
|
85491
86168
|
}
|
|
85492
|
-
async function $
|
|
86169
|
+
async function $do67(client, request, options) {
|
|
85493
86170
|
const parsed = safeParse(
|
|
85494
86171
|
request,
|
|
85495
86172
|
(value) => z35__namespace.parse(CreateReferralCodeParams$outboundSchema, value),
|
|
@@ -85558,13 +86235,13 @@ async function $do64(client, request, options) {
|
|
|
85558
86235
|
return [result, { status: "complete", request: req, response }];
|
|
85559
86236
|
}
|
|
85560
86237
|
function referralsCreateProgram(client, request, options) {
|
|
85561
|
-
return new APIPromise($
|
|
86238
|
+
return new APIPromise($do68(
|
|
85562
86239
|
client,
|
|
85563
86240
|
request,
|
|
85564
86241
|
options
|
|
85565
86242
|
));
|
|
85566
86243
|
}
|
|
85567
|
-
async function $
|
|
86244
|
+
async function $do68(client, request, options) {
|
|
85568
86245
|
const parsed = safeParse(
|
|
85569
86246
|
request,
|
|
85570
86247
|
(value) => z35__namespace.parse(CreateReferralProgramParams$outboundSchema, value),
|
|
@@ -85633,13 +86310,13 @@ async function $do65(client, request, options) {
|
|
|
85633
86310
|
return [result, { status: "complete", request: req, response }];
|
|
85634
86311
|
}
|
|
85635
86312
|
function referralsDeleteProgram(client, request, options) {
|
|
85636
|
-
return new APIPromise($
|
|
86313
|
+
return new APIPromise($do69(
|
|
85637
86314
|
client,
|
|
85638
86315
|
request,
|
|
85639
86316
|
options
|
|
85640
86317
|
));
|
|
85641
86318
|
}
|
|
85642
|
-
async function $
|
|
86319
|
+
async function $do69(client, request, options) {
|
|
85643
86320
|
const parsed = safeParse(
|
|
85644
86321
|
request,
|
|
85645
86322
|
(value) => z35__namespace.parse(DeleteReferralProgramParams$outboundSchema, value),
|
|
@@ -85708,13 +86385,13 @@ async function $do66(client, request, options) {
|
|
|
85708
86385
|
return [result, { status: "complete", request: req, response }];
|
|
85709
86386
|
}
|
|
85710
86387
|
function referralsGetProgram(client, request, options) {
|
|
85711
|
-
return new APIPromise($
|
|
86388
|
+
return new APIPromise($do70(
|
|
85712
86389
|
client,
|
|
85713
86390
|
request,
|
|
85714
86391
|
options
|
|
85715
86392
|
));
|
|
85716
86393
|
}
|
|
85717
|
-
async function $
|
|
86394
|
+
async function $do70(client, request, options) {
|
|
85718
86395
|
const parsed = safeParse(
|
|
85719
86396
|
request,
|
|
85720
86397
|
(value) => z35__namespace.parse(GetReferralProgramParams$outboundSchema, value),
|
|
@@ -85785,13 +86462,13 @@ async function $do67(client, request, options) {
|
|
|
85785
86462
|
|
|
85786
86463
|
// ../sdk/src/funcs/referrals-list-programs.ts
|
|
85787
86464
|
function referralsListPrograms(client, _request, options) {
|
|
85788
|
-
return new APIPromise($
|
|
86465
|
+
return new APIPromise($do71(
|
|
85789
86466
|
client,
|
|
85790
86467
|
_request,
|
|
85791
86468
|
options
|
|
85792
86469
|
));
|
|
85793
86470
|
}
|
|
85794
|
-
async function $
|
|
86471
|
+
async function $do71(client, _request, options) {
|
|
85795
86472
|
const path = pathToFunc("/v1/referral_programs.list")();
|
|
85796
86473
|
const headers = new Headers(compactMap({
|
|
85797
86474
|
"Content-Type": "application/json",
|
|
@@ -85849,13 +86526,13 @@ async function $do68(client, _request, options) {
|
|
|
85849
86526
|
return [result, { status: "complete", request: req, response }];
|
|
85850
86527
|
}
|
|
85851
86528
|
function referralsRedeemCode(client, request, options) {
|
|
85852
|
-
return new APIPromise($
|
|
86529
|
+
return new APIPromise($do72(
|
|
85853
86530
|
client,
|
|
85854
86531
|
request,
|
|
85855
86532
|
options
|
|
85856
86533
|
));
|
|
85857
86534
|
}
|
|
85858
|
-
async function $
|
|
86535
|
+
async function $do72(client, request, options) {
|
|
85859
86536
|
const parsed = safeParse(
|
|
85860
86537
|
request,
|
|
85861
86538
|
(value) => z35__namespace.parse(RedeemReferralCodeParams$outboundSchema, value),
|
|
@@ -85924,13 +86601,13 @@ async function $do69(client, request, options) {
|
|
|
85924
86601
|
return [result, { status: "complete", request: req, response }];
|
|
85925
86602
|
}
|
|
85926
86603
|
function referralsUpdateProgram(client, request, options) {
|
|
85927
|
-
return new APIPromise($
|
|
86604
|
+
return new APIPromise($do73(
|
|
85928
86605
|
client,
|
|
85929
86606
|
request,
|
|
85930
86607
|
options
|
|
85931
86608
|
));
|
|
85932
86609
|
}
|
|
85933
|
-
async function $
|
|
86610
|
+
async function $do73(client, request, options) {
|
|
85934
86611
|
const parsed = safeParse(
|
|
85935
86612
|
request,
|
|
85936
86613
|
(value) => z35__namespace.parse(UpdateReferralProgramParams$outboundSchema, value),
|
|
@@ -86073,13 +86750,13 @@ var Referrals = class extends ClientSDK {
|
|
|
86073
86750
|
}
|
|
86074
86751
|
};
|
|
86075
86752
|
function rewardsCreate(client, request, options) {
|
|
86076
|
-
return new APIPromise($
|
|
86753
|
+
return new APIPromise($do74(
|
|
86077
86754
|
client,
|
|
86078
86755
|
request,
|
|
86079
86756
|
options
|
|
86080
86757
|
));
|
|
86081
86758
|
}
|
|
86082
|
-
async function $
|
|
86759
|
+
async function $do74(client, request, options) {
|
|
86083
86760
|
const parsed = safeParse(
|
|
86084
86761
|
request,
|
|
86085
86762
|
(value) => z35__namespace.parse(CreateRewardParams$outboundSchema, value),
|
|
@@ -86148,13 +86825,13 @@ async function $do71(client, request, options) {
|
|
|
86148
86825
|
return [result, { status: "complete", request: req, response }];
|
|
86149
86826
|
}
|
|
86150
86827
|
function rewardsDelete(client, request, options) {
|
|
86151
|
-
return new APIPromise($
|
|
86828
|
+
return new APIPromise($do75(
|
|
86152
86829
|
client,
|
|
86153
86830
|
request,
|
|
86154
86831
|
options
|
|
86155
86832
|
));
|
|
86156
86833
|
}
|
|
86157
|
-
async function $
|
|
86834
|
+
async function $do75(client, request, options) {
|
|
86158
86835
|
const parsed = safeParse(
|
|
86159
86836
|
request,
|
|
86160
86837
|
(value) => z35__namespace.parse(DeleteRewardParams$outboundSchema, value),
|
|
@@ -86223,13 +86900,13 @@ async function $do72(client, request, options) {
|
|
|
86223
86900
|
return [result, { status: "complete", request: req, response }];
|
|
86224
86901
|
}
|
|
86225
86902
|
function rewardsGet(client, request, options) {
|
|
86226
|
-
return new APIPromise($
|
|
86903
|
+
return new APIPromise($do76(
|
|
86227
86904
|
client,
|
|
86228
86905
|
request,
|
|
86229
86906
|
options
|
|
86230
86907
|
));
|
|
86231
86908
|
}
|
|
86232
|
-
async function $
|
|
86909
|
+
async function $do76(client, request, options) {
|
|
86233
86910
|
const parsed = safeParse(
|
|
86234
86911
|
request,
|
|
86235
86912
|
(value) => z35__namespace.parse(GetRewardParams$outboundSchema, value),
|
|
@@ -86300,13 +86977,13 @@ async function $do73(client, request, options) {
|
|
|
86300
86977
|
|
|
86301
86978
|
// ../sdk/src/funcs/rewards-list.ts
|
|
86302
86979
|
function rewardsList(client, _request, options) {
|
|
86303
|
-
return new APIPromise($
|
|
86980
|
+
return new APIPromise($do77(
|
|
86304
86981
|
client,
|
|
86305
86982
|
_request,
|
|
86306
86983
|
options
|
|
86307
86984
|
));
|
|
86308
86985
|
}
|
|
86309
|
-
async function $
|
|
86986
|
+
async function $do77(client, _request, options) {
|
|
86310
86987
|
const path = pathToFunc("/v1/rewards.list")();
|
|
86311
86988
|
const headers = new Headers(compactMap({
|
|
86312
86989
|
"Content-Type": "application/json",
|
|
@@ -86364,13 +87041,13 @@ async function $do74(client, _request, options) {
|
|
|
86364
87041
|
return [result, { status: "complete", request: req, response }];
|
|
86365
87042
|
}
|
|
86366
87043
|
function rewardsRedeemCode(client, request, options) {
|
|
86367
|
-
return new APIPromise($
|
|
87044
|
+
return new APIPromise($do78(
|
|
86368
87045
|
client,
|
|
86369
87046
|
request,
|
|
86370
87047
|
options
|
|
86371
87048
|
));
|
|
86372
87049
|
}
|
|
86373
|
-
async function $
|
|
87050
|
+
async function $do78(client, request, options) {
|
|
86374
87051
|
const parsed = safeParse(
|
|
86375
87052
|
request,
|
|
86376
87053
|
(value) => z35__namespace.parse(RedeemRewardCodeParams$outboundSchema, value),
|
|
@@ -86439,13 +87116,13 @@ async function $do75(client, request, options) {
|
|
|
86439
87116
|
return [result, { status: "complete", request: req, response }];
|
|
86440
87117
|
}
|
|
86441
87118
|
function rewardsUpdate(client, request, options) {
|
|
86442
|
-
return new APIPromise($
|
|
87119
|
+
return new APIPromise($do79(
|
|
86443
87120
|
client,
|
|
86444
87121
|
request,
|
|
86445
87122
|
options
|
|
86446
87123
|
));
|
|
86447
87124
|
}
|
|
86448
|
-
async function $
|
|
87125
|
+
async function $do79(client, request, options) {
|
|
86449
87126
|
const parsed = safeParse(
|
|
86450
87127
|
request,
|
|
86451
87128
|
(value) => z35__namespace.parse(UpdateRewardParams$outboundSchema, value),
|
|
@@ -86578,13 +87255,13 @@ var Rewards = class extends ClientSDK {
|
|
|
86578
87255
|
}
|
|
86579
87256
|
};
|
|
86580
87257
|
function sandboxesCreate(client, request, options) {
|
|
86581
|
-
return new APIPromise($
|
|
87258
|
+
return new APIPromise($do80(
|
|
86582
87259
|
client,
|
|
86583
87260
|
request,
|
|
86584
87261
|
options
|
|
86585
87262
|
));
|
|
86586
87263
|
}
|
|
86587
|
-
async function $
|
|
87264
|
+
async function $do80(client, request, options) {
|
|
86588
87265
|
const parsed = safeParse(
|
|
86589
87266
|
request,
|
|
86590
87267
|
(value) => z35__namespace.parse(CreateSandboxParams$outboundSchema, value),
|
|
@@ -86653,13 +87330,13 @@ async function $do77(client, request, options) {
|
|
|
86653
87330
|
return [result, { status: "complete", request: req, response }];
|
|
86654
87331
|
}
|
|
86655
87332
|
function sandboxesDelete(client, request, options) {
|
|
86656
|
-
return new APIPromise($
|
|
87333
|
+
return new APIPromise($do81(
|
|
86657
87334
|
client,
|
|
86658
87335
|
request,
|
|
86659
87336
|
options
|
|
86660
87337
|
));
|
|
86661
87338
|
}
|
|
86662
|
-
async function $
|
|
87339
|
+
async function $do81(client, request, options) {
|
|
86663
87340
|
const parsed = safeParse(
|
|
86664
87341
|
request,
|
|
86665
87342
|
(value) => z35__namespace.parse(DeleteSandboxParams$outboundSchema, value),
|
|
@@ -86730,13 +87407,13 @@ async function $do78(client, request, options) {
|
|
|
86730
87407
|
|
|
86731
87408
|
// ../sdk/src/funcs/sandboxes-list.ts
|
|
86732
87409
|
function sandboxesList(client, _request, options) {
|
|
86733
|
-
return new APIPromise($
|
|
87410
|
+
return new APIPromise($do82(
|
|
86734
87411
|
client,
|
|
86735
87412
|
_request,
|
|
86736
87413
|
options
|
|
86737
87414
|
));
|
|
86738
87415
|
}
|
|
86739
|
-
async function $
|
|
87416
|
+
async function $do82(client, _request, options) {
|
|
86740
87417
|
const path = pathToFunc("/v1/sandboxes.list")();
|
|
86741
87418
|
const headers = new Headers(compactMap({
|
|
86742
87419
|
"Content-Type": "application/json",
|
|
@@ -86796,13 +87473,13 @@ async function $do79(client, _request, options) {
|
|
|
86796
87473
|
|
|
86797
87474
|
// ../sdk/src/funcs/sandboxes-reset.ts
|
|
86798
87475
|
function sandboxesReset(client, _request, options) {
|
|
86799
|
-
return new APIPromise($
|
|
87476
|
+
return new APIPromise($do83(
|
|
86800
87477
|
client,
|
|
86801
87478
|
_request,
|
|
86802
87479
|
options
|
|
86803
87480
|
));
|
|
86804
87481
|
}
|
|
86805
|
-
async function $
|
|
87482
|
+
async function $do83(client, _request, options) {
|
|
86806
87483
|
const path = pathToFunc("/v1/sandboxes.reset")();
|
|
86807
87484
|
const headers = new Headers(compactMap({
|
|
86808
87485
|
"Content-Type": "application/json",
|
|
@@ -86904,13 +87581,13 @@ var Sandboxes = class extends ClientSDK {
|
|
|
86904
87581
|
}
|
|
86905
87582
|
};
|
|
86906
87583
|
function webhooksCreate(client, request, options) {
|
|
86907
|
-
return new APIPromise($
|
|
87584
|
+
return new APIPromise($do84(
|
|
86908
87585
|
client,
|
|
86909
87586
|
request,
|
|
86910
87587
|
options
|
|
86911
87588
|
));
|
|
86912
87589
|
}
|
|
86913
|
-
async function $
|
|
87590
|
+
async function $do84(client, request, options) {
|
|
86914
87591
|
const parsed = safeParse(
|
|
86915
87592
|
request,
|
|
86916
87593
|
(value) => z35__namespace.parse(CreateWebhookParams$outboundSchema, value),
|
|
@@ -86979,13 +87656,13 @@ async function $do81(client, request, options) {
|
|
|
86979
87656
|
return [result, { status: "complete", request: req, response }];
|
|
86980
87657
|
}
|
|
86981
87658
|
function webhooksDelete(client, request, options) {
|
|
86982
|
-
return new APIPromise($
|
|
87659
|
+
return new APIPromise($do85(
|
|
86983
87660
|
client,
|
|
86984
87661
|
request,
|
|
86985
87662
|
options
|
|
86986
87663
|
));
|
|
86987
87664
|
}
|
|
86988
|
-
async function $
|
|
87665
|
+
async function $do85(client, request, options) {
|
|
86989
87666
|
const parsed = safeParse(
|
|
86990
87667
|
request,
|
|
86991
87668
|
(value) => z35__namespace.parse(DeleteWebhookParams$outboundSchema, value),
|
|
@@ -87054,13 +87731,13 @@ async function $do82(client, request, options) {
|
|
|
87054
87731
|
return [result, { status: "complete", request: req, response }];
|
|
87055
87732
|
}
|
|
87056
87733
|
function webhooksGet(client, request, options) {
|
|
87057
|
-
return new APIPromise($
|
|
87734
|
+
return new APIPromise($do86(
|
|
87058
87735
|
client,
|
|
87059
87736
|
request,
|
|
87060
87737
|
options
|
|
87061
87738
|
));
|
|
87062
87739
|
}
|
|
87063
|
-
async function $
|
|
87740
|
+
async function $do86(client, request, options) {
|
|
87064
87741
|
const parsed = safeParse(
|
|
87065
87742
|
request,
|
|
87066
87743
|
(value) => z35__namespace.parse(GetWebhookParams$outboundSchema, value),
|
|
@@ -87131,13 +87808,13 @@ async function $do83(client, request, options) {
|
|
|
87131
87808
|
|
|
87132
87809
|
// ../sdk/src/funcs/webhooks-list.ts
|
|
87133
87810
|
function webhooksList(client, _request, options) {
|
|
87134
|
-
return new APIPromise($
|
|
87811
|
+
return new APIPromise($do87(
|
|
87135
87812
|
client,
|
|
87136
87813
|
_request,
|
|
87137
87814
|
options
|
|
87138
87815
|
));
|
|
87139
87816
|
}
|
|
87140
|
-
async function $
|
|
87817
|
+
async function $do87(client, _request, options) {
|
|
87141
87818
|
const path = pathToFunc("/v1/webhooks.list")();
|
|
87142
87819
|
const headers = new Headers(compactMap({
|
|
87143
87820
|
"Content-Type": "application/json",
|
|
@@ -87195,13 +87872,13 @@ async function $do84(client, _request, options) {
|
|
|
87195
87872
|
return [result, { status: "complete", request: req, response }];
|
|
87196
87873
|
}
|
|
87197
87874
|
function webhooksPreviewSync(client, request, options) {
|
|
87198
|
-
return new APIPromise($
|
|
87875
|
+
return new APIPromise($do88(
|
|
87199
87876
|
client,
|
|
87200
87877
|
request,
|
|
87201
87878
|
options
|
|
87202
87879
|
));
|
|
87203
87880
|
}
|
|
87204
|
-
async function $
|
|
87881
|
+
async function $do88(client, request, options) {
|
|
87205
87882
|
const parsed = safeParse(
|
|
87206
87883
|
request,
|
|
87207
87884
|
(value) => z35__namespace.parse(
|
|
@@ -87273,13 +87950,13 @@ async function $do85(client, request, options) {
|
|
|
87273
87950
|
return [result, { status: "complete", request: req, response }];
|
|
87274
87951
|
}
|
|
87275
87952
|
function webhooksSync(client, request, options) {
|
|
87276
|
-
return new APIPromise($
|
|
87953
|
+
return new APIPromise($do89(
|
|
87277
87954
|
client,
|
|
87278
87955
|
request,
|
|
87279
87956
|
options
|
|
87280
87957
|
));
|
|
87281
87958
|
}
|
|
87282
|
-
async function $
|
|
87959
|
+
async function $do89(client, request, options) {
|
|
87283
87960
|
const parsed = safeParse(
|
|
87284
87961
|
request,
|
|
87285
87962
|
(value) => z35__namespace.parse(SyncWebhooksSyncWebhooksParams$outboundSchema, value),
|
|
@@ -87348,13 +88025,13 @@ async function $do86(client, request, options) {
|
|
|
87348
88025
|
return [result, { status: "complete", request: req, response }];
|
|
87349
88026
|
}
|
|
87350
88027
|
function webhooksUpdate(client, request, options) {
|
|
87351
|
-
return new APIPromise($
|
|
88028
|
+
return new APIPromise($do90(
|
|
87352
88029
|
client,
|
|
87353
88030
|
request,
|
|
87354
88031
|
options
|
|
87355
88032
|
));
|
|
87356
88033
|
}
|
|
87357
|
-
async function $
|
|
88034
|
+
async function $do90(client, request, options) {
|
|
87358
88035
|
const parsed = safeParse(
|
|
87359
88036
|
request,
|
|
87360
88037
|
(value) => z35__namespace.parse(UpdateWebhookParams$outboundSchema, value),
|
|
@@ -90284,6 +90961,25 @@ exports.LinkRevenueCatEnv = LinkRevenueCatEnv;
|
|
|
90284
90961
|
exports.LinkRevenueCatEnv$outboundSchema = LinkRevenueCatEnv$outboundSchema;
|
|
90285
90962
|
exports.LinkRevenueCatParams$outboundSchema = LinkRevenueCatParams$outboundSchema;
|
|
90286
90963
|
exports.LinkRevenueCatResponse$inboundSchema = LinkRevenueCatResponse$inboundSchema;
|
|
90964
|
+
exports.ListBalancesBillingMethod = ListBalancesBillingMethod;
|
|
90965
|
+
exports.ListBalancesBillingMethod$inboundSchema = ListBalancesBillingMethod$inboundSchema;
|
|
90966
|
+
exports.ListBalancesIntervalEnum = ListBalancesIntervalEnum;
|
|
90967
|
+
exports.ListBalancesIntervalEnum$inboundSchema = ListBalancesIntervalEnum$inboundSchema;
|
|
90968
|
+
exports.ListBalancesIntervalUnion$inboundSchema = ListBalancesIntervalUnion$inboundSchema;
|
|
90969
|
+
exports.ListBalancesList$inboundSchema = ListBalancesList$inboundSchema;
|
|
90970
|
+
exports.ListBalancesListStatus = ListBalancesListStatus;
|
|
90971
|
+
exports.ListBalancesListStatus$inboundSchema = ListBalancesListStatus$inboundSchema;
|
|
90972
|
+
exports.ListBalancesParams$outboundSchema = ListBalancesParams$outboundSchema;
|
|
90973
|
+
exports.ListBalancesPrice$inboundSchema = ListBalancesPrice$inboundSchema;
|
|
90974
|
+
exports.ListBalancesReset$inboundSchema = ListBalancesReset$inboundSchema;
|
|
90975
|
+
exports.ListBalancesResponse$inboundSchema = ListBalancesResponse$inboundSchema;
|
|
90976
|
+
exports.ListBalancesRollover$inboundSchema = ListBalancesRollover$inboundSchema;
|
|
90977
|
+
exports.ListBalancesStatusRequestBody = ListBalancesStatusRequestBody;
|
|
90978
|
+
exports.ListBalancesStatusRequestBody$outboundSchema = ListBalancesStatusRequestBody$outboundSchema;
|
|
90979
|
+
exports.ListBalancesTier$inboundSchema = ListBalancesTier$inboundSchema;
|
|
90980
|
+
exports.ListBalancesTierBehavior = ListBalancesTierBehavior;
|
|
90981
|
+
exports.ListBalancesTierBehavior$inboundSchema = ListBalancesTierBehavior$inboundSchema;
|
|
90982
|
+
exports.ListBalancesTo$inboundSchema = ListBalancesTo$inboundSchema;
|
|
90287
90983
|
exports.ListCustomersAnchor = ListCustomersAnchor;
|
|
90288
90984
|
exports.ListCustomersAnchor$inboundSchema = ListCustomersAnchor$inboundSchema;
|
|
90289
90985
|
exports.ListCustomersAutoTopup$inboundSchema = ListCustomersAutoTopup$inboundSchema;
|
|
@@ -91032,6 +91728,15 @@ exports.ListPlansVariantUpsertLicenseThresholdBilling$inboundSchema = ListPlansV
|
|
|
91032
91728
|
exports.ListPlansVariantUpsertLicenseTierAdditionalCurrency$inboundSchema = ListPlansVariantUpsertLicenseTierAdditionalCurrency$inboundSchema;
|
|
91033
91729
|
exports.ListPlansVariantUpsertLicenseTierBehavior = ListPlansVariantUpsertLicenseTierBehavior;
|
|
91034
91730
|
exports.ListPlansVariantUpsertLicenseTierBehavior$inboundSchema = ListPlansVariantUpsertLicenseTierBehavior$inboundSchema;
|
|
91731
|
+
exports.ListPurchasesList$inboundSchema = ListPurchasesList$inboundSchema;
|
|
91732
|
+
exports.ListPurchasesListStatus = ListPurchasesListStatus;
|
|
91733
|
+
exports.ListPurchasesListStatus$inboundSchema = ListPurchasesListStatus$inboundSchema;
|
|
91734
|
+
exports.ListPurchasesParams$outboundSchema = ListPurchasesParams$outboundSchema;
|
|
91735
|
+
exports.ListPurchasesResponse$inboundSchema = ListPurchasesResponse$inboundSchema;
|
|
91736
|
+
exports.ListPurchasesScope = ListPurchasesScope;
|
|
91737
|
+
exports.ListPurchasesScope$inboundSchema = ListPurchasesScope$inboundSchema;
|
|
91738
|
+
exports.ListPurchasesStatusRequestBody = ListPurchasesStatusRequestBody;
|
|
91739
|
+
exports.ListPurchasesStatusRequestBody$outboundSchema = ListPurchasesStatusRequestBody$outboundSchema;
|
|
91035
91740
|
exports.ListReferralProgramsList$inboundSchema = ListReferralProgramsList$inboundSchema;
|
|
91036
91741
|
exports.ListReferralProgramsParams$outboundSchema = ListReferralProgramsParams$outboundSchema;
|
|
91037
91742
|
exports.ListReferralProgramsReceivedBy = ListReferralProgramsReceivedBy;
|
|
@@ -91058,6 +91763,15 @@ exports.ListSandboxesColor$inboundSchema = ListSandboxesColor$inboundSchema;
|
|
|
91058
91763
|
exports.ListSandboxesList$inboundSchema = ListSandboxesList$inboundSchema;
|
|
91059
91764
|
exports.ListSandboxesParams$outboundSchema = ListSandboxesParams$outboundSchema;
|
|
91060
91765
|
exports.ListSandboxesResponse$inboundSchema = ListSandboxesResponse$inboundSchema;
|
|
91766
|
+
exports.ListSubscriptionsList$inboundSchema = ListSubscriptionsList$inboundSchema;
|
|
91767
|
+
exports.ListSubscriptionsListStatus = ListSubscriptionsListStatus;
|
|
91768
|
+
exports.ListSubscriptionsListStatus$inboundSchema = ListSubscriptionsListStatus$inboundSchema;
|
|
91769
|
+
exports.ListSubscriptionsParams$outboundSchema = ListSubscriptionsParams$outboundSchema;
|
|
91770
|
+
exports.ListSubscriptionsResponse$inboundSchema = ListSubscriptionsResponse$inboundSchema;
|
|
91771
|
+
exports.ListSubscriptionsScope = ListSubscriptionsScope;
|
|
91772
|
+
exports.ListSubscriptionsScope$inboundSchema = ListSubscriptionsScope$inboundSchema;
|
|
91773
|
+
exports.ListSubscriptionsStatusRequestBody = ListSubscriptionsStatusRequestBody;
|
|
91774
|
+
exports.ListSubscriptionsStatusRequestBody$outboundSchema = ListSubscriptionsStatusRequestBody$outboundSchema;
|
|
91061
91775
|
exports.ListWebhooksList$inboundSchema = ListWebhooksList$inboundSchema;
|
|
91062
91776
|
exports.ListWebhooksParams$outboundSchema = ListWebhooksParams$outboundSchema;
|
|
91063
91777
|
exports.ListWebhooksResponse$inboundSchema = ListWebhooksResponse$inboundSchema;
|
|
@@ -95591,6 +96305,15 @@ exports.linesToJSON = linesToJSON;
|
|
|
95591
96305
|
exports.linkRevenueCatParamsToJSON = linkRevenueCatParamsToJSON;
|
|
95592
96306
|
exports.linkRevenueCatResponseFromJSON = linkRevenueCatResponseFromJSON;
|
|
95593
96307
|
exports.linkToJSON = linkToJSON;
|
|
96308
|
+
exports.listBalancesIntervalUnionFromJSON = listBalancesIntervalUnionFromJSON;
|
|
96309
|
+
exports.listBalancesListFromJSON = listBalancesListFromJSON;
|
|
96310
|
+
exports.listBalancesParamsToJSON = listBalancesParamsToJSON;
|
|
96311
|
+
exports.listBalancesPriceFromJSON = listBalancesPriceFromJSON;
|
|
96312
|
+
exports.listBalancesResetFromJSON = listBalancesResetFromJSON;
|
|
96313
|
+
exports.listBalancesResponseFromJSON = listBalancesResponseFromJSON;
|
|
96314
|
+
exports.listBalancesRolloverFromJSON = listBalancesRolloverFromJSON;
|
|
96315
|
+
exports.listBalancesTierFromJSON = listBalancesTierFromJSON;
|
|
96316
|
+
exports.listBalancesToFromJSON = listBalancesToFromJSON;
|
|
95594
96317
|
exports.listCustomersAutoTopupFromJSON = listCustomersAutoTopupFromJSON;
|
|
95595
96318
|
exports.listCustomersBillingControlsFromJSON = listCustomersBillingControlsFromJSON;
|
|
95596
96319
|
exports.listCustomersConfigFromJSON = listCustomersConfigFromJSON;
|
|
@@ -96009,6 +96732,9 @@ exports.listPlansVariantUpsertLicenseResetFromJSON = listPlansVariantUpsertLicen
|
|
|
96009
96732
|
exports.listPlansVariantUpsertLicenseRolloverFromJSON = listPlansVariantUpsertLicenseRolloverFromJSON;
|
|
96010
96733
|
exports.listPlansVariantUpsertLicenseThresholdBillingFromJSON = listPlansVariantUpsertLicenseThresholdBillingFromJSON;
|
|
96011
96734
|
exports.listPlansVariantUpsertLicenseTierAdditionalCurrencyFromJSON = listPlansVariantUpsertLicenseTierAdditionalCurrencyFromJSON;
|
|
96735
|
+
exports.listPurchasesListFromJSON = listPurchasesListFromJSON;
|
|
96736
|
+
exports.listPurchasesParamsToJSON = listPurchasesParamsToJSON;
|
|
96737
|
+
exports.listPurchasesResponseFromJSON = listPurchasesResponseFromJSON;
|
|
96012
96738
|
exports.listReferralProgramsListFromJSON = listReferralProgramsListFromJSON;
|
|
96013
96739
|
exports.listReferralProgramsParamsToJSON = listReferralProgramsParamsToJSON;
|
|
96014
96740
|
exports.listReferralProgramsResponseFromJSON = listReferralProgramsResponseFromJSON;
|
|
@@ -96023,6 +96749,9 @@ exports.listRewardsResponseFromJSON = listRewardsResponseFromJSON;
|
|
|
96023
96749
|
exports.listSandboxesListFromJSON = listSandboxesListFromJSON;
|
|
96024
96750
|
exports.listSandboxesParamsToJSON = listSandboxesParamsToJSON;
|
|
96025
96751
|
exports.listSandboxesResponseFromJSON = listSandboxesResponseFromJSON;
|
|
96752
|
+
exports.listSubscriptionsListFromJSON = listSubscriptionsListFromJSON;
|
|
96753
|
+
exports.listSubscriptionsParamsToJSON = listSubscriptionsParamsToJSON;
|
|
96754
|
+
exports.listSubscriptionsResponseFromJSON = listSubscriptionsResponseFromJSON;
|
|
96026
96755
|
exports.listWebhooksListFromJSON = listWebhooksListFromJSON;
|
|
96027
96756
|
exports.listWebhooksParamsToJSON = listWebhooksParamsToJSON;
|
|
96028
96757
|
exports.listWebhooksResponseFromJSON = listWebhooksResponseFromJSON;
|