@scaleway/sdk-vpc 2.10.1 → 2.12.0

package/dist/v2/marshalling.gen.js

@@ -0,0 +1,293 @@
+import { isJSONObject, unmarshalArrayOfObject, unmarshalDate } from "@scaleway/sdk-client";
+import randomName from "@scaleway/random-name";
+//#region src/v2/marshalling.gen.ts
+const unmarshalSubnet = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'Subnet' failed as data isn't a dictionary.`);
+	return {
+		createdAt: unmarshalDate(data.created_at),
+		id: data.id,
+		privateNetworkId: data.private_network_id,
+		projectId: data.project_id,
+		region: data.region,
+		subnet: data.subnet,
+		updatedAt: unmarshalDate(data.updated_at),
+		vpcId: data.vpc_id
+	};
+};
+const unmarshalPrivateNetwork = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'PrivateNetwork' failed as data isn't a dictionary.`);
+	return {
+		createdAt: unmarshalDate(data.created_at),
+		defaultRoutePropagationEnabled: data.default_route_propagation_enabled,
+		dhcpEnabled: data.dhcp_enabled,
+		hasS3Integration: data.has_s3_integration,
+		id: data.id,
+		name: data.name,
+		organizationId: data.organization_id,
+		projectId: data.project_id,
+		region: data.region,
+		subnets: unmarshalArrayOfObject(data.subnets, unmarshalSubnet),
+		tags: data.tags,
+		updatedAt: unmarshalDate(data.updated_at),
+		vpcId: data.vpc_id
+	};
+};
+const unmarshalRoute = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'Route' failed as data isn't a dictionary.`);
+	return {
+		createdAt: unmarshalDate(data.created_at),
+		description: data.description,
+		destination: data.destination,
+		id: data.id,
+		isReadOnly: data.is_read_only,
+		nexthopPrivateNetworkId: data.nexthop_private_network_id,
+		nexthopResourceId: data.nexthop_resource_id,
+		nexthopVpcConnectorId: data.nexthop_vpc_connector_id,
+		region: data.region,
+		tags: data.tags,
+		type: data.type ? data.type : void 0,
+		updatedAt: unmarshalDate(data.updated_at),
+		vpcId: data.vpc_id
+	};
+};
+const unmarshalIngressRule = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'IngressRule' failed as data isn't a dictionary.`);
+	return {
+		createdAt: unmarshalDate(data.created_at),
+		description: data.description,
+		id: data.id,
+		isIpv6: data.is_ipv6,
+		nexthopPrivateNetworkId: data.nexthop_private_network_id,
+		nexthopResourceIp: data.nexthop_resource_ip,
+		organizationId: data.organization_id,
+		projectId: data.project_id,
+		region: data.region,
+		source: data.source,
+		tags: data.tags,
+		updatedAt: unmarshalDate(data.updated_at),
+		vpcId: data.vpc_id
+	};
+};
+const unmarshalVPCConnectorPeerInfo = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'VPCConnectorPeerInfo' failed as data isn't a dictionary.`);
+	return {
+		organizationId: data.organization_id,
+		projectId: data.project_id,
+		vpcName: data.vpc_name
+	};
+};
+const unmarshalVPCConnector = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'VPCConnector' failed as data isn't a dictionary.`);
+	return {
+		createdAt: unmarshalDate(data.created_at),
+		id: data.id,
+		name: data.name,
+		organizationId: data.organization_id,
+		peerInfo: data.peer_info ? unmarshalVPCConnectorPeerInfo(data.peer_info) : void 0,
+		projectId: data.project_id,
+		region: data.region,
+		status: data.status,
+		tags: data.tags,
+		targetVpcId: data.target_vpc_id,
+		updatedAt: unmarshalDate(data.updated_at),
+		vpcId: data.vpc_id
+	};
+};
+const unmarshalVPC = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'VPC' failed as data isn't a dictionary.`);
+	return {
+		createdAt: unmarshalDate(data.created_at),
+		customRoutesPropagationEnabled: data.custom_routes_propagation_enabled,
+		id: data.id,
+		isDefault: data.is_default,
+		name: data.name,
+		organizationId: data.organization_id,
+		privateNetworkCount: data.private_network_count,
+		projectId: data.project_id,
+		region: data.region,
+		routingEnabled: data.routing_enabled,
+		s3IntegrationEnabled: data.s3_integration_enabled,
+		tags: data.tags,
+		transitivityEnabled: data.transitivity_enabled,
+		updatedAt: unmarshalDate(data.updated_at)
+	};
+};
+const unmarshalAddPrivateNetworkS3EndpointResponse = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'AddPrivateNetworkS3EndpointResponse' failed as data isn't a dictionary.`);
+	return {
+		privateNetworkIds: data.private_network_ids,
+		vpcId: data.vpc_id
+	};
+};
+const unmarshalAclRule = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'AclRule' failed as data isn't a dictionary.`);
+	return {
+		action: data.action,
+		description: data.description,
+		destination: data.destination,
+		dstPortHigh: data.dst_port_high,
+		dstPortLow: data.dst_port_low,
+		protocol: data.protocol,
+		source: data.source,
+		srcPortHigh: data.src_port_high,
+		srcPortLow: data.src_port_low
+	};
+};
+const unmarshalGetAclResponse = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'GetAclResponse' failed as data isn't a dictionary.`);
+	return {
+		defaultPolicy: data.default_policy,
+		rules: unmarshalArrayOfObject(data.rules, unmarshalAclRule)
+	};
+};
+const unmarshalListIngressRulesResponse = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'ListIngressRulesResponse' failed as data isn't a dictionary.`);
+	return {
+		rules: unmarshalArrayOfObject(data.rules, unmarshalIngressRule),
+		totalCount: data.total_count
+	};
+};
+const unmarshalListPrivateNetworksResponse = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'ListPrivateNetworksResponse' failed as data isn't a dictionary.`);
+	return {
+		privateNetworks: unmarshalArrayOfObject(data.private_networks, unmarshalPrivateNetwork),
+		totalCount: data.total_count
+	};
+};
+const unmarshalListSubnetOverlapsResponseSubnetOverlap = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'ListSubnetOverlapsResponseSubnetOverlap' failed as data isn't a dictionary.`);
+	return {
+		subnet: data.subnet,
+		subnetId: data.subnet_id,
+		targetSubnet: data.target_subnet,
+		targetSubnetId: data.target_subnet_id
+	};
+};
+const unmarshalListSubnetOverlapsResponse = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'ListSubnetOverlapsResponse' failed as data isn't a dictionary.`);
+	return {
+		subnetOverlaps: unmarshalArrayOfObject(data.subnet_overlaps, unmarshalListSubnetOverlapsResponseSubnetOverlap),
+		totalCount: data.total_count
+	};
+};
+const unmarshalListSubnetsResponse = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'ListSubnetsResponse' failed as data isn't a dictionary.`);
+	return {
+		subnets: unmarshalArrayOfObject(data.subnets, unmarshalSubnet),
+		totalCount: data.total_count
+	};
+};
+const unmarshalListVPCConnectorsResponse = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'ListVPCConnectorsResponse' failed as data isn't a dictionary.`);
+	return {
+		totalCount: data.total_count,
+		vpcConnectors: unmarshalArrayOfObject(data.vpc_connectors, unmarshalVPCConnector)
+	};
+};
+const unmarshalListVPCsResponse = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'ListVPCsResponse' failed as data isn't a dictionary.`);
+	return {
+		totalCount: data.total_count,
+		vpcs: unmarshalArrayOfObject(data.vpcs, unmarshalVPC)
+	};
+};
+const unmarshalSetAclResponse = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'SetAclResponse' failed as data isn't a dictionary.`);
+	return {
+		defaultPolicy: data.default_policy,
+		rules: unmarshalArrayOfObject(data.rules, unmarshalAclRule)
+	};
+};
+const unmarshalSetPrivateNetworksS3EndpointResponse = (data) => {
+	if (!isJSONObject(data)) throw new TypeError(`Unmarshalling the type 'SetPrivateNetworksS3EndpointResponse' failed as data isn't a dictionary.`);
+	return {
+		privateNetworkIds: data.private_network_ids,
+		vpcId: data.vpc_id
+	};
+};
+const marshalAddPrivateNetworkS3EndpointRequest = (request, defaults) => ({ private_network_id: request.privateNetworkId });
+const marshalCreateIngressRuleRequest = (request, defaults) => ({
+	description: request.description,
+	nexthop_private_network_id: request.nexthopPrivateNetworkId,
+	nexthop_resource_ip: request.nexthopResourceIp,
+	source: request.source,
+	tags: request.tags,
+	vpc_id: request.vpcId
+});
+const marshalCreatePrivateNetworkRequest = (request, defaults) => ({
+	default_route_propagation_enabled: request.defaultRoutePropagationEnabled,
+	name: request.name || randomName("pn"),
+	project_id: request.projectId ?? defaults.defaultProjectId,
+	subnets: request.subnets,
+	tags: request.tags,
+	vpc_id: request.vpcId
+});
+const marshalCreateRouteRequest = (request, defaults) => ({
+	description: request.description,
+	destination: request.destination,
+	nexthop_private_network_id: request.nexthopPrivateNetworkId,
+	nexthop_resource_id: request.nexthopResourceId,
+	nexthop_vpc_connector_id: request.nexthopVpcConnectorId,
+	tags: request.tags,
+	vpc_id: request.vpcId
+});
+const marshalCreateVPCConnectorRequest = (request, defaults) => ({
+	name: request.name || randomName("VPCConnector"),
+	tags: request.tags,
+	target_vpc_id: request.targetVpcId,
+	vpc_id: request.vpcId
+});
+const marshalCreateVPCRequest = (request, defaults) => ({
+	enable_routing: request.enableRouting,
+	enable_transitivity: request.enableTransitivity,
+	name: request.name || randomName("vpc"),
+	project_id: request.projectId ?? defaults.defaultProjectId,
+	tags: request.tags
+});
+const marshalAclRule = (request, defaults) => ({
+	action: request.action,
+	description: request.description,
+	destination: request.destination,
+	dst_port_high: request.dstPortHigh,
+	dst_port_low: request.dstPortLow,
+	protocol: request.protocol,
+	source: request.source,
+	src_port_high: request.srcPortHigh,
+	src_port_low: request.srcPortLow
+});
+const marshalSetAclRequest = (request, defaults) => ({
+	default_policy: request.defaultPolicy,
+	is_ipv6: request.isIpv6,
+	rules: request.rules.map((elt) => marshalAclRule(elt, defaults))
+});
+const marshalSetPrivateNetworksS3EndpointRequest = (request, defaults) => ({ private_network_ids: request.privateNetworkIds });
+const marshalUpdateIngressRuleRequest = (request, defaults) => ({
+	description: request.description,
+	nexthop_private_network_id: request.nexthopPrivateNetworkId,
+	nexthop_resource_ip: request.nexthopResourceIp,
+	source: request.source,
+	tags: request.tags
+});
+const marshalUpdatePrivateNetworkRequest = (request, defaults) => ({
+	default_route_propagation_enabled: request.defaultRoutePropagationEnabled,
+	name: request.name,
+	tags: request.tags
+});
+const marshalUpdateRouteRequest = (request, defaults) => ({
+	description: request.description,
+	destination: request.destination,
+	nexthop_private_network_id: request.nexthopPrivateNetworkId,
+	nexthop_resource_id: request.nexthopResourceId,
+	nexthop_vpc_connector_id: request.nexthopVpcConnectorId,
+	tags: request.tags
+});
+const marshalUpdateVPCConnectorRequest = (request, defaults) => ({
+	name: request.name,
+	tags: request.tags
+});
+const marshalUpdateVPCRequest = (request, defaults) => ({
+	name: request.name,
+	tags: request.tags
+});
+//#endregion
+export { marshalAddPrivateNetworkS3EndpointRequest, marshalCreateIngressRuleRequest, marshalCreatePrivateNetworkRequest, marshalCreateRouteRequest, marshalCreateVPCConnectorRequest, marshalCreateVPCRequest, marshalSetAclRequest, marshalSetPrivateNetworksS3EndpointRequest, marshalUpdateIngressRuleRequest, marshalUpdatePrivateNetworkRequest, marshalUpdateRouteRequest, marshalUpdateVPCConnectorRequest, marshalUpdateVPCRequest, unmarshalAddPrivateNetworkS3EndpointResponse, unmarshalGetAclResponse, unmarshalIngressRule, unmarshalListIngressRulesResponse, unmarshalListPrivateNetworksResponse, unmarshalListSubnetOverlapsResponse, unmarshalListSubnetsResponse, unmarshalListVPCConnectorsResponse, unmarshalListVPCsResponse, unmarshalPrivateNetwork, unmarshalRoute, unmarshalSetAclResponse, unmarshalSetPrivateNetworksS3EndpointResponse, unmarshalVPC, unmarshalVPCConnector };

package/dist/v2/metadata.gen.d.ts

@@ -0,0 +1,130 @@
+export declare const queriesMetadata: {
+    readonly namespace: 'vpc';
+    readonly version: 'v2';
+    readonly folderName: 'vpcv2';
+    readonly services: readonly [{
+        readonly apiClass: 'API';
+        readonly methods: readonly [{
+            readonly methodName: 'listVPCs';
+            readonly protoName: 'ListVPCs';
+            readonly paramsType: 'ListVPCsRequest';
+            readonly returnType: 'ListVPCsResponse';
+            readonly isList: true;
+            readonly paginationType: 'offset';
+            readonly pageParamKey: 'page';
+            readonly listItemType: 'VPC';
+            readonly isPrivate: false;
+            readonly description: '"';
+        }, {
+            readonly methodName: 'getVPC';
+            readonly protoName: 'GetVPC';
+            readonly paramsType: 'GetVPCRequest';
+            readonly returnType: 'VPC';
+            readonly isList: false;
+            readonly paginationType: 'none';
+            readonly isPrivate: false;
+            readonly description: '"';
+        }, {
+            readonly methodName: 'listPrivateNetworks';
+            readonly protoName: 'ListPrivateNetworks';
+            readonly paramsType: 'ListPrivateNetworksRequest';
+            readonly returnType: 'ListPrivateNetworksResponse';
+            readonly isList: true;
+            readonly paginationType: 'offset';
+            readonly pageParamKey: 'page';
+            readonly listItemType: 'PrivateNetwork';
+            readonly isPrivate: false;
+            readonly description: '"';
+        }, {
+            readonly methodName: 'getPrivateNetwork';
+            readonly protoName: 'GetPrivateNetwork';
+            readonly paramsType: 'GetPrivateNetworkRequest';
+            readonly returnType: 'PrivateNetwork';
+            readonly isList: false;
+            readonly paginationType: 'none';
+            readonly isPrivate: false;
+            readonly description: '"';
+        }, {
+            readonly methodName: 'listSubnets';
+            readonly protoName: 'ListSubnets';
+            readonly paramsType: 'ListSubnetsRequest';
+            readonly returnType: 'ListSubnetsResponse';
+            readonly isList: true;
+            readonly paginationType: 'offset';
+            readonly pageParamKey: 'page';
+            readonly listItemType: 'Subnet';
+            readonly isPrivate: false;
+            readonly description: '"';
+        }, {
+            readonly methodName: 'getRoute';
+            readonly protoName: 'GetRoute';
+            readonly paramsType: 'GetRouteRequest';
+            readonly returnType: 'Route';
+            readonly isList: false;
+            readonly paginationType: 'none';
+            readonly isPrivate: false;
+            readonly description: '"';
+        }, {
+            readonly methodName: 'getAcl';
+            readonly protoName: 'GetAcl';
+            readonly paramsType: 'GetAclRequest';
+            readonly returnType: 'GetAclResponse';
+            readonly isList: false;
+            readonly paginationType: 'none';
+            readonly isPrivate: false;
+            readonly description: '"';
+        }, {
+            readonly methodName: 'listVPCConnectors';
+            readonly protoName: 'ListVPCConnectors';
+            readonly paramsType: 'ListVPCConnectorsRequest';
+            readonly returnType: 'ListVPCConnectorsResponse';
+            readonly isList: true;
+            readonly paginationType: 'offset';
+            readonly pageParamKey: 'page';
+            readonly listItemType: 'VPCConnector';
+            readonly isPrivate: false;
+            readonly description: '"';
+        }, {
+            readonly methodName: 'getVPCConnector';
+            readonly protoName: 'GetVPCConnector';
+            readonly paramsType: 'GetVPCConnectorRequest';
+            readonly returnType: 'VPCConnector';
+            readonly isList: false;
+            readonly paginationType: 'none';
+            readonly isPrivate: false;
+            readonly description: '"';
+        }, {
+            readonly methodName: 'listSubnetOverlaps';
+            readonly protoName: 'ListSubnetOverlaps';
+            readonly paramsType: 'ListSubnetOverlapsRequest';
+            readonly returnType: 'ListSubnetOverlapsResponse';
+            readonly isList: true;
+            readonly paginationType: 'offset';
+            readonly pageParamKey: 'page';
+            readonly listItemType: 'ListSubnetOverlapsResponseSubnetOverlap';
+            readonly isPrivate: false;
+            readonly description: '"';
+        }, {
+            readonly methodName: 'listIngressRules';
+            readonly protoName: 'ListIngressRules';
+            readonly paramsType: 'ListIngressRulesRequest';
+            readonly returnType: 'ListIngressRulesResponse';
+            readonly isList: true;
+            readonly paginationType: 'offset';
+            readonly pageParamKey: 'page';
+            readonly listItemType: 'IngressRule';
+            readonly isPrivate: false;
+            readonly description: '"';
+        }, {
+            readonly methodName: 'getIngressRule';
+            readonly protoName: 'GetIngressRule';
+            readonly paramsType: 'GetIngressRuleRequest';
+            readonly returnType: 'IngressRule';
+            readonly isList: false;
+            readonly paginationType: 'none';
+            readonly isPrivate: false;
+            readonly description: '"';
+        }];
+    }];
+};
+export type QueriesMetadata = typeof queriesMetadata;

package/dist/v2/metadata.gen.js

@@ -0,0 +1,145 @@
+//#region src/v2/metadata.gen.ts
+const queriesMetadata = {
+	namespace: "vpc",
+	version: "v2",
+	folderName: "vpcv2",
+	services: [{
+		apiClass: "API",
+		methods: [
+			{
+				methodName: "listVPCs",
+				protoName: "ListVPCs",
+				paramsType: "ListVPCsRequest",
+				returnType: "ListVPCsResponse",
+				isList: true,
+				paginationType: "offset",
+				pageParamKey: "page",
+				listItemType: "VPC",
+				isPrivate: false,
+				description: "\""
+			},
+			{
+				methodName: "getVPC",
+				protoName: "GetVPC",
+				paramsType: "GetVPCRequest",
+				returnType: "VPC",
+				isList: false,
+				paginationType: "none",
+				isPrivate: false,
+				description: "\""
+			},
+			{
+				methodName: "listPrivateNetworks",
+				protoName: "ListPrivateNetworks",
+				paramsType: "ListPrivateNetworksRequest",
+				returnType: "ListPrivateNetworksResponse",
+				isList: true,
+				paginationType: "offset",
+				pageParamKey: "page",
+				listItemType: "PrivateNetwork",
+				isPrivate: false,
+				description: "\""
+			},
+			{
+				methodName: "getPrivateNetwork",
+				protoName: "GetPrivateNetwork",
+				paramsType: "GetPrivateNetworkRequest",
+				returnType: "PrivateNetwork",
+				isList: false,
+				paginationType: "none",
+				isPrivate: false,
+				description: "\""
+			},
+			{
+				methodName: "listSubnets",
+				protoName: "ListSubnets",
+				paramsType: "ListSubnetsRequest",
+				returnType: "ListSubnetsResponse",
+				isList: true,
+				paginationType: "offset",
+				pageParamKey: "page",
+				listItemType: "Subnet",
+				isPrivate: false,
+				description: "\""
+			},
+			{
+				methodName: "getRoute",
+				protoName: "GetRoute",
+				paramsType: "GetRouteRequest",
+				returnType: "Route",
+				isList: false,
+				paginationType: "none",
+				isPrivate: false,
+				description: "\""
+			},
+			{
+				methodName: "getAcl",
+				protoName: "GetAcl",
+				paramsType: "GetAclRequest",
+				returnType: "GetAclResponse",
+				isList: false,
+				paginationType: "none",
+				isPrivate: false,
+				description: "\""
+			},
+			{
+				methodName: "listVPCConnectors",
+				protoName: "ListVPCConnectors",
+				paramsType: "ListVPCConnectorsRequest",
+				returnType: "ListVPCConnectorsResponse",
+				isList: true,
+				paginationType: "offset",
+				pageParamKey: "page",
+				listItemType: "VPCConnector",
+				isPrivate: false,
+				description: "\""
+			},
+			{
+				methodName: "getVPCConnector",
+				protoName: "GetVPCConnector",
+				paramsType: "GetVPCConnectorRequest",
+				returnType: "VPCConnector",
+				isList: false,
+				paginationType: "none",
+				isPrivate: false,
+				description: "\""
+			},
+			{
+				methodName: "listSubnetOverlaps",
+				protoName: "ListSubnetOverlaps",
+				paramsType: "ListSubnetOverlapsRequest",
+				returnType: "ListSubnetOverlapsResponse",
+				isList: true,
+				paginationType: "offset",
+				pageParamKey: "page",
+				listItemType: "ListSubnetOverlapsResponseSubnetOverlap",
+				isPrivate: false,
+				description: "\""
+			},
+			{
+				methodName: "listIngressRules",
+				protoName: "ListIngressRules",
+				paramsType: "ListIngressRulesRequest",
+				returnType: "ListIngressRulesResponse",
+				isList: true,
+				paginationType: "offset",
+				pageParamKey: "page",
+				listItemType: "IngressRule",
+				isPrivate: false,
+				description: "\""
+			},
+			{
+				methodName: "getIngressRule",
+				protoName: "GetIngressRule",
+				paramsType: "GetIngressRuleRequest",
+				returnType: "IngressRule",
+				isList: false,
+				paginationType: "none",
+				isPrivate: false,
+				description: "\""
+			}
+		]
+	}]
+};
+//#endregion
+export { queriesMetadata };