-- squawk-ignore-file
-- pg version: 18.2
-- update via:
--   cargo xtask sync-builtins

create schema pg_temp;

create schema information_schema;

-- system catalog schema
create schema pg_catalog;

-- standard public schema
create schema public;

-- size: 4, align: 4
create type information_schema.cardinal_number;

-- size: -1, align: 4
create type information_schema.character_data;

-- size: 64, align: 1
create type information_schema.sql_identifier;

-- size: 8, align: 8
create type information_schema.time_stamp;

-- size: -1, align: 4
create type information_schema.yes_or_no;

-- access control list
-- size: 16, align: 8
create type pg_catalog.aclitem;

-- pseudo-type representing any type
-- size: 4, align: 4
create type pg_catalog.any;

-- pseudo-type representing a polymorphic array type
-- size: -1, align: 8
create type pg_catalog.anyarray;

-- pseudo-type representing a polymorphic common type
-- size: 4, align: 4
create type pg_catalog.anycompatible;

-- pseudo-type representing an array of polymorphic common type elements
-- size: -1, align: 8
create type pg_catalog.anycompatiblearray;

-- pseudo-type representing a multirange over a polymorphic common type
-- size: -1, align: 8
create type pg_catalog.anycompatiblemultirange;

-- pseudo-type representing a polymorphic common type that is not an array
-- size: 4, align: 4
create type pg_catalog.anycompatiblenonarray;

-- pseudo-type representing a range over a polymorphic common type
-- size: -1, align: 8
create type pg_catalog.anycompatiblerange;

-- pseudo-type representing a polymorphic base type
-- size: 4, align: 4
create type pg_catalog.anyelement;

-- pseudo-type representing a polymorphic base type that is an enum
-- size: 4, align: 4
create type pg_catalog.anyenum;

-- pseudo-type representing a polymorphic base type that is a multirange
-- size: -1, align: 8
create type pg_catalog.anymultirange;

-- pseudo-type representing a polymorphic base type that is not an array
-- size: 4, align: 4
create type pg_catalog.anynonarray;

-- pseudo-type representing a range over a polymorphic base type
-- size: -1, align: 8
create type pg_catalog.anyrange;

-- fixed-length bit string
-- size: -1, align: 4
create type pg_catalog.bit;

-- boolean, format 't'/'f'
-- size: 1, align: 1
create type pg_catalog.bool;

-- geometric box, format 'lower left point,upper right point'
-- size: 32, align: 8
create type pg_catalog.box;

-- 'char(length)' blank-padded string, fixed storage length
-- size: -1, align: 4
create type pg_catalog.bpchar;

-- variable-length string, binary values escaped
-- size: -1, align: 4
create type pg_catalog.bytea;

-- single character
-- size: 1, align: 1
create type pg_catalog.char;

-- command identifier type, sequence in transaction id
-- size: 4, align: 4
create type pg_catalog.cid;

-- network IP address/netmask, network address
-- size: -1, align: 4
create type pg_catalog.cidr;

-- geometric circle, format '<center point,radius>'
-- size: 24, align: 8
create type pg_catalog.circle;

-- C-style string
-- size: -2, align: 1
create type pg_catalog.cstring;

-- date
-- size: 4, align: 4
create type pg_catalog.date;

-- pseudo-type for the result of an event trigger function
-- size: 4, align: 4
create type pg_catalog.event_trigger;

-- pseudo-type for the result of an FDW handler function
-- size: 4, align: 4
create type pg_catalog.fdw_handler;

-- single-precision floating point number, 4-byte storage
-- size: 4, align: 4
create type pg_catalog.float4;

-- double-precision floating point number, 8-byte storage
-- size: 8, align: 8
create type pg_catalog.float8;

-- GiST index internal text representation for text search
-- size: -1, align: 4
create type pg_catalog.gtsvector;

-- pseudo-type for the result of an index AM handler function
-- size: 4, align: 4
create type pg_catalog.index_am_handler;

-- IP address/netmask, host address, netmask optional
-- size: -1, align: 4
create type pg_catalog.inet;

-- -32 thousand to 32 thousand, 2-byte storage
-- size: 2, align: 2
create type pg_catalog.int2;

-- array of int2, used in system tables
-- size: -1, align: 4
create type pg_catalog.int2vector;

-- -2 billion to 2 billion integer, 4-byte storage
-- size: 4, align: 4
create type pg_catalog.int4;

-- ~18 digit integer, 8-byte storage
-- size: 8, align: 8
create type pg_catalog.int8;

-- pseudo-type representing an internal data structure
-- size: 8, align: 8
create type pg_catalog.internal;

-- time interval, format 'number units ...'
-- size: 16, align: 8
create type pg_catalog.interval;

-- JSON stored as text
-- size: -1, align: 4
create type pg_catalog.json;

-- Binary JSON
-- size: -1, align: 4
create type pg_catalog.jsonb;

-- JSON path
-- size: -1, align: 4
create type pg_catalog.jsonpath;

-- pseudo-type for the result of a language handler function
-- size: 4, align: 4
create type pg_catalog.language_handler;

-- geometric line, formats '{A,B,C}'/'[point1,point2]'
-- size: 24, align: 8
create type pg_catalog.line;

-- geometric line segment, format '[point1,point2]'
-- size: 32, align: 8
create type pg_catalog.lseg;

-- XX:XX:XX:XX:XX:XX, MAC address
-- size: 6, align: 4
create type pg_catalog.macaddr;

-- XX:XX:XX:XX:XX:XX:XX:XX, MAC address
-- size: 8, align: 4
create type pg_catalog.macaddr8;

-- monetary amounts, $d,ddd.cc
-- size: 8, align: 8
create type pg_catalog.money;

-- 63-byte type for storing system identifiers
-- size: 64, align: 1
create type pg_catalog.name;

-- 'numeric(precision, scale)' arbitrary precision number
-- size: -1, align: 4
create type pg_catalog.numeric;

-- object identifier(oid), maximum 4 billion
-- size: 4, align: 4
create type pg_catalog.oid;

-- array of oids, used in system tables
-- size: -1, align: 4
create type pg_catalog.oidvector;

-- geometric path, format '(point1,...)'
-- size: -1, align: 8
create type pg_catalog.path;

-- pseudo-type representing BRIN bloom summary
-- size: -1, align: 4
create type pg_catalog.pg_brin_bloom_summary;

-- pseudo-type representing BRIN minmax-multi summary
-- size: -1, align: 4
create type pg_catalog.pg_brin_minmax_multi_summary;

-- internal type for passing CollectedCommand
-- size: 8, align: 8
create type pg_catalog.pg_ddl_command;

-- multivariate dependencies
-- size: -1, align: 4
create type pg_catalog.pg_dependencies;

-- PostgreSQL LSN
-- size: 8, align: 8
create type pg_catalog.pg_lsn;

-- multivariate MCV list
-- size: -1, align: 4
create type pg_catalog.pg_mcv_list;

-- multivariate ndistinct coefficients
-- size: -1, align: 4
create type pg_catalog.pg_ndistinct;

-- string representing an internal node tree
-- size: -1, align: 4
create type pg_catalog.pg_node_tree;

-- transaction snapshot
-- size: -1, align: 8
create type pg_catalog.pg_snapshot;

-- geometric point, format '(x,y)'
-- size: 16, align: 8
create type pg_catalog.point;

-- geometric polygon, format '(point1,...)'
-- size: -1, align: 8
create type pg_catalog.polygon;

-- pseudo-type representing any composite type
-- size: -1, align: 8
create type pg_catalog.record;

-- reference to cursor (portal name)
-- size: -1, align: 4
create type pg_catalog.refcursor;

-- registered class
-- size: 4, align: 4
create type pg_catalog.regclass;

-- registered collation
-- size: 4, align: 4
create type pg_catalog.regcollation;

-- registered text search configuration
-- size: 4, align: 4
create type pg_catalog.regconfig;

-- registered text search dictionary
-- size: 4, align: 4
create type pg_catalog.regdictionary;

-- registered namespace
-- size: 4, align: 4
create type pg_catalog.regnamespace;

-- registered operator
-- size: 4, align: 4
create type pg_catalog.regoper;

-- registered operator (with args)
-- size: 4, align: 4
create type pg_catalog.regoperator;

-- registered procedure
-- size: 4, align: 4
create type pg_catalog.regproc;

-- registered procedure (with args)
-- size: 4, align: 4
create type pg_catalog.regprocedure;

-- registered role
-- size: 4, align: 4
create type pg_catalog.regrole;

-- registered type
-- size: 4, align: 4
create type pg_catalog.regtype;

-- pseudo-type for the result of a table AM handler function
-- size: 4, align: 4
create type pg_catalog.table_am_handler;

-- variable-length string, no limit specified
-- size: -1, align: 4
create type pg_catalog.text;

-- tuple physical location, format '(block,offset)'
-- size: 6, align: 2
create type pg_catalog.tid;

-- time of day
-- size: 8, align: 8
create type pg_catalog.time;

-- date and time
-- size: 8, align: 8
create type pg_catalog.timestamp;

-- date and time with time zone
-- size: 8, align: 8
create type pg_catalog.timestamptz;

-- time of day with time zone
-- size: 12, align: 8
create type pg_catalog.timetz;

-- pseudo-type for the result of a trigger function
-- size: 4, align: 4
create type pg_catalog.trigger;

-- pseudo-type for the result of a tablesample method function
-- size: 4, align: 4
create type pg_catalog.tsm_handler;

-- query representation for text search
-- size: -1, align: 4
create type pg_catalog.tsquery;

-- text representation for text search
-- size: -1, align: 4
create type pg_catalog.tsvector;

-- transaction snapshot
-- size: -1, align: 8
create type pg_catalog.txid_snapshot;

-- pseudo-type representing an undetermined type
-- size: -2, align: 1
create type pg_catalog.unknown;

-- UUID
-- size: 16, align: 1
create type pg_catalog.uuid;

-- variable-length bit string
-- size: -1, align: 4
create type pg_catalog.varbit;

-- 'varchar(length)' non-blank-padded string, variable storage length
-- size: -1, align: 4
create type pg_catalog.varchar;

-- pseudo-type for the result of a function with no real result
-- size: 4, align: 4
create type pg_catalog.void;

-- transaction id
-- size: 4, align: 4
create type pg_catalog.xid;

-- full transaction id
-- size: 8, align: 8
create type pg_catalog.xid8;

-- XML content
-- size: -1, align: 4
create type pg_catalog.xml;

-- range of dates
-- size: -1, align: 4
create type pg_catalog.daterange as range (subtype = date);

-- range of integers
-- size: -1, align: 4
create type pg_catalog.int4range as range (subtype = integer);

-- range of bigints
-- size: -1, align: 8
create type pg_catalog.int8range as range (subtype = bigint);

-- range of numerics
-- size: -1, align: 4
create type pg_catalog.numrange as range (subtype = numeric);

-- range of timestamps without time zone
-- size: -1, align: 8
create type pg_catalog.tsrange as range (subtype = timestamp without time zone);

-- range of timestamps with time zone
-- size: -1, align: 8
create type pg_catalog.tstzrange as range (subtype = timestamp with time zone);

create table information_schema.sql_features (
  feature_id information_schema.character_data,
  feature_name information_schema.character_data,
  sub_feature_id information_schema.character_data,
  sub_feature_name information_schema.character_data,
  is_supported information_schema.yes_or_no,
  is_verified_by information_schema.character_data,
  comments information_schema.character_data
);

create table information_schema.sql_implementation_info (
  implementation_info_id information_schema.character_data,
  implementation_info_name information_schema.character_data,
  integer_value information_schema.cardinal_number,
  character_value information_schema.character_data,
  comments information_schema.character_data
);

create table information_schema.sql_parts (
  feature_id information_schema.character_data,
  feature_name information_schema.character_data,
  is_supported information_schema.yes_or_no,
  is_verified_by information_schema.character_data,
  comments information_schema.character_data
);

create table information_schema.sql_sizing (
  sizing_id information_schema.cardinal_number,
  sizing_name information_schema.character_data,
  supported_value information_schema.cardinal_number,
  comments information_schema.character_data
);

create table pg_catalog.pg_aggregate (
  aggfnoid regproc,
  aggkind "char",
  aggnumdirectargs smallint,
  aggtransfn regproc,
  aggfinalfn regproc,
  aggcombinefn regproc,
  aggserialfn regproc,
  aggdeserialfn regproc,
  aggmtransfn regproc,
  aggminvtransfn regproc,
  aggmfinalfn regproc,
  aggfinalextra boolean,
  aggmfinalextra boolean,
  aggfinalmodify "char",
  aggmfinalmodify "char",
  aggsortop oid,
  aggtranstype oid,
  aggtransspace integer,
  aggmtranstype oid,
  aggmtransspace integer,
  agginitval text,
  aggminitval text
);

create table pg_catalog.pg_am (
  oid oid,
  amname name,
  amhandler regproc,
  amtype "char"
);

create table pg_catalog.pg_amop (
  oid oid,
  amopfamily oid,
  amoplefttype oid,
  amoprighttype oid,
  amopstrategy smallint,
  amoppurpose "char",
  amopopr oid,
  amopmethod oid,
  amopsortfamily oid
);

create table pg_catalog.pg_amproc (
  oid oid,
  amprocfamily oid,
  amproclefttype oid,
  amprocrighttype oid,
  amprocnum smallint,
  amproc regproc
);

create table pg_catalog.pg_attrdef (
  oid oid,
  adrelid oid,
  adnum smallint,
  adbin pg_node_tree
);

create table pg_catalog.pg_attribute (
  attrelid oid,
  attname name,
  atttypid oid,
  attlen smallint,
  attnum smallint,
  atttypmod integer,
  attndims smallint,
  attbyval boolean,
  attalign "char",
  attstorage "char",
  attcompression "char",
  attnotnull boolean,
  atthasdef boolean,
  atthasmissing boolean,
  attidentity "char",
  attgenerated "char",
  attisdropped boolean,
  attislocal boolean,
  attinhcount smallint,
  attcollation oid,
  attstattarget smallint,
  attacl aclitem[],
  attoptions text[],
  attfdwoptions text[],
  attmissingval anyarray
);

create table pg_catalog.pg_auth_members (
  oid oid,
  roleid oid,
  member oid,
  grantor oid,
  admin_option boolean,
  inherit_option boolean,
  set_option boolean
);

create table pg_catalog.pg_authid (
  oid oid,
  rolname name,
  rolsuper boolean,
  rolinherit boolean,
  rolcreaterole boolean,
  rolcreatedb boolean,
  rolcanlogin boolean,
  rolreplication boolean,
  rolbypassrls boolean,
  rolconnlimit integer,
  rolpassword text,
  rolvaliduntil timestamp with time zone
);

create table pg_catalog.pg_cast (
  oid oid,
  castsource oid,
  casttarget oid,
  castfunc oid,
  castcontext "char",
  castmethod "char"
);

create table pg_catalog.pg_class (
  oid oid,
  relname name,
  relnamespace oid,
  reltype oid,
  reloftype oid,
  relowner oid,
  relam oid,
  relfilenode oid,
  reltablespace oid,
  relpages integer,
  reltuples real,
  relallvisible integer,
  relallfrozen integer,
  reltoastrelid oid,
  relhasindex boolean,
  relisshared boolean,
  relpersistence "char",
  relkind "char",
  relnatts smallint,
  relchecks smallint,
  relhasrules boolean,
  relhastriggers boolean,
  relhassubclass boolean,
  relrowsecurity boolean,
  relforcerowsecurity boolean,
  relispopulated boolean,
  relreplident "char",
  relispartition boolean,
  relrewrite oid,
  relfrozenxid xid,
  relminmxid xid,
  relacl aclitem[],
  reloptions text[],
  relpartbound pg_node_tree
);

create table pg_catalog.pg_collation (
  oid oid,
  collname name,
  collnamespace oid,
  collowner oid,
  collprovider "char",
  collisdeterministic boolean,
  collencoding integer,
  collcollate text,
  collctype text,
  colllocale text,
  collicurules text,
  collversion text
);

create table pg_catalog.pg_constraint (
  oid oid,
  conname name,
  connamespace oid,
  contype "char",
  condeferrable boolean,
  condeferred boolean,
  conenforced boolean,
  convalidated boolean,
  conrelid oid,
  contypid oid,
  conindid oid,
  conparentid oid,
  confrelid oid,
  confupdtype "char",
  confdeltype "char",
  confmatchtype "char",
  conislocal boolean,
  coninhcount smallint,
  connoinherit boolean,
  conperiod boolean,
  conkey smallint[],
  confkey smallint[],
  conpfeqop oid[],
  conppeqop oid[],
  conffeqop oid[],
  confdelsetcols smallint[],
  conexclop oid[],
  conbin pg_node_tree
);

create table pg_catalog.pg_conversion (
  oid oid,
  conname name,
  connamespace oid,
  conowner oid,
  conforencoding integer,
  contoencoding integer,
  conproc regproc,
  condefault boolean
);

create table pg_catalog.pg_database (
  oid oid,
  datname name,
  datdba oid,
  encoding integer,
  datlocprovider "char",
  datistemplate boolean,
  datallowconn boolean,
  dathasloginevt boolean,
  datconnlimit integer,
  datfrozenxid xid,
  datminmxid xid,
  dattablespace oid,
  datcollate text,
  datctype text,
  datlocale text,
  daticurules text,
  datcollversion text,
  datacl aclitem[]
);

create table pg_catalog.pg_db_role_setting (
  setdatabase oid,
  setrole oid,
  setconfig text[]
);

create table pg_catalog.pg_default_acl (
  oid oid,
  defaclrole oid,
  defaclnamespace oid,
  defaclobjtype "char",
  defaclacl aclitem[]
);

create table pg_catalog.pg_depend (
  classid oid,
  objid oid,
  objsubid integer,
  refclassid oid,
  refobjid oid,
  refobjsubid integer,
  deptype "char"
);

create table pg_catalog.pg_description (
  objoid oid,
  classoid oid,
  objsubid integer,
  description text
);

create table pg_catalog.pg_enum (
  oid oid,
  enumtypid oid,
  enumsortorder real,
  enumlabel name
);

create table pg_catalog.pg_event_trigger (
  oid oid,
  evtname name,
  evtevent name,
  evtowner oid,
  evtfoid oid,
  evtenabled "char",
  evttags text[]
);

create table pg_catalog.pg_extension (
  oid oid,
  extname name,
  extowner oid,
  extnamespace oid,
  extrelocatable boolean,
  extversion text,
  extconfig oid[],
  extcondition text[]
);

create table pg_catalog.pg_foreign_data_wrapper (
  oid oid,
  fdwname name,
  fdwowner oid,
  fdwhandler oid,
  fdwvalidator oid,
  fdwacl aclitem[],
  fdwoptions text[]
);

create table pg_catalog.pg_foreign_server (
  oid oid,
  srvname name,
  srvowner oid,
  srvfdw oid,
  srvtype text,
  srvversion text,
  srvacl aclitem[],
  srvoptions text[]
);

create table pg_catalog.pg_foreign_table (
  ftrelid oid,
  ftserver oid,
  ftoptions text[]
);

create table pg_catalog.pg_index (
  indexrelid oid,
  indrelid oid,
  indnatts smallint,
  indnkeyatts smallint,
  indisunique boolean,
  indnullsnotdistinct boolean,
  indisprimary boolean,
  indisexclusion boolean,
  indimmediate boolean,
  indisclustered boolean,
  indisvalid boolean,
  indcheckxmin boolean,
  indisready boolean,
  indislive boolean,
  indisreplident boolean,
  indkey int2vector,
  indcollation oidvector,
  indclass oidvector,
  indoption int2vector,
  indexprs pg_node_tree,
  indpred pg_node_tree
);

create table pg_catalog.pg_inherits (
  inhrelid oid,
  inhparent oid,
  inhseqno integer,
  inhdetachpending boolean
);

create table pg_catalog.pg_init_privs (
  objoid oid,
  classoid oid,
  objsubid integer,
  privtype "char",
  initprivs aclitem[]
);

create table pg_catalog.pg_language (
  oid oid,
  lanname name,
  lanowner oid,
  lanispl boolean,
  lanpltrusted boolean,
  lanplcallfoid oid,
  laninline oid,
  lanvalidator oid,
  lanacl aclitem[]
);

create table pg_catalog.pg_largeobject (
  loid oid,
  pageno integer,
  data bytea
);

create table pg_catalog.pg_largeobject_metadata (
  oid oid,
  lomowner oid,
  lomacl aclitem[]
);

create table pg_catalog.pg_namespace (
  oid oid,
  nspname name,
  nspowner oid,
  nspacl aclitem[]
);

create table pg_catalog.pg_opclass (
  oid oid,
  opcmethod oid,
  opcname name,
  opcnamespace oid,
  opcowner oid,
  opcfamily oid,
  opcintype oid,
  opcdefault boolean,
  opckeytype oid
);

create table pg_catalog.pg_operator (
  oid oid,
  oprname name,
  oprnamespace oid,
  oprowner oid,
  oprkind "char",
  oprcanmerge boolean,
  oprcanhash boolean,
  oprleft oid,
  oprright oid,
  oprresult oid,
  oprcom oid,
  oprnegate oid,
  oprcode regproc,
  oprrest regproc,
  oprjoin regproc
);

create table pg_catalog.pg_opfamily (
  oid oid,
  opfmethod oid,
  opfname name,
  opfnamespace oid,
  opfowner oid
);

create table pg_catalog.pg_parameter_acl (
  oid oid,
  parname text,
  paracl aclitem[]
);

create table pg_catalog.pg_partitioned_table (
  partrelid oid,
  partstrat "char",
  partnatts smallint,
  partdefid oid,
  partattrs int2vector,
  partclass oidvector,
  partcollation oidvector,
  partexprs pg_node_tree
);

create table pg_catalog.pg_policy (
  oid oid,
  polname name,
  polrelid oid,
  polcmd "char",
  polpermissive boolean,
  polroles oid[],
  polqual pg_node_tree,
  polwithcheck pg_node_tree
);

create table pg_catalog.pg_proc (
  oid oid,
  proname name,
  pronamespace oid,
  proowner oid,
  prolang oid,
  procost real,
  prorows real,
  provariadic oid,
  prosupport regproc,
  prokind "char",
  prosecdef boolean,
  proleakproof boolean,
  proisstrict boolean,
  proretset boolean,
  provolatile "char",
  proparallel "char",
  pronargs smallint,
  pronargdefaults smallint,
  prorettype oid,
  proargtypes oidvector,
  proallargtypes oid[],
  proargmodes "char"[],
  proargnames text[],
  proargdefaults pg_node_tree,
  protrftypes oid[],
  prosrc text,
  probin text,
  prosqlbody pg_node_tree,
  proconfig text[],
  proacl aclitem[]
);

create table pg_catalog.pg_publication (
  oid oid,
  pubname name,
  pubowner oid,
  puballtables boolean,
  pubinsert boolean,
  pubupdate boolean,
  pubdelete boolean,
  pubtruncate boolean,
  pubviaroot boolean,
  pubgencols "char"
);

create table pg_catalog.pg_publication_namespace (
  oid oid,
  pnpubid oid,
  pnnspid oid
);

create table pg_catalog.pg_publication_rel (
  oid oid,
  prpubid oid,
  prrelid oid,
  prqual pg_node_tree,
  prattrs int2vector
);

create table pg_catalog.pg_range (
  rngtypid oid,
  rngsubtype oid,
  rngmultitypid oid,
  rngcollation oid,
  rngsubopc oid,
  rngcanonical regproc,
  rngsubdiff regproc
);

create table pg_catalog.pg_replication_origin (
  roident oid,
  roname text
);

create table pg_catalog.pg_rewrite (
  oid oid,
  rulename name,
  ev_class oid,
  ev_type "char",
  ev_enabled "char",
  is_instead boolean,
  ev_qual pg_node_tree,
  ev_action pg_node_tree
);

create table pg_catalog.pg_seclabel (
  objoid oid,
  classoid oid,
  objsubid integer,
  provider text,
  label text
);

create table pg_catalog.pg_sequence (
  seqrelid oid,
  seqtypid oid,
  seqstart bigint,
  seqincrement bigint,
  seqmax bigint,
  seqmin bigint,
  seqcache bigint,
  seqcycle boolean
);

create table pg_catalog.pg_shdepend (
  dbid oid,
  classid oid,
  objid oid,
  objsubid integer,
  refclassid oid,
  refobjid oid,
  deptype "char"
);

create table pg_catalog.pg_shdescription (
  objoid oid,
  classoid oid,
  description text
);

create table pg_catalog.pg_shseclabel (
  objoid oid,
  classoid oid,
  provider text,
  label text
);

create table pg_catalog.pg_statistic (
  starelid oid,
  staattnum smallint,
  stainherit boolean,
  stanullfrac real,
  stawidth integer,
  stadistinct real,
  stakind1 smallint,
  stakind2 smallint,
  stakind3 smallint,
  stakind4 smallint,
  stakind5 smallint,
  staop1 oid,
  staop2 oid,
  staop3 oid,
  staop4 oid,
  staop5 oid,
  stacoll1 oid,
  stacoll2 oid,
  stacoll3 oid,
  stacoll4 oid,
  stacoll5 oid,
  stanumbers1 real[],
  stanumbers2 real[],
  stanumbers3 real[],
  stanumbers4 real[],
  stanumbers5 real[],
  stavalues1 anyarray,
  stavalues2 anyarray,
  stavalues3 anyarray,
  stavalues4 anyarray,
  stavalues5 anyarray
);

create table pg_catalog.pg_statistic_ext (
  oid oid,
  stxrelid oid,
  stxname name,
  stxnamespace oid,
  stxowner oid,
  stxkeys int2vector,
  stxstattarget smallint,
  stxkind "char"[],
  stxexprs pg_node_tree
);

create table pg_catalog.pg_statistic_ext_data (
  stxoid oid,
  stxdinherit boolean,
  stxdndistinct pg_ndistinct,
  stxddependencies pg_dependencies,
  stxdmcv pg_mcv_list,
  stxdexpr pg_statistic[]
);

create table pg_catalog.pg_subscription (
  oid oid,
  subdbid oid,
  subskiplsn pg_lsn,
  subname name,
  subowner oid,
  subenabled boolean,
  subbinary boolean,
  substream "char",
  subtwophasestate "char",
  subdisableonerr boolean,
  subpasswordrequired boolean,
  subrunasowner boolean,
  subfailover boolean,
  subconninfo text,
  subslotname name,
  subsynccommit text,
  subpublications text[],
  suborigin text
);

create table pg_catalog.pg_subscription_rel (
  srsubid oid,
  srrelid oid,
  srsubstate "char",
  srsublsn pg_lsn
);

create table pg_catalog.pg_tablespace (
  oid oid,
  spcname name,
  spcowner oid,
  spcacl aclitem[],
  spcoptions text[]
);

create table pg_catalog.pg_transform (
  oid oid,
  trftype oid,
  trflang oid,
  trffromsql regproc,
  trftosql regproc
);

create table pg_catalog.pg_trigger (
  oid oid,
  tgrelid oid,
  tgparentid oid,
  tgname name,
  tgfoid oid,
  tgtype smallint,
  tgenabled "char",
  tgisinternal boolean,
  tgconstrrelid oid,
  tgconstrindid oid,
  tgconstraint oid,
  tgdeferrable boolean,
  tginitdeferred boolean,
  tgnargs smallint,
  tgattr int2vector,
  tgargs bytea,
  tgqual pg_node_tree,
  tgoldtable name,
  tgnewtable name
);

create table pg_catalog.pg_ts_config (
  oid oid,
  cfgname name,
  cfgnamespace oid,
  cfgowner oid,
  cfgparser oid
);

create table pg_catalog.pg_ts_config_map (
  mapcfg oid,
  maptokentype integer,
  mapseqno integer,
  mapdict oid
);

create table pg_catalog.pg_ts_dict (
  oid oid,
  dictname name,
  dictnamespace oid,
  dictowner oid,
  dicttemplate oid,
  dictinitoption text
);

create table pg_catalog.pg_ts_parser (
  oid oid,
  prsname name,
  prsnamespace oid,
  prsstart regproc,
  prstoken regproc,
  prsend regproc,
  prsheadline regproc,
  prslextype regproc
);

create table pg_catalog.pg_ts_template (
  oid oid,
  tmplname name,
  tmplnamespace oid,
  tmplinit regproc,
  tmpllexize regproc
);

create table pg_catalog.pg_type (
  oid oid,
  typname name,
  typnamespace oid,
  typowner oid,
  typlen smallint,
  typbyval boolean,
  typtype "char",
  typcategory "char",
  typispreferred boolean,
  typisdefined boolean,
  typdelim "char",
  typrelid oid,
  typsubscript regproc,
  typelem oid,
  typarray oid,
  typinput regproc,
  typoutput regproc,
  typreceive regproc,
  typsend regproc,
  typmodin regproc,
  typmodout regproc,
  typanalyze regproc,
  typalign "char",
  typstorage "char",
  typnotnull boolean,
  typbasetype oid,
  typtypmod integer,
  typndims integer,
  typcollation oid,
  typdefaultbin pg_node_tree,
  typdefault text,
  typacl aclitem[]
);

create table pg_catalog.pg_user_mapping (
  oid oid,
  umuser oid,
  umserver oid,
  umoptions text[]
);

create view information_schema._pg_foreign_data_wrappers(oid, fdwowner, fdwoptions, foreign_data_wrapper_catalog, foreign_data_wrapper_name, authorization_identifier, foreign_data_wrapper_language) as
  select
    null::oid,
    null::oid,
    null::text[],
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data
;

create view information_schema._pg_foreign_servers(oid, srvoptions, foreign_server_catalog, foreign_server_name, foreign_data_wrapper_catalog, foreign_data_wrapper_name, foreign_server_type, foreign_server_version, authorization_identifier) as
  select
    null::oid,
    null::text[],
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.character_data,
    null::information_schema.sql_identifier
;

create view information_schema._pg_foreign_table_columns(nspname, relname, attname, attfdwoptions) as
  select
    null::name,
    null::name,
    null::name,
    null::text[]
;

create view information_schema._pg_foreign_tables(foreign_table_catalog, foreign_table_schema, foreign_table_name, ftoptions, foreign_server_catalog, foreign_server_name, authorization_identifier) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::text[],
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier
;

create view information_schema._pg_user_mappings(oid, umoptions, umuser, authorization_identifier, foreign_server_catalog, foreign_server_name, srvowner) as
  select
    null::oid,
    null::text[],
    null::oid,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier
;

create view information_schema.administrable_role_authorizations(grantee, role_name, is_grantable) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.yes_or_no
;

create view information_schema.applicable_roles(grantee, role_name, is_grantable) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.yes_or_no
;

create view information_schema.attributes(udt_catalog, udt_schema, udt_name, attribute_name, ordinal_position, attribute_default, is_nullable, data_type, character_maximum_length, character_octet_length, character_set_catalog, character_set_schema, character_set_name, collation_catalog, collation_schema, collation_name, numeric_precision, numeric_precision_radix, numeric_scale, datetime_precision, interval_type, interval_precision, attribute_udt_catalog, attribute_udt_schema, attribute_udt_name, scope_catalog, scope_schema, scope_name, maximum_cardinality, dtd_identifier, is_derived_reference_attribute) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.cardinal_number,
    null::information_schema.character_data,
    null::information_schema.yes_or_no,
    null::information_schema.character_data,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.character_data,
    null::information_schema.cardinal_number,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.cardinal_number,
    null::information_schema.sql_identifier,
    null::information_schema.yes_or_no
;

create view information_schema.character_sets(character_set_catalog, character_set_schema, character_set_name, character_repertoire, form_of_use, default_collate_catalog, default_collate_schema, default_collate_name) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier
;

create view information_schema.check_constraint_routine_usage(constraint_catalog, constraint_schema, constraint_name, specific_catalog, specific_schema, specific_name) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier
;

create view information_schema.check_constraints(constraint_catalog, constraint_schema, constraint_name, check_clause) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data
;

create view information_schema.collation_character_set_applicability(collation_catalog, collation_schema, collation_name, character_set_catalog, character_set_schema, character_set_name) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier
;

create view information_schema.collations(collation_catalog, collation_schema, collation_name, pad_attribute) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data
;

create view information_schema.column_column_usage(table_catalog, table_schema, table_name, column_name, dependent_column) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier
;

create view information_schema.column_domain_usage(domain_catalog, domain_schema, domain_name, table_catalog, table_schema, table_name, column_name) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier
;

create view information_schema.column_options(table_catalog, table_schema, table_name, column_name, option_name, option_value) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data
;

create view information_schema.column_privileges(grantor, grantee, table_catalog, table_schema, table_name, column_name, privilege_type, is_grantable) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.yes_or_no
;

create view information_schema.column_udt_usage(udt_catalog, udt_schema, udt_name, table_catalog, table_schema, table_name, column_name) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier
;

create view information_schema.columns(table_catalog, table_schema, table_name, column_name, ordinal_position, column_default, is_nullable, data_type, character_maximum_length, character_octet_length, numeric_precision, numeric_precision_radix, numeric_scale, datetime_precision, interval_type, interval_precision, character_set_catalog, character_set_schema, character_set_name, collation_catalog, collation_schema, collation_name, domain_catalog, domain_schema, domain_name, udt_catalog, udt_schema, udt_name, scope_catalog, scope_schema, scope_name, maximum_cardinality, dtd_identifier, is_self_referencing, is_identity, identity_generation, identity_start, identity_increment, identity_maximum, identity_minimum, identity_cycle, is_generated, generation_expression, is_updatable) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.cardinal_number,
    null::information_schema.character_data,
    null::information_schema.yes_or_no,
    null::information_schema.character_data,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.character_data,
    null::information_schema.cardinal_number,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.cardinal_number,
    null::information_schema.sql_identifier,
    null::information_schema.yes_or_no,
    null::information_schema.yes_or_no,
    null::information_schema.character_data,
    null::information_schema.character_data,
    null::information_schema.character_data,
    null::information_schema.character_data,
    null::information_schema.character_data,
    null::information_schema.yes_or_no,
    null::information_schema.character_data,
    null::information_schema.character_data,
    null::information_schema.yes_or_no
;

create view information_schema.constraint_column_usage(table_catalog, table_schema, table_name, column_name, constraint_catalog, constraint_schema, constraint_name) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier
;

create view information_schema.constraint_table_usage(table_catalog, table_schema, table_name, constraint_catalog, constraint_schema, constraint_name) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier
;

create view information_schema.data_type_privileges(object_catalog, object_schema, object_name, object_type, dtd_identifier) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.sql_identifier
;

create view information_schema.domain_constraints(constraint_catalog, constraint_schema, constraint_name, domain_catalog, domain_schema, domain_name, is_deferrable, initially_deferred) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.yes_or_no,
    null::information_schema.yes_or_no
;

create view information_schema.domain_udt_usage(udt_catalog, udt_schema, udt_name, domain_catalog, domain_schema, domain_name) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier
;

create view information_schema.domains(domain_catalog, domain_schema, domain_name, data_type, character_maximum_length, character_octet_length, character_set_catalog, character_set_schema, character_set_name, collation_catalog, collation_schema, collation_name, numeric_precision, numeric_precision_radix, numeric_scale, datetime_precision, interval_type, interval_precision, domain_default, udt_catalog, udt_schema, udt_name, scope_catalog, scope_schema, scope_name, maximum_cardinality, dtd_identifier) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.character_data,
    null::information_schema.cardinal_number,
    null::information_schema.character_data,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.cardinal_number,
    null::information_schema.sql_identifier
;

create view information_schema.element_types(object_catalog, object_schema, object_name, object_type, collection_type_identifier, data_type, character_maximum_length, character_octet_length, character_set_catalog, character_set_schema, character_set_name, collation_catalog, collation_schema, collation_name, numeric_precision, numeric_precision_radix, numeric_scale, datetime_precision, interval_type, interval_precision, udt_catalog, udt_schema, udt_name, scope_catalog, scope_schema, scope_name, maximum_cardinality, dtd_identifier) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.character_data,
    null::information_schema.cardinal_number,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.cardinal_number,
    null::information_schema.sql_identifier
;

create view information_schema.enabled_roles(role_name) as
  select
    null::information_schema.sql_identifier
;

create view information_schema.foreign_data_wrapper_options(foreign_data_wrapper_catalog, foreign_data_wrapper_name, option_name, option_value) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data
;

create view information_schema.foreign_data_wrappers(foreign_data_wrapper_catalog, foreign_data_wrapper_name, authorization_identifier, library_name, foreign_data_wrapper_language) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.character_data
;

create view information_schema.foreign_server_options(foreign_server_catalog, foreign_server_name, option_name, option_value) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data
;

create view information_schema.foreign_servers(foreign_server_catalog, foreign_server_name, foreign_data_wrapper_catalog, foreign_data_wrapper_name, foreign_server_type, foreign_server_version, authorization_identifier) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.character_data,
    null::information_schema.sql_identifier
;

create view information_schema.foreign_table_options(foreign_table_catalog, foreign_table_schema, foreign_table_name, option_name, option_value) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data
;

create view information_schema.foreign_tables(foreign_table_catalog, foreign_table_schema, foreign_table_name, foreign_server_catalog, foreign_server_name) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier
;

create view information_schema.information_schema_catalog_name(catalog_name) as
  select
    null::information_schema.sql_identifier
;

create view information_schema.key_column_usage(constraint_catalog, constraint_schema, constraint_name, table_catalog, table_schema, table_name, column_name, ordinal_position, position_in_unique_constraint) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number
;

create view information_schema.parameters(specific_catalog, specific_schema, specific_name, ordinal_position, parameter_mode, is_result, as_locator, parameter_name, data_type, character_maximum_length, character_octet_length, character_set_catalog, character_set_schema, character_set_name, collation_catalog, collation_schema, collation_name, numeric_precision, numeric_precision_radix, numeric_scale, datetime_precision, interval_type, interval_precision, udt_catalog, udt_schema, udt_name, scope_catalog, scope_schema, scope_name, maximum_cardinality, dtd_identifier, parameter_default) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.cardinal_number,
    null::information_schema.character_data,
    null::information_schema.yes_or_no,
    null::information_schema.yes_or_no,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.character_data,
    null::information_schema.cardinal_number,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.cardinal_number,
    null::information_schema.sql_identifier,
    null::information_schema.character_data
;

create view information_schema.referential_constraints(constraint_catalog, constraint_schema, constraint_name, unique_constraint_catalog, unique_constraint_schema, unique_constraint_name, match_option, update_rule, delete_rule) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.character_data,
    null::information_schema.character_data
;

create view information_schema.role_column_grants(grantor, grantee, table_catalog, table_schema, table_name, column_name, privilege_type, is_grantable) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.yes_or_no
;

create view information_schema.role_routine_grants(grantor, grantee, specific_catalog, specific_schema, specific_name, routine_catalog, routine_schema, routine_name, privilege_type, is_grantable) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.yes_or_no
;

create view information_schema.role_table_grants(grantor, grantee, table_catalog, table_schema, table_name, privilege_type, is_grantable, with_hierarchy) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.yes_or_no,
    null::information_schema.yes_or_no
;

create view information_schema.role_udt_grants(grantor, grantee, udt_catalog, udt_schema, udt_name, privilege_type, is_grantable) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.yes_or_no
;

create view information_schema.role_usage_grants(grantor, grantee, object_catalog, object_schema, object_name, object_type, privilege_type, is_grantable) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.character_data,
    null::information_schema.yes_or_no
;

create view information_schema.routine_column_usage(specific_catalog, specific_schema, specific_name, routine_catalog, routine_schema, routine_name, table_catalog, table_schema, table_name, column_name) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier
;

create view information_schema.routine_privileges(grantor, grantee, specific_catalog, specific_schema, specific_name, routine_catalog, routine_schema, routine_name, privilege_type, is_grantable) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.yes_or_no
;

create view information_schema.routine_routine_usage(specific_catalog, specific_schema, specific_name, routine_catalog, routine_schema, routine_name) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier
;

create view information_schema.routine_sequence_usage(specific_catalog, specific_schema, specific_name, routine_catalog, routine_schema, routine_name, sequence_catalog, sequence_schema, sequence_name) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier
;

create view information_schema.routine_table_usage(specific_catalog, specific_schema, specific_name, routine_catalog, routine_schema, routine_name, table_catalog, table_schema, table_name) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier
;

create view information_schema.routines(specific_catalog, specific_schema, specific_name, routine_catalog, routine_schema, routine_name, routine_type, module_catalog, module_schema, module_name, udt_catalog, udt_schema, udt_name, data_type, character_maximum_length, character_octet_length, character_set_catalog, character_set_schema, character_set_name, collation_catalog, collation_schema, collation_name, numeric_precision, numeric_precision_radix, numeric_scale, datetime_precision, interval_type, interval_precision, type_udt_catalog, type_udt_schema, type_udt_name, scope_catalog, scope_schema, scope_name, maximum_cardinality, dtd_identifier, routine_body, routine_definition, external_name, external_language, parameter_style, is_deterministic, sql_data_access, is_null_call, sql_path, schema_level_routine, max_dynamic_result_sets, is_user_defined_cast, is_implicitly_invocable, security_type, to_sql_specific_catalog, to_sql_specific_schema, to_sql_specific_name, as_locator, created, last_altered, new_savepoint_level, is_udt_dependent, result_cast_from_data_type, result_cast_as_locator, result_cast_char_max_length, result_cast_char_octet_length, result_cast_char_set_catalog, result_cast_char_set_schema, result_cast_char_set_name, result_cast_collation_catalog, result_cast_collation_schema, result_cast_collation_name, result_cast_numeric_precision, result_cast_numeric_precision_radix, result_cast_numeric_scale, result_cast_datetime_precision, result_cast_interval_type, result_cast_interval_precision, result_cast_type_udt_catalog, result_cast_type_udt_schema, result_cast_type_udt_name, result_cast_scope_catalog, result_cast_scope_schema, result_cast_scope_name, result_cast_maximum_cardinality, result_cast_dtd_identifier) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.character_data,
    null::information_schema.cardinal_number,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.cardinal_number,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.character_data,
    null::information_schema.character_data,
    null::information_schema.character_data,
    null::information_schema.character_data,
    null::information_schema.yes_or_no,
    null::information_schema.character_data,
    null::information_schema.yes_or_no,
    null::information_schema.character_data,
    null::information_schema.yes_or_no,
    null::information_schema.cardinal_number,
    null::information_schema.yes_or_no,
    null::information_schema.yes_or_no,
    null::information_schema.character_data,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.yes_or_no,
    null::information_schema.time_stamp,
    null::information_schema.time_stamp,
    null::information_schema.yes_or_no,
    null::information_schema.yes_or_no,
    null::information_schema.character_data,
    null::information_schema.yes_or_no,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.character_data,
    null::information_schema.cardinal_number,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.cardinal_number,
    null::information_schema.sql_identifier
;

create view information_schema.schemata(catalog_name, schema_name, schema_owner, default_character_set_catalog, default_character_set_schema, default_character_set_name, sql_path) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data
;

create view information_schema.sequences(sequence_catalog, sequence_schema, sequence_name, data_type, numeric_precision, numeric_precision_radix, numeric_scale, start_value, minimum_value, maximum_value, increment, cycle_option) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.character_data,
    null::information_schema.character_data,
    null::information_schema.character_data,
    null::information_schema.character_data,
    null::information_schema.yes_or_no
;

create view information_schema.table_constraints(constraint_catalog, constraint_schema, constraint_name, table_catalog, table_schema, table_name, constraint_type, is_deferrable, initially_deferred, enforced, nulls_distinct) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.yes_or_no,
    null::information_schema.yes_or_no,
    null::information_schema.yes_or_no,
    null::information_schema.yes_or_no
;

create view information_schema.table_privileges(grantor, grantee, table_catalog, table_schema, table_name, privilege_type, is_grantable, with_hierarchy) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.yes_or_no,
    null::information_schema.yes_or_no
;

create view information_schema.tables(table_catalog, table_schema, table_name, table_type, self_referencing_column_name, reference_generation, user_defined_type_catalog, user_defined_type_schema, user_defined_type_name, is_insertable_into, is_typed, commit_action) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.yes_or_no,
    null::information_schema.yes_or_no,
    null::information_schema.character_data
;

create view information_schema.transforms(udt_catalog, udt_schema, udt_name, specific_catalog, specific_schema, specific_name, group_name, transform_type) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data
;

create view information_schema.triggered_update_columns(trigger_catalog, trigger_schema, trigger_name, event_object_catalog, event_object_schema, event_object_table, event_object_column) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier
;

create view information_schema.triggers(trigger_catalog, trigger_schema, trigger_name, event_manipulation, event_object_catalog, event_object_schema, event_object_table, action_order, action_condition, action_statement, action_orientation, action_timing, action_reference_old_table, action_reference_new_table, action_reference_old_row, action_reference_new_row, created) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.cardinal_number,
    null::information_schema.character_data,
    null::information_schema.character_data,
    null::information_schema.character_data,
    null::information_schema.character_data,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.time_stamp
;

create view information_schema.udt_privileges(grantor, grantee, udt_catalog, udt_schema, udt_name, privilege_type, is_grantable) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.yes_or_no
;

create view information_schema.usage_privileges(grantor, grantee, object_catalog, object_schema, object_name, object_type, privilege_type, is_grantable) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.character_data,
    null::information_schema.yes_or_no
;

create view information_schema.user_defined_types(user_defined_type_catalog, user_defined_type_schema, user_defined_type_name, user_defined_type_category, is_instantiable, is_final, ordering_form, ordering_category, ordering_routine_catalog, ordering_routine_schema, ordering_routine_name, reference_type, data_type, character_maximum_length, character_octet_length, character_set_catalog, character_set_schema, character_set_name, collation_catalog, collation_schema, collation_name, numeric_precision, numeric_precision_radix, numeric_scale, datetime_precision, interval_type, interval_precision, source_dtd_identifier, ref_dtd_identifier) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.yes_or_no,
    null::information_schema.yes_or_no,
    null::information_schema.character_data,
    null::information_schema.character_data,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.character_data,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.cardinal_number,
    null::information_schema.character_data,
    null::information_schema.cardinal_number,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier
;

create view information_schema.user_mapping_options(authorization_identifier, foreign_server_catalog, foreign_server_name, option_name, option_value) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data
;

create view information_schema.user_mappings(authorization_identifier, foreign_server_catalog, foreign_server_name) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier
;

create view information_schema.view_column_usage(view_catalog, view_schema, view_name, table_catalog, table_schema, table_name, column_name) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier
;

create view information_schema.view_routine_usage(table_catalog, table_schema, table_name, specific_catalog, specific_schema, specific_name) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier
;

create view information_schema.view_table_usage(view_catalog, view_schema, view_name, table_catalog, table_schema, table_name) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier
;

create view information_schema.views(table_catalog, table_schema, table_name, view_definition, check_option, is_updatable, is_insertable_into, is_trigger_updatable, is_trigger_deletable, is_trigger_insertable_into) as
  select
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.sql_identifier,
    null::information_schema.character_data,
    null::information_schema.character_data,
    null::information_schema.yes_or_no,
    null::information_schema.yes_or_no,
    null::information_schema.yes_or_no,
    null::information_schema.yes_or_no,
    null::information_schema.yes_or_no
;

create view pg_catalog.pg_aios(pid, io_id, io_generation, state, operation, off, length, target, handle_data_len, raw_result, result, target_desc, f_sync, f_localmem, f_buffered) as
  select
    null::integer,
    null::integer,
    null::bigint,
    null::text,
    null::text,
    null::bigint,
    null::bigint,
    null::text,
    null::smallint,
    null::integer,
    null::text,
    null::text,
    null::boolean,
    null::boolean,
    null::boolean
;

create view pg_catalog.pg_available_extension_versions(name, version, installed, superuser, trusted, relocatable, schema, requires, comment) as
  select
    null::name,
    null::text,
    null::boolean,
    null::boolean,
    null::boolean,
    null::boolean,
    null::name,
    null::name[],
    null::text
;

create view pg_catalog.pg_available_extensions(name, default_version, installed_version, comment) as
  select
    null::name,
    null::text,
    null::text,
    null::text
;

create view pg_catalog.pg_backend_memory_contexts(name, ident, type, level, path, total_bytes, total_nblocks, free_bytes, free_chunks, used_bytes) as
  select
    null::text,
    null::text,
    null::text,
    null::integer,
    null::integer[],
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint
;

create view pg_catalog.pg_config(name, setting) as
  select
    null::text,
    null::text
;

create view pg_catalog.pg_cursors(name, statement, is_holdable, is_binary, is_scrollable, creation_time) as
  select
    null::text,
    null::text,
    null::boolean,
    null::boolean,
    null::boolean,
    null::timestamp with time zone
;

create view pg_catalog.pg_file_settings(sourcefile, sourceline, seqno, name, setting, applied, error) as
  select
    null::text,
    null::integer,
    null::integer,
    null::text,
    null::text,
    null::boolean,
    null::text
;

create view pg_catalog.pg_group(groname, grosysid, grolist) as
  select
    null::name,
    null::oid,
    null::oid[]
;

create view pg_catalog.pg_hba_file_rules(rule_number, file_name, line_number, type, database, user_name, address, netmask, auth_method, options, error) as
  select
    null::integer,
    null::text,
    null::integer,
    null::text,
    null::text[],
    null::text[],
    null::text,
    null::text,
    null::text,
    null::text[],
    null::text
;

create view pg_catalog.pg_ident_file_mappings(map_number, file_name, line_number, map_name, sys_name, pg_username, error) as
  select
    null::integer,
    null::text,
    null::integer,
    null::text,
    null::text,
    null::text,
    null::text
;

create view pg_catalog.pg_indexes(schemaname, tablename, indexname, tablespace, indexdef) as
  select
    null::name,
    null::name,
    null::name,
    null::name,
    null::text
;

create view pg_catalog.pg_locks(locktype, database, relation, page, tuple, virtualxid, transactionid, classid, objid, objsubid, virtualtransaction, pid, mode, granted, fastpath, waitstart) as
  select
    null::text,
    null::oid,
    null::oid,
    null::integer,
    null::smallint,
    null::text,
    null::xid,
    null::oid,
    null::oid,
    null::smallint,
    null::text,
    null::integer,
    null::text,
    null::boolean,
    null::boolean,
    null::timestamp with time zone
;

create view pg_catalog.pg_matviews(schemaname, matviewname, matviewowner, tablespace, hasindexes, ispopulated, definition) as
  select
    null::name,
    null::name,
    null::name,
    null::name,
    null::boolean,
    null::boolean,
    null::text
;

create view pg_catalog.pg_policies(schemaname, tablename, policyname, permissive, roles, cmd, qual, with_check) as
  select
    null::name,
    null::name,
    null::name,
    null::text,
    null::name[],
    null::text,
    null::text,
    null::text
;

create view pg_catalog.pg_prepared_statements(name, statement, prepare_time, parameter_types, result_types, from_sql, generic_plans, custom_plans) as
  select
    null::text,
    null::text,
    null::timestamp with time zone,
    null::regtype[],
    null::regtype[],
    null::boolean,
    null::bigint,
    null::bigint
;

create view pg_catalog.pg_prepared_xacts(transaction, gid, prepared, owner, database) as
  select
    null::xid,
    null::text,
    null::timestamp with time zone,
    null::name,
    null::name
;

create view pg_catalog.pg_publication_tables(pubname, schemaname, tablename, attnames, rowfilter) as
  select
    null::name,
    null::name,
    null::name,
    null::name[],
    null::text
;

create view pg_catalog.pg_replication_origin_status(local_id, external_id, remote_lsn, local_lsn) as
  select
    null::oid,
    null::text,
    null::pg_lsn,
    null::pg_lsn
;

create view pg_catalog.pg_replication_slots(slot_name, plugin, slot_type, datoid, database, temporary, active, active_pid, xmin, catalog_xmin, restart_lsn, confirmed_flush_lsn, wal_status, safe_wal_size, two_phase, two_phase_at, inactive_since, conflicting, invalidation_reason, failover, synced) as
  select
    null::name,
    null::name,
    null::text,
    null::oid,
    null::name,
    null::boolean,
    null::boolean,
    null::integer,
    null::xid,
    null::xid,
    null::pg_lsn,
    null::pg_lsn,
    null::text,
    null::bigint,
    null::boolean,
    null::pg_lsn,
    null::timestamp with time zone,
    null::boolean,
    null::text,
    null::boolean,
    null::boolean
;

create view pg_catalog.pg_roles(rolname, rolsuper, rolinherit, rolcreaterole, rolcreatedb, rolcanlogin, rolreplication, rolconnlimit, rolpassword, rolvaliduntil, rolbypassrls, rolconfig, oid) as
  select
    null::name,
    null::boolean,
    null::boolean,
    null::boolean,
    null::boolean,
    null::boolean,
    null::boolean,
    null::integer,
    null::text,
    null::timestamp with time zone,
    null::boolean,
    null::text[],
    null::oid
;

create view pg_catalog.pg_rules(schemaname, tablename, rulename, definition) as
  select
    null::name,
    null::name,
    null::name,
    null::text
;

create view pg_catalog.pg_seclabels(objoid, classoid, objsubid, objtype, objnamespace, objname, provider, label) as
  select
    null::oid,
    null::oid,
    null::integer,
    null::text,
    null::oid,
    null::text,
    null::text,
    null::text
;

create view pg_catalog.pg_sequences(schemaname, sequencename, sequenceowner, data_type, start_value, min_value, max_value, increment_by, cycle, cache_size, last_value) as
  select
    null::name,
    null::name,
    null::name,
    null::regtype,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::boolean,
    null::bigint,
    null::bigint
;

create view pg_catalog.pg_settings(name, setting, unit, category, short_desc, extra_desc, context, vartype, source, min_val, max_val, enumvals, boot_val, reset_val, sourcefile, sourceline, pending_restart) as
  select
    null::text,
    null::text,
    null::text,
    null::text,
    null::text,
    null::text,
    null::text,
    null::text,
    null::text,
    null::text,
    null::text,
    null::text[],
    null::text,
    null::text,
    null::text,
    null::integer,
    null::boolean
;

create view pg_catalog.pg_shadow(usename, usesysid, usecreatedb, usesuper, userepl, usebypassrls, passwd, valuntil, useconfig) as
  select
    null::name,
    null::oid,
    null::boolean,
    null::boolean,
    null::boolean,
    null::boolean,
    null::text,
    null::timestamp with time zone,
    null::text[]
;

create view pg_catalog.pg_shmem_allocations(name, off, size, allocated_size) as
  select
    null::text,
    null::bigint,
    null::bigint,
    null::bigint
;

create view pg_catalog.pg_shmem_allocations_numa(name, numa_node, size) as
  select
    null::text,
    null::integer,
    null::bigint
;

create view pg_catalog.pg_stat_activity(datid, datname, pid, leader_pid, usesysid, usename, application_name, client_addr, client_hostname, client_port, backend_start, xact_start, query_start, state_change, wait_event_type, wait_event, state, backend_xid, backend_xmin, query_id, query, backend_type) as
  select
    null::oid,
    null::name,
    null::integer,
    null::integer,
    null::oid,
    null::name,
    null::text,
    null::inet,
    null::text,
    null::integer,
    null::timestamp with time zone,
    null::timestamp with time zone,
    null::timestamp with time zone,
    null::timestamp with time zone,
    null::text,
    null::text,
    null::text,
    null::xid,
    null::xid,
    null::bigint,
    null::text,
    null::text
;

create view pg_catalog.pg_stat_all_indexes(relid, indexrelid, schemaname, relname, indexrelname, idx_scan, last_idx_scan, idx_tup_read, idx_tup_fetch) as
  select
    null::oid,
    null::oid,
    null::name,
    null::name,
    null::name,
    null::bigint,
    null::timestamp with time zone,
    null::bigint,
    null::bigint
;

create view pg_catalog.pg_stat_all_tables(relid, schemaname, relname, seq_scan, last_seq_scan, seq_tup_read, idx_scan, last_idx_scan, idx_tup_fetch, n_tup_ins, n_tup_upd, n_tup_del, n_tup_hot_upd, n_tup_newpage_upd, n_live_tup, n_dead_tup, n_mod_since_analyze, n_ins_since_vacuum, last_vacuum, last_autovacuum, last_analyze, last_autoanalyze, vacuum_count, autovacuum_count, analyze_count, autoanalyze_count, total_vacuum_time, total_autovacuum_time, total_analyze_time, total_autoanalyze_time) as
  select
    null::oid,
    null::name,
    null::name,
    null::bigint,
    null::timestamp with time zone,
    null::bigint,
    null::bigint,
    null::timestamp with time zone,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::timestamp with time zone,
    null::timestamp with time zone,
    null::timestamp with time zone,
    null::timestamp with time zone,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::double precision,
    null::double precision,
    null::double precision,
    null::double precision
;

create view pg_catalog.pg_stat_archiver(archived_count, last_archived_wal, last_archived_time, failed_count, last_failed_wal, last_failed_time, stats_reset) as
  select
    null::bigint,
    null::text,
    null::timestamp with time zone,
    null::bigint,
    null::text,
    null::timestamp with time zone,
    null::timestamp with time zone
;

create view pg_catalog.pg_stat_bgwriter(buffers_clean, maxwritten_clean, buffers_alloc, stats_reset) as
  select
    null::bigint,
    null::bigint,
    null::bigint,
    null::timestamp with time zone
;

create view pg_catalog.pg_stat_checkpointer(num_timed, num_requested, num_done, restartpoints_timed, restartpoints_req, restartpoints_done, write_time, sync_time, buffers_written, slru_written, stats_reset) as
  select
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::double precision,
    null::double precision,
    null::bigint,
    null::bigint,
    null::timestamp with time zone
;

create view pg_catalog.pg_stat_database(datid, datname, numbackends, xact_commit, xact_rollback, blks_read, blks_hit, tup_returned, tup_fetched, tup_inserted, tup_updated, tup_deleted, conflicts, temp_files, temp_bytes, deadlocks, checksum_failures, checksum_last_failure, blk_read_time, blk_write_time, session_time, active_time, idle_in_transaction_time, sessions, sessions_abandoned, sessions_fatal, sessions_killed, parallel_workers_to_launch, parallel_workers_launched, stats_reset) as
  select
    null::oid,
    null::name,
    null::integer,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::timestamp with time zone,
    null::double precision,
    null::double precision,
    null::double precision,
    null::double precision,
    null::double precision,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::timestamp with time zone
;

create view pg_catalog.pg_stat_database_conflicts(datid, datname, confl_tablespace, confl_lock, confl_snapshot, confl_bufferpin, confl_deadlock, confl_active_logicalslot) as
  select
    null::oid,
    null::name,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint
;

create view pg_catalog.pg_stat_gssapi(pid, gss_authenticated, principal, encrypted, credentials_delegated) as
  select
    null::integer,
    null::boolean,
    null::text,
    null::boolean,
    null::boolean
;

create view pg_catalog.pg_stat_io(backend_type, object, context, reads, read_bytes, read_time, writes, write_bytes, write_time, writebacks, writeback_time, extends, extend_bytes, extend_time, hits, evictions, reuses, fsyncs, fsync_time, stats_reset) as
  select
    null::text,
    null::text,
    null::text,
    null::bigint,
    null::numeric,
    null::double precision,
    null::bigint,
    null::numeric,
    null::double precision,
    null::bigint,
    null::double precision,
    null::bigint,
    null::numeric,
    null::double precision,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::double precision,
    null::timestamp with time zone
;

create view pg_catalog.pg_stat_progress_analyze(pid, datid, datname, relid, phase, sample_blks_total, sample_blks_scanned, ext_stats_total, ext_stats_computed, child_tables_total, child_tables_done, current_child_table_relid, delay_time) as
  select
    null::integer,
    null::oid,
    null::name,
    null::oid,
    null::text,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::oid,
    null::double precision
;

create view pg_catalog.pg_stat_progress_basebackup(pid, phase, backup_total, backup_streamed, tablespaces_total, tablespaces_streamed) as
  select
    null::integer,
    null::text,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint
;

create view pg_catalog.pg_stat_progress_cluster(pid, datid, datname, relid, command, phase, cluster_index_relid, heap_tuples_scanned, heap_tuples_written, heap_blks_total, heap_blks_scanned, index_rebuild_count) as
  select
    null::integer,
    null::oid,
    null::name,
    null::oid,
    null::text,
    null::text,
    null::oid,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint
;

create view pg_catalog.pg_stat_progress_copy(pid, datid, datname, relid, command, type, bytes_processed, bytes_total, tuples_processed, tuples_excluded, tuples_skipped) as
  select
    null::integer,
    null::oid,
    null::name,
    null::oid,
    null::text,
    null::text,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint
;

create view pg_catalog.pg_stat_progress_create_index(pid, datid, datname, relid, index_relid, command, phase, lockers_total, lockers_done, current_locker_pid, blocks_total, blocks_done, tuples_total, tuples_done, partitions_total, partitions_done) as
  select
    null::integer,
    null::oid,
    null::name,
    null::oid,
    null::oid,
    null::text,
    null::text,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint
;

create view pg_catalog.pg_stat_progress_vacuum(pid, datid, datname, relid, phase, heap_blks_total, heap_blks_scanned, heap_blks_vacuumed, index_vacuum_count, max_dead_tuple_bytes, dead_tuple_bytes, num_dead_item_ids, indexes_total, indexes_processed, delay_time) as
  select
    null::integer,
    null::oid,
    null::name,
    null::oid,
    null::text,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::double precision
;

create view pg_catalog.pg_stat_recovery_prefetch(stats_reset, prefetch, hit, skip_init, skip_new, skip_fpw, skip_rep, wal_distance, block_distance, io_depth) as
  select
    null::timestamp with time zone,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::integer,
    null::integer,
    null::integer
;

create view pg_catalog.pg_stat_replication(pid, usesysid, usename, application_name, client_addr, client_hostname, client_port, backend_start, backend_xmin, state, sent_lsn, write_lsn, flush_lsn, replay_lsn, write_lag, flush_lag, replay_lag, sync_priority, sync_state, reply_time) as
  select
    null::integer,
    null::oid,
    null::name,
    null::text,
    null::inet,
    null::text,
    null::integer,
    null::timestamp with time zone,
    null::xid,
    null::text,
    null::pg_lsn,
    null::pg_lsn,
    null::pg_lsn,
    null::pg_lsn,
    null::interval,
    null::interval,
    null::interval,
    null::integer,
    null::text,
    null::timestamp with time zone
;

create view pg_catalog.pg_stat_replication_slots(slot_name, spill_txns, spill_count, spill_bytes, stream_txns, stream_count, stream_bytes, total_txns, total_bytes, stats_reset) as
  select
    null::text,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::timestamp with time zone
;

create view pg_catalog.pg_stat_slru(name, blks_zeroed, blks_hit, blks_read, blks_written, blks_exists, flushes, truncates, stats_reset) as
  select
    null::text,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::timestamp with time zone
;

create view pg_catalog.pg_stat_ssl(pid, ssl, version, cipher, bits, client_dn, client_serial, issuer_dn) as
  select
    null::integer,
    null::boolean,
    null::text,
    null::text,
    null::integer,
    null::text,
    null::numeric,
    null::text
;

create view pg_catalog.pg_stat_subscription(subid, subname, worker_type, pid, leader_pid, relid, received_lsn, last_msg_send_time, last_msg_receipt_time, latest_end_lsn, latest_end_time) as
  select
    null::oid,
    null::name,
    null::text,
    null::integer,
    null::integer,
    null::oid,
    null::pg_lsn,
    null::timestamp with time zone,
    null::timestamp with time zone,
    null::pg_lsn,
    null::timestamp with time zone
;

create view pg_catalog.pg_stat_subscription_stats(subid, subname, apply_error_count, sync_error_count, confl_insert_exists, confl_update_origin_differs, confl_update_exists, confl_update_missing, confl_delete_origin_differs, confl_delete_missing, confl_multiple_unique_conflicts, stats_reset) as
  select
    null::oid,
    null::name,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::timestamp with time zone
;

create view pg_catalog.pg_stat_sys_indexes(relid, indexrelid, schemaname, relname, indexrelname, idx_scan, last_idx_scan, idx_tup_read, idx_tup_fetch) as
  select
    null::oid,
    null::oid,
    null::name,
    null::name,
    null::name,
    null::bigint,
    null::timestamp with time zone,
    null::bigint,
    null::bigint
;

create view pg_catalog.pg_stat_sys_tables(relid, schemaname, relname, seq_scan, last_seq_scan, seq_tup_read, idx_scan, last_idx_scan, idx_tup_fetch, n_tup_ins, n_tup_upd, n_tup_del, n_tup_hot_upd, n_tup_newpage_upd, n_live_tup, n_dead_tup, n_mod_since_analyze, n_ins_since_vacuum, last_vacuum, last_autovacuum, last_analyze, last_autoanalyze, vacuum_count, autovacuum_count, analyze_count, autoanalyze_count, total_vacuum_time, total_autovacuum_time, total_analyze_time, total_autoanalyze_time) as
  select
    null::oid,
    null::name,
    null::name,
    null::bigint,
    null::timestamp with time zone,
    null::bigint,
    null::bigint,
    null::timestamp with time zone,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::timestamp with time zone,
    null::timestamp with time zone,
    null::timestamp with time zone,
    null::timestamp with time zone,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::double precision,
    null::double precision,
    null::double precision,
    null::double precision
;

create view pg_catalog.pg_stat_user_functions(funcid, schemaname, funcname, calls, total_time, self_time) as
  select
    null::oid,
    null::name,
    null::name,
    null::bigint,
    null::double precision,
    null::double precision
;

create view pg_catalog.pg_stat_user_indexes(relid, indexrelid, schemaname, relname, indexrelname, idx_scan, last_idx_scan, idx_tup_read, idx_tup_fetch) as
  select
    null::oid,
    null::oid,
    null::name,
    null::name,
    null::name,
    null::bigint,
    null::timestamp with time zone,
    null::bigint,
    null::bigint
;

create view pg_catalog.pg_stat_user_tables(relid, schemaname, relname, seq_scan, last_seq_scan, seq_tup_read, idx_scan, last_idx_scan, idx_tup_fetch, n_tup_ins, n_tup_upd, n_tup_del, n_tup_hot_upd, n_tup_newpage_upd, n_live_tup, n_dead_tup, n_mod_since_analyze, n_ins_since_vacuum, last_vacuum, last_autovacuum, last_analyze, last_autoanalyze, vacuum_count, autovacuum_count, analyze_count, autoanalyze_count, total_vacuum_time, total_autovacuum_time, total_analyze_time, total_autoanalyze_time) as
  select
    null::oid,
    null::name,
    null::name,
    null::bigint,
    null::timestamp with time zone,
    null::bigint,
    null::bigint,
    null::timestamp with time zone,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::timestamp with time zone,
    null::timestamp with time zone,
    null::timestamp with time zone,
    null::timestamp with time zone,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::double precision,
    null::double precision,
    null::double precision,
    null::double precision
;

create view pg_catalog.pg_stat_wal(wal_records, wal_fpi, wal_bytes, wal_buffers_full, stats_reset) as
  select
    null::bigint,
    null::bigint,
    null::numeric,
    null::bigint,
    null::timestamp with time zone
;

create view pg_catalog.pg_stat_wal_receiver(pid, status, receive_start_lsn, receive_start_tli, written_lsn, flushed_lsn, received_tli, last_msg_send_time, last_msg_receipt_time, latest_end_lsn, latest_end_time, slot_name, sender_host, sender_port, conninfo) as
  select
    null::integer,
    null::text,
    null::pg_lsn,
    null::integer,
    null::pg_lsn,
    null::pg_lsn,
    null::integer,
    null::timestamp with time zone,
    null::timestamp with time zone,
    null::pg_lsn,
    null::timestamp with time zone,
    null::text,
    null::text,
    null::integer,
    null::text
;

create view pg_catalog.pg_stat_xact_all_tables(relid, schemaname, relname, seq_scan, seq_tup_read, idx_scan, idx_tup_fetch, n_tup_ins, n_tup_upd, n_tup_del, n_tup_hot_upd, n_tup_newpage_upd) as
  select
    null::oid,
    null::name,
    null::name,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint
;

create view pg_catalog.pg_stat_xact_sys_tables(relid, schemaname, relname, seq_scan, seq_tup_read, idx_scan, idx_tup_fetch, n_tup_ins, n_tup_upd, n_tup_del, n_tup_hot_upd, n_tup_newpage_upd) as
  select
    null::oid,
    null::name,
    null::name,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint
;

create view pg_catalog.pg_stat_xact_user_functions(funcid, schemaname, funcname, calls, total_time, self_time) as
  select
    null::oid,
    null::name,
    null::name,
    null::bigint,
    null::double precision,
    null::double precision
;

create view pg_catalog.pg_stat_xact_user_tables(relid, schemaname, relname, seq_scan, seq_tup_read, idx_scan, idx_tup_fetch, n_tup_ins, n_tup_upd, n_tup_del, n_tup_hot_upd, n_tup_newpage_upd) as
  select
    null::oid,
    null::name,
    null::name,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint
;

create view pg_catalog.pg_statio_all_indexes(relid, indexrelid, schemaname, relname, indexrelname, idx_blks_read, idx_blks_hit) as
  select
    null::oid,
    null::oid,
    null::name,
    null::name,
    null::name,
    null::bigint,
    null::bigint
;

create view pg_catalog.pg_statio_all_sequences(relid, schemaname, relname, blks_read, blks_hit) as
  select
    null::oid,
    null::name,
    null::name,
    null::bigint,
    null::bigint
;

create view pg_catalog.pg_statio_all_tables(relid, schemaname, relname, heap_blks_read, heap_blks_hit, idx_blks_read, idx_blks_hit, toast_blks_read, toast_blks_hit, tidx_blks_read, tidx_blks_hit) as
  select
    null::oid,
    null::name,
    null::name,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint
;

create view pg_catalog.pg_statio_sys_indexes(relid, indexrelid, schemaname, relname, indexrelname, idx_blks_read, idx_blks_hit) as
  select
    null::oid,
    null::oid,
    null::name,
    null::name,
    null::name,
    null::bigint,
    null::bigint
;

create view pg_catalog.pg_statio_sys_sequences(relid, schemaname, relname, blks_read, blks_hit) as
  select
    null::oid,
    null::name,
    null::name,
    null::bigint,
    null::bigint
;

create view pg_catalog.pg_statio_sys_tables(relid, schemaname, relname, heap_blks_read, heap_blks_hit, idx_blks_read, idx_blks_hit, toast_blks_read, toast_blks_hit, tidx_blks_read, tidx_blks_hit) as
  select
    null::oid,
    null::name,
    null::name,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint
;

create view pg_catalog.pg_statio_user_indexes(relid, indexrelid, schemaname, relname, indexrelname, idx_blks_read, idx_blks_hit) as
  select
    null::oid,
    null::oid,
    null::name,
    null::name,
    null::name,
    null::bigint,
    null::bigint
;

create view pg_catalog.pg_statio_user_sequences(relid, schemaname, relname, blks_read, blks_hit) as
  select
    null::oid,
    null::name,
    null::name,
    null::bigint,
    null::bigint
;

create view pg_catalog.pg_statio_user_tables(relid, schemaname, relname, heap_blks_read, heap_blks_hit, idx_blks_read, idx_blks_hit, toast_blks_read, toast_blks_hit, tidx_blks_read, tidx_blks_hit) as
  select
    null::oid,
    null::name,
    null::name,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint,
    null::bigint
;

create view pg_catalog.pg_stats(schemaname, tablename, attname, inherited, null_frac, avg_width, n_distinct, most_common_vals, most_common_freqs, histogram_bounds, correlation, most_common_elems, most_common_elem_freqs, elem_count_histogram, range_length_histogram, range_empty_frac, range_bounds_histogram) as
  select
    null::name,
    null::name,
    null::name,
    null::boolean,
    null::real,
    null::integer,
    null::real,
    null::anyarray,
    null::real[],
    null::anyarray,
    null::real,
    null::anyarray,
    null::real[],
    null::real[],
    null::anyarray,
    null::real,
    null::anyarray
;

create view pg_catalog.pg_stats_ext(schemaname, tablename, statistics_schemaname, statistics_name, statistics_owner, attnames, exprs, kinds, inherited, n_distinct, dependencies, most_common_vals, most_common_val_nulls, most_common_freqs, most_common_base_freqs) as
  select
    null::name,
    null::name,
    null::name,
    null::name,
    null::name,
    null::name[],
    null::text[],
    null::"char"[],
    null::boolean,
    null::pg_ndistinct,
    null::pg_dependencies,
    null::text[],
    null::boolean[],
    null::double precision[],
    null::double precision[]
;

create view pg_catalog.pg_stats_ext_exprs(schemaname, tablename, statistics_schemaname, statistics_name, statistics_owner, expr, inherited, null_frac, avg_width, n_distinct, most_common_vals, most_common_freqs, histogram_bounds, correlation, most_common_elems, most_common_elem_freqs, elem_count_histogram) as
  select
    null::name,
    null::name,
    null::name,
    null::name,
    null::name,
    null::text,
    null::boolean,
    null::real,
    null::integer,
    null::real,
    null::anyarray,
    null::real[],
    null::anyarray,
    null::real,
    null::anyarray,
    null::real[],
    null::real[]
;

create view pg_catalog.pg_tables(schemaname, tablename, tableowner, tablespace, hasindexes, hasrules, hastriggers, rowsecurity) as
  select
    null::name,
    null::name,
    null::name,
    null::name,
    null::boolean,
    null::boolean,
    null::boolean,
    null::boolean
;

create view pg_catalog.pg_timezone_abbrevs(abbrev, utc_offset, is_dst) as
  select
    null::text,
    null::interval,
    null::boolean
;

create view pg_catalog.pg_timezone_names(name, abbrev, utc_offset, is_dst) as
  select
    null::text,
    null::text,
    null::interval,
    null::boolean
;

create view pg_catalog.pg_user(usename, usesysid, usecreatedb, usesuper, userepl, usebypassrls, passwd, valuntil, useconfig) as
  select
    null::name,
    null::oid,
    null::boolean,
    null::boolean,
    null::boolean,
    null::boolean,
    null::text,
    null::timestamp with time zone,
    null::text[]
;

create view pg_catalog.pg_user_mappings(umid, srvid, srvname, umuser, usename, umoptions) as
  select
    null::oid,
    null::oid,
    null::name,
    null::oid,
    null::name,
    null::text[]
;

create view pg_catalog.pg_views(schemaname, viewname, viewowner, definition) as
  select
    null::name,
    null::name,
    null::name,
    null::text
;

create view pg_catalog.pg_wait_events(type, name, description) as
  select
    null::text,
    null::text,
    null::text
;

create function information_schema._pg_char_max_length(typid oid, typmod integer) returns integer
  language sql;

create function information_schema._pg_char_octet_length(typid oid, typmod integer) returns integer
  language sql;

create function information_schema._pg_datetime_precision(typid oid, typmod integer) returns integer
  language sql;

create function information_schema._pg_expandarray(anyarray, OUT x anyelement, OUT n integer) returns SETOF record
  language sql;

create function information_schema._pg_index_position(oid, smallint) returns integer
  language sql;

create function information_schema._pg_interval_type(typid oid, mod integer) returns text
  language sql;

create function information_schema._pg_numeric_precision(typid oid, typmod integer) returns integer
  language sql;

create function information_schema._pg_numeric_precision_radix(typid oid, typmod integer) returns integer
  language sql;

create function information_schema._pg_numeric_scale(typid oid, typmod integer) returns integer
  language sql;

create function information_schema._pg_truetypid(pg_attribute, pg_type) returns oid
  language sql;

create function information_schema._pg_truetypmod(pg_attribute, pg_type) returns integer
  language sql;

-- referential integrity ON DELETE CASCADE
create function pg_catalog.RI_FKey_cascade_del() returns trigger
  language internal;

-- referential integrity ON UPDATE CASCADE
create function pg_catalog.RI_FKey_cascade_upd() returns trigger
  language internal;

-- referential integrity FOREIGN KEY ... REFERENCES
create function pg_catalog.RI_FKey_check_ins() returns trigger
  language internal;

-- referential integrity FOREIGN KEY ... REFERENCES
create function pg_catalog.RI_FKey_check_upd() returns trigger
  language internal;

-- referential integrity ON DELETE NO ACTION
create function pg_catalog.RI_FKey_noaction_del() returns trigger
  language internal;

-- referential integrity ON UPDATE NO ACTION
create function pg_catalog.RI_FKey_noaction_upd() returns trigger
  language internal;

-- referential integrity ON DELETE RESTRICT
create function pg_catalog.RI_FKey_restrict_del() returns trigger
  language internal;

-- referential integrity ON UPDATE RESTRICT
create function pg_catalog.RI_FKey_restrict_upd() returns trigger
  language internal;

-- referential integrity ON DELETE SET DEFAULT
create function pg_catalog.RI_FKey_setdefault_del() returns trigger
  language internal;

-- referential integrity ON UPDATE SET DEFAULT
create function pg_catalog.RI_FKey_setdefault_upd() returns trigger
  language internal;

-- referential integrity ON DELETE SET NULL
create function pg_catalog.RI_FKey_setnull_del() returns trigger
  language internal;

-- referential integrity ON UPDATE SET NULL
create function pg_catalog.RI_FKey_setnull_upd() returns trigger
  language internal;

-- abbreviated display of cidr value
create function pg_catalog.abbrev(cidr) returns text
  language internal;

-- abbreviated display of inet value
create function pg_catalog.abbrev(inet) returns text
  language internal;

-- absolute value
create function pg_catalog.abs(bigint) returns bigint
  language internal;

-- absolute value
create function pg_catalog.abs(double precision) returns double precision
  language internal;

-- absolute value
create function pg_catalog.abs(integer) returns integer
  language internal;

-- absolute value
create function pg_catalog.abs(numeric) returns numeric
  language internal;

-- absolute value
create function pg_catalog.abs(real) returns real
  language internal;

-- absolute value
create function pg_catalog.abs(smallint) returns smallint
  language internal;

-- contains
create function pg_catalog.aclcontains(aclitem[], aclitem) returns boolean
  language internal;

-- show hardwired default privileges, primarily for use by the information schema
create function pg_catalog.acldefault("char", oid) returns aclitem[]
  language internal;

-- convert ACL item array to table, primarily for use by information schema
create function pg_catalog.aclexplode(acl aclitem[], OUT grantor oid, OUT grantee oid, OUT privilege_type text, OUT is_grantable boolean) returns SETOF record
  language internal;

-- add/update ACL item
create function pg_catalog.aclinsert(aclitem[], aclitem) returns aclitem[]
  language internal;

-- implementation of = operator
create function pg_catalog.aclitemeq(aclitem, aclitem) returns boolean
  language internal;

-- I/O
create function pg_catalog.aclitemin(cstring) returns aclitem
  language internal;

-- I/O
create function pg_catalog.aclitemout(aclitem) returns cstring
  language internal;

-- remove ACL item
create function pg_catalog.aclremove(aclitem[], aclitem) returns aclitem[]
  language internal;

-- arccosine
create function pg_catalog.acos(double precision) returns double precision
  language internal;

-- arccosine, degrees
create function pg_catalog.acosd(double precision) returns double precision
  language internal;

-- inverse hyperbolic cosine
create function pg_catalog.acosh(double precision) returns double precision
  language internal;

-- date difference from today preserving months and years
create function pg_catalog.age(timestamp with time zone) returns interval
  language sql;

-- date difference preserving months and years
create function pg_catalog.age(timestamp with time zone, timestamp with time zone) returns interval
  language internal;

-- date difference from today preserving months and years
create function pg_catalog.age(timestamp without time zone) returns interval
  language sql;

-- date difference preserving months and years
create function pg_catalog.age(timestamp without time zone, timestamp without time zone) returns interval
  language internal;

-- age of a transaction ID, in transactions before current transaction
create function pg_catalog.age(xid) returns integer
  language internal;

-- validate an operator class
create function pg_catalog.amvalidate(oid) returns boolean
  language internal;

-- I/O
create function pg_catalog.any_in(cstring) returns "any"
  language internal;

-- I/O
create function pg_catalog.any_out("any") returns cstring
  language internal;

-- arbitrary value from among input values
create aggregate pg_catalog.any_value(anyelement) (
  sfunc = any_value_transfn,
  stype = anyelement,
  combinefunc = any_value_transfn
);

-- aggregate transition function
create function pg_catalog.any_value_transfn(anyelement, anyelement) returns anyelement
  language internal;

-- I/O
create function pg_catalog.anyarray_in(cstring) returns anyarray
  language internal;

-- I/O
create function pg_catalog.anyarray_out(anyarray) returns cstring
  language internal;

-- I/O
create function pg_catalog.anyarray_recv(internal) returns anyarray
  language internal;

-- I/O
create function pg_catalog.anyarray_send(anyarray) returns bytea
  language internal;

-- I/O
create function pg_catalog.anycompatible_in(cstring) returns anycompatible
  language internal;

-- I/O
create function pg_catalog.anycompatible_out(anycompatible) returns cstring
  language internal;

-- I/O
create function pg_catalog.anycompatiblearray_in(cstring) returns anycompatiblearray
  language internal;

-- I/O
create function pg_catalog.anycompatiblearray_out(anycompatiblearray) returns cstring
  language internal;

-- I/O
create function pg_catalog.anycompatiblearray_recv(internal) returns anycompatiblearray
  language internal;

-- I/O
create function pg_catalog.anycompatiblearray_send(anycompatiblearray) returns bytea
  language internal;

-- I/O
create function pg_catalog.anycompatiblemultirange_in(cstring, oid, integer) returns anycompatiblemultirange
  language internal;

-- I/O
create function pg_catalog.anycompatiblemultirange_out(anycompatiblemultirange) returns cstring
  language internal;

-- I/O
create function pg_catalog.anycompatiblenonarray_in(cstring) returns anycompatiblenonarray
  language internal;

-- I/O
create function pg_catalog.anycompatiblenonarray_out(anycompatiblenonarray) returns cstring
  language internal;

-- I/O
create function pg_catalog.anycompatiblerange_in(cstring, oid, integer) returns anycompatiblerange
  language internal;

-- I/O
create function pg_catalog.anycompatiblerange_out(anycompatiblerange) returns cstring
  language internal;

-- I/O
create function pg_catalog.anyelement_in(cstring) returns anyelement
  language internal;

-- I/O
create function pg_catalog.anyelement_out(anyelement) returns cstring
  language internal;

-- I/O
create function pg_catalog.anyenum_in(cstring) returns anyenum
  language internal;

-- I/O
create function pg_catalog.anyenum_out(anyenum) returns cstring
  language internal;

-- I/O
create function pg_catalog.anymultirange_in(cstring, oid, integer) returns anymultirange
  language internal;

-- I/O
create function pg_catalog.anymultirange_out(anymultirange) returns cstring
  language internal;

-- I/O
create function pg_catalog.anynonarray_in(cstring) returns anynonarray
  language internal;

-- I/O
create function pg_catalog.anynonarray_out(anynonarray) returns cstring
  language internal;

-- I/O
create function pg_catalog.anyrange_in(cstring, oid, integer) returns anyrange
  language internal;

-- I/O
create function pg_catalog.anyrange_out(anyrange) returns cstring
  language internal;

-- implementation of || operator
create function pg_catalog.anytextcat(anynonarray, text) returns text
  language sql;

-- box area
create function pg_catalog.area(box) returns double precision
  language internal;

-- area of circle
create function pg_catalog.area(circle) returns double precision
  language internal;

-- area of a closed path
create function pg_catalog.area(path) returns double precision
  language internal;

-- join selectivity for area-comparison operators
create function pg_catalog.areajoinsel(internal, oid, internal, smallint, internal) returns double precision
  language internal;

-- restriction selectivity for area-comparison operators
create function pg_catalog.areasel(internal, oid, internal, integer) returns double precision
  language internal;

-- concatenate aggregate input into an array
create aggregate pg_catalog.array_agg(anyarray) (
  sfunc = array_agg_array_transfn,
  stype = internal,
  finalfunc = array_agg_array_finalfn,
  combinefunc = array_agg_array_combine
);

-- concatenate aggregate input into an array
create aggregate pg_catalog.array_agg(anynonarray) (
  sfunc = array_agg_transfn,
  stype = internal,
  finalfunc = array_agg_finalfn,
  combinefunc = array_agg_combine
);

-- aggregate combine function
create function pg_catalog.array_agg_array_combine(internal, internal) returns internal
  language internal;

-- aggregate deserial function
create function pg_catalog.array_agg_array_deserialize(bytea, internal) returns internal
  language internal;

-- aggregate final function
create function pg_catalog.array_agg_array_finalfn(internal, anyarray) returns anyarray
  language internal;

-- aggregate serial function
create function pg_catalog.array_agg_array_serialize(internal) returns bytea
  language internal;

-- aggregate transition function
create function pg_catalog.array_agg_array_transfn(internal, anyarray) returns internal
  language internal;

-- aggregate combine function
create function pg_catalog.array_agg_combine(internal, internal) returns internal
  language internal;

-- aggregate deserial function
create function pg_catalog.array_agg_deserialize(bytea, internal) returns internal
  language internal;

-- aggregate final function
create function pg_catalog.array_agg_finalfn(internal, anynonarray) returns anyarray
  language internal;

-- aggregate serial function
create function pg_catalog.array_agg_serialize(internal) returns bytea
  language internal;

-- aggregate transition function
create function pg_catalog.array_agg_transfn(internal, anynonarray) returns internal
  language internal;

-- append element onto end of array
create function pg_catalog.array_append(anycompatiblearray, anycompatible) returns anycompatiblearray
  language internal;

-- planner support for array_append
create function pg_catalog.array_append_support(internal) returns internal
  language internal;

-- implementation of || operator
create function pg_catalog.array_cat(anycompatiblearray, anycompatiblearray) returns anycompatiblearray
  language internal;

-- array dimensions
create function pg_catalog.array_dims(anyarray) returns text
  language internal;

-- implementation of = operator
create function pg_catalog.array_eq(anyarray, anyarray) returns boolean
  language internal;

-- array constructor with value
create function pg_catalog.array_fill(anyelement, integer[]) returns anyarray
  language internal;

-- array constructor with value
create function pg_catalog.array_fill(anyelement, integer[], integer[]) returns anyarray
  language internal;

-- implementation of >= operator
create function pg_catalog.array_ge(anyarray, anyarray) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.array_gt(anyarray, anyarray) returns boolean
  language internal;

-- I/O
create function pg_catalog.array_in(cstring, oid, integer) returns anyarray
  language internal;

-- larger of two
create function pg_catalog.array_larger(anyarray, anyarray) returns anyarray
  language internal;

-- implementation of <= operator
create function pg_catalog.array_le(anyarray, anyarray) returns boolean
  language internal;

-- array length
create function pg_catalog.array_length(anyarray, integer) returns integer
  language internal;

-- array lower dimension
create function pg_catalog.array_lower(anyarray, integer) returns integer
  language internal;

-- implementation of < operator
create function pg_catalog.array_lt(anyarray, anyarray) returns boolean
  language internal;

-- number of array dimensions
create function pg_catalog.array_ndims(anyarray) returns integer
  language internal;

-- implementation of <> operator
create function pg_catalog.array_ne(anyarray, anyarray) returns boolean
  language internal;

-- I/O
create function pg_catalog.array_out(anyarray) returns cstring
  language internal;

-- returns an offset of value in array
create function pg_catalog.array_position(anycompatiblearray, anycompatible) returns integer
  language internal;

-- returns an offset of value in array with start index
create function pg_catalog.array_position(anycompatiblearray, anycompatible, integer) returns integer
  language internal;

-- returns an array of offsets of some value in array
create function pg_catalog.array_positions(anycompatiblearray, anycompatible) returns integer[]
  language internal;

-- prepend element onto front of array
create function pg_catalog.array_prepend(anycompatible, anycompatiblearray) returns anycompatiblearray
  language internal;

-- planner support for array_prepend
create function pg_catalog.array_prepend_support(internal) returns internal
  language internal;

-- I/O
create function pg_catalog.array_recv(internal, oid, integer) returns anyarray
  language internal;

-- remove any occurrences of an element from an array
create function pg_catalog.array_remove(anycompatiblearray, anycompatible) returns anycompatiblearray
  language internal;

-- replace any occurrences of an element in an array
create function pg_catalog.array_replace(anycompatiblearray, anycompatible, anycompatible) returns anycompatiblearray
  language internal;

-- reverse array
create function pg_catalog.array_reverse(anyarray) returns anyarray
  language internal;

-- take samples from array
create function pg_catalog.array_sample(anyarray, integer) returns anyarray
  language internal;

-- I/O
create function pg_catalog.array_send(anyarray) returns bytea
  language internal;

-- shuffle array
create function pg_catalog.array_shuffle(anyarray) returns anyarray
  language internal;

-- smaller of two
create function pg_catalog.array_smaller(anyarray, anyarray) returns anyarray
  language internal;

-- sort array
create function pg_catalog.array_sort("array" anyarray, descending boolean) returns anyarray
  language internal;

-- sort array
create function pg_catalog.array_sort("array" anyarray, descending boolean, nulls_first boolean) returns anyarray
  language internal;

-- sort array
create function pg_catalog.array_sort(anyarray) returns anyarray
  language internal;

-- standard array subscripting support
create function pg_catalog.array_subscript_handler(internal) returns internal
  language internal;

-- planner support for array_subscript_handler
create function pg_catalog.array_subscript_handler_support(internal) returns internal
  language internal;

-- map array to json
create function pg_catalog.array_to_json(anyarray) returns json
  language internal;

-- map array to json with optional pretty printing
create function pg_catalog.array_to_json(anyarray, boolean) returns json
  language internal;

-- concatenate array elements, using delimiter, into text
create function pg_catalog.array_to_string(anyarray, text) returns text
  language internal;

-- concatenate array elements, using delimiter and null string, into text
create function pg_catalog.array_to_string(anyarray, text, text) returns text
  language internal;

-- build tsvector from array of lexemes
create function pg_catalog.array_to_tsvector(text[]) returns tsvector
  language internal;

-- array typanalyze
create function pg_catalog.array_typanalyze(internal) returns boolean
  language internal;

-- planner support for array_unnest
create function pg_catalog.array_unnest_support(internal) returns internal
  language internal;

-- array upper dimension
create function pg_catalog.array_upper(anyarray, integer) returns integer
  language internal;

-- implementation of <@ operator
create function pg_catalog.arraycontained(anyarray, anyarray) returns boolean
  language internal;

-- implementation of @> operator
create function pg_catalog.arraycontains(anyarray, anyarray) returns boolean
  language internal;

-- join selectivity for array-containment operators
create function pg_catalog.arraycontjoinsel(internal, oid, internal, smallint, internal) returns double precision
  language internal;

-- restriction selectivity for array-containment operators
create function pg_catalog.arraycontsel(internal, oid, internal, integer) returns double precision
  language internal;

-- implementation of && operator
create function pg_catalog.arrayoverlap(anyarray, anyarray) returns boolean
  language internal;

-- convert first char to int4
create function pg_catalog.ascii(text) returns integer
  language internal;

-- arcsine
create function pg_catalog.asin(double precision) returns double precision
  language internal;

-- arcsine, degrees
create function pg_catalog.asind(double precision) returns double precision
  language internal;

-- inverse hyperbolic sine
create function pg_catalog.asinh(double precision) returns double precision
  language internal;

-- arctangent
create function pg_catalog.atan(double precision) returns double precision
  language internal;

-- arctangent, two arguments
create function pg_catalog.atan2(double precision, double precision) returns double precision
  language internal;

-- arctangent, two arguments, degrees
create function pg_catalog.atan2d(double precision, double precision) returns double precision
  language internal;

-- arctangent, degrees
create function pg_catalog.atand(double precision) returns double precision
  language internal;

-- inverse hyperbolic tangent
create function pg_catalog.atanh(double precision) returns double precision
  language internal;

-- the average (arithmetic mean) as numeric of all bigint values
create aggregate pg_catalog.avg(bigint) (
  sfunc = int8_avg_accum,
  stype = internal,
  finalfunc = numeric_poly_avg,
  combinefunc = int8_avg_combine
);

-- the average (arithmetic mean) as float8 of all float8 values
create aggregate pg_catalog.avg(double precision) (
  sfunc = float8_accum,
  stype = double precision[],
  finalfunc = float8_avg,
  combinefunc = float8_combine,
  initcond = '{0,0,0}'
);

-- the average (arithmetic mean) as numeric of all integer values
create aggregate pg_catalog.avg(integer) (
  sfunc = int4_avg_accum,
  stype = bigint[],
  finalfunc = int8_avg,
  combinefunc = int4_avg_combine,
  initcond = '{0,0}'
);

-- the average (arithmetic mean) as interval of all interval values
create aggregate pg_catalog.avg(interval) (
  sfunc = interval_avg_accum,
  stype = internal,
  finalfunc = interval_avg,
  combinefunc = interval_avg_combine
);

-- the average (arithmetic mean) as numeric of all numeric values
create aggregate pg_catalog.avg(numeric) (
  sfunc = numeric_avg_accum,
  stype = internal,
  finalfunc = numeric_avg,
  combinefunc = numeric_avg_combine
);

-- the average (arithmetic mean) as float8 of all float4 values
create aggregate pg_catalog.avg(real) (
  sfunc = float4_accum,
  stype = double precision[],
  finalfunc = float8_avg,
  combinefunc = float8_combine,
  initcond = '{0,0,0}'
);

-- the average (arithmetic mean) as numeric of all smallint values
create aggregate pg_catalog.avg(smallint) (
  sfunc = int2_avg_accum,
  stype = bigint[],
  finalfunc = int8_avg,
  combinefunc = int4_avg_combine,
  initcond = '{0,0}'
);

-- BERNOULLI tablesample method handler
create function pg_catalog.bernoulli(internal) returns tsm_handler
  language internal;

-- internal conversion function for BIG5 to EUC_TW
create function pg_catalog.big5_to_euc_tw(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for BIG5 to MULE_INTERNAL
create function pg_catalog.big5_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for BIG5 to UTF8
create function pg_catalog.big5_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- for use by pg_upgrade (relation for pg_subscription_rel)
create function pg_catalog.binary_upgrade_add_sub_rel_state(text, oid, "char", pg_lsn) returns void
  language internal;

-- for use by pg_upgrade
create function pg_catalog.binary_upgrade_create_empty_extension(text, text, boolean, text, oid[], text[], text[]) returns void
  language internal;

-- for use by pg_upgrade
create function pg_catalog.binary_upgrade_logical_slot_has_caught_up(name) returns boolean
  language internal;

-- for use by pg_upgrade (remote_lsn for origin)
create function pg_catalog.binary_upgrade_replorigin_advance(text, pg_lsn) returns void
  language internal;

-- for use by pg_upgrade
create function pg_catalog.binary_upgrade_set_missing_value(oid, text, text) returns void
  language internal;

-- for use by pg_upgrade
create function pg_catalog.binary_upgrade_set_next_array_pg_type_oid(oid) returns void
  language internal;

-- for use by pg_upgrade
create function pg_catalog.binary_upgrade_set_next_heap_pg_class_oid(oid) returns void
  language internal;

-- for use by pg_upgrade
create function pg_catalog.binary_upgrade_set_next_heap_relfilenode(oid) returns void
  language internal;

-- for use by pg_upgrade
create function pg_catalog.binary_upgrade_set_next_index_pg_class_oid(oid) returns void
  language internal;

-- for use by pg_upgrade
create function pg_catalog.binary_upgrade_set_next_index_relfilenode(oid) returns void
  language internal;

-- for use by pg_upgrade
create function pg_catalog.binary_upgrade_set_next_multirange_array_pg_type_oid(oid) returns void
  language internal;

-- for use by pg_upgrade
create function pg_catalog.binary_upgrade_set_next_multirange_pg_type_oid(oid) returns void
  language internal;

-- for use by pg_upgrade
create function pg_catalog.binary_upgrade_set_next_pg_authid_oid(oid) returns void
  language internal;

-- for use by pg_upgrade
create function pg_catalog.binary_upgrade_set_next_pg_enum_oid(oid) returns void
  language internal;

-- for use by pg_upgrade
create function pg_catalog.binary_upgrade_set_next_pg_tablespace_oid(oid) returns void
  language internal;

-- for use by pg_upgrade
create function pg_catalog.binary_upgrade_set_next_pg_type_oid(oid) returns void
  language internal;

-- for use by pg_upgrade
create function pg_catalog.binary_upgrade_set_next_toast_pg_class_oid(oid) returns void
  language internal;

-- for use by pg_upgrade
create function pg_catalog.binary_upgrade_set_next_toast_relfilenode(oid) returns void
  language internal;

-- for use by pg_upgrade
create function pg_catalog.binary_upgrade_set_record_init_privs(boolean) returns void
  language internal;

-- convert int8 to bitstring
create function pg_catalog.bit(bigint, integer) returns bit
  language internal;

-- adjust bit() to typmod length
create function pg_catalog.bit(bit, integer, boolean) returns bit
  language internal;

-- convert int4 to bitstring
create function pg_catalog.bit(integer, integer) returns bit
  language internal;

-- bitwise-and bigint aggregate
create aggregate pg_catalog.bit_and(bigint) (
  sfunc = int8and,
  stype = bigint,
  combinefunc = int8and
);

-- bitwise-and bit aggregate
create aggregate pg_catalog.bit_and(bit) (
  sfunc = bitand,
  stype = bit,
  combinefunc = bitand
);

-- bitwise-and integer aggregate
create aggregate pg_catalog.bit_and(integer) (
  sfunc = int4and,
  stype = integer,
  combinefunc = int4and
);

-- bitwise-and smallint aggregate
create aggregate pg_catalog.bit_and(smallint) (
  sfunc = int2and,
  stype = smallint,
  combinefunc = int2and
);

-- number of set bits
create function pg_catalog.bit_count(bit) returns bigint
  language internal;

-- number of set bits
create function pg_catalog.bit_count(bytea) returns bigint
  language internal;

-- I/O
create function pg_catalog.bit_in(cstring, oid, integer) returns bit
  language internal;

-- length in bits
create function pg_catalog.bit_length(bit) returns integer
  language sql;

-- length in bits
create function pg_catalog.bit_length(bytea) returns integer
  language sql;

-- length in bits
create function pg_catalog.bit_length(text) returns integer
  language sql;

-- bitwise-or bigint aggregate
create aggregate pg_catalog.bit_or(bigint) (
  sfunc = int8or,
  stype = bigint,
  combinefunc = int8or
);

-- bitwise-or bit aggregate
create aggregate pg_catalog.bit_or(bit) (
  sfunc = bitor,
  stype = bit,
  combinefunc = bitor
);

-- bitwise-or integer aggregate
create aggregate pg_catalog.bit_or(integer) (
  sfunc = int4or,
  stype = integer,
  combinefunc = int4or
);

-- bitwise-or smallint aggregate
create aggregate pg_catalog.bit_or(smallint) (
  sfunc = int2or,
  stype = smallint,
  combinefunc = int2or
);

-- I/O
create function pg_catalog.bit_out(bit) returns cstring
  language internal;

-- I/O
create function pg_catalog.bit_recv(internal, oid, integer) returns bit
  language internal;

-- I/O
create function pg_catalog.bit_send(bit) returns bytea
  language internal;

-- bitwise-xor bigint aggregate
create aggregate pg_catalog.bit_xor(bigint) (
  sfunc = int8xor,
  stype = bigint,
  combinefunc = int8xor
);

-- bitwise-xor bit aggregate
create aggregate pg_catalog.bit_xor(bit) (
  sfunc = bitxor,
  stype = bit,
  combinefunc = bitxor
);

-- bitwise-xor integer aggregate
create aggregate pg_catalog.bit_xor(integer) (
  sfunc = int4xor,
  stype = integer,
  combinefunc = int4xor
);

-- bitwise-xor smallint aggregate
create aggregate pg_catalog.bit_xor(smallint) (
  sfunc = int2xor,
  stype = smallint,
  combinefunc = int2xor
);

-- implementation of & operator
create function pg_catalog.bitand(bit, bit) returns bit
  language internal;

-- implementation of || operator
create function pg_catalog.bitcat(bit varying, bit varying) returns bit varying
  language internal;

-- less-equal-greater
create function pg_catalog.bitcmp(bit, bit) returns integer
  language internal;

-- implementation of = operator
create function pg_catalog.biteq(bit, bit) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.bitge(bit, bit) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.bitgt(bit, bit) returns boolean
  language internal;

-- implementation of <= operator
create function pg_catalog.bitle(bit, bit) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.bitlt(bit, bit) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.bitne(bit, bit) returns boolean
  language internal;

-- implementation of ~ operator
create function pg_catalog.bitnot(bit) returns bit
  language internal;

-- implementation of | operator
create function pg_catalog.bitor(bit, bit) returns bit
  language internal;

-- implementation of << operator
create function pg_catalog.bitshiftleft(bit, integer) returns bit
  language internal;

-- implementation of >> operator
create function pg_catalog.bitshiftright(bit, integer) returns bit
  language internal;

-- I/O typmod
create function pg_catalog.bittypmodin(cstring[]) returns integer
  language internal;

-- I/O typmod
create function pg_catalog.bittypmodout(integer) returns cstring
  language internal;

-- implementation of # operator
create function pg_catalog.bitxor(bit, bit) returns bit
  language internal;

-- convert int4 to boolean
create function pg_catalog.bool(integer) returns boolean
  language internal;

-- convert jsonb to boolean
create function pg_catalog.bool(jsonb) returns boolean
  language internal;

-- aggregate transition function
create function pg_catalog.bool_accum(internal, boolean) returns internal
  language internal;

-- aggregate transition function
create function pg_catalog.bool_accum_inv(internal, boolean) returns internal
  language internal;

-- aggregate final function
create function pg_catalog.bool_alltrue(internal) returns boolean
  language internal;

-- boolean-and aggregate
create aggregate pg_catalog.bool_and(boolean) (
  sfunc = booland_statefunc,
  stype = boolean,
  combinefunc = booland_statefunc
);

-- aggregate final function
create function pg_catalog.bool_anytrue(internal) returns boolean
  language internal;

-- boolean-or aggregate
create aggregate pg_catalog.bool_or(boolean) (
  sfunc = boolor_statefunc,
  stype = boolean,
  combinefunc = boolor_statefunc
);

-- aggregate transition function
create function pg_catalog.booland_statefunc(boolean, boolean) returns boolean
  language internal;

-- implementation of = operator
create function pg_catalog.booleq(boolean, boolean) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.boolge(boolean, boolean) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.boolgt(boolean, boolean) returns boolean
  language internal;

-- I/O
create function pg_catalog.boolin(cstring) returns boolean
  language internal;

-- implementation of <= operator
create function pg_catalog.boolle(boolean, boolean) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.boollt(boolean, boolean) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.boolne(boolean, boolean) returns boolean
  language internal;

-- aggregate transition function
create function pg_catalog.boolor_statefunc(boolean, boolean) returns boolean
  language internal;

-- I/O
create function pg_catalog.boolout(boolean) returns cstring
  language internal;

-- I/O
create function pg_catalog.boolrecv(internal) returns boolean
  language internal;

-- I/O
create function pg_catalog.boolsend(boolean) returns bytea
  language internal;

-- bounding box of two boxes
create function pg_catalog.bound_box(box, box) returns box
  language internal;

-- convert circle to box
create function pg_catalog.box(circle) returns box
  language internal;

-- convert point to empty box
create function pg_catalog.box(point) returns box
  language internal;

-- convert points to box
create function pg_catalog.box(point, point) returns box
  language internal;

-- convert polygon to bounding box
create function pg_catalog.box(polygon) returns box
  language internal;

-- implementation of |>> operator
create function pg_catalog.box_above(box, box) returns boolean
  language internal;

-- implementation of >^ operator
create function pg_catalog.box_above_eq(box, box) returns boolean
  language internal;

-- implementation of + operator
create function pg_catalog.box_add(box, point) returns box
  language internal;

-- implementation of <<| operator
create function pg_catalog.box_below(box, box) returns boolean
  language internal;

-- implementation of <^ operator
create function pg_catalog.box_below_eq(box, box) returns boolean
  language internal;

-- implementation of @@ operator
create function pg_catalog.box_center(box) returns point
  language internal;

-- implementation of @> operator
create function pg_catalog.box_contain(box, box) returns boolean
  language internal;

-- implementation of @> operator
create function pg_catalog.box_contain_pt(box, point) returns boolean
  language internal;

-- implementation of <@ operator
create function pg_catalog.box_contained(box, box) returns boolean
  language internal;

-- implementation of <-> operator
create function pg_catalog.box_distance(box, box) returns double precision
  language internal;

-- implementation of / operator
create function pg_catalog.box_div(box, point) returns box
  language internal;

-- implementation of = operator
create function pg_catalog.box_eq(box, box) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.box_ge(box, box) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.box_gt(box, box) returns boolean
  language internal;

-- I/O
create function pg_catalog.box_in(cstring) returns box
  language internal;

-- implementation of # operator
create function pg_catalog.box_intersect(box, box) returns box
  language internal;

-- implementation of <= operator
create function pg_catalog.box_le(box, box) returns boolean
  language internal;

-- implementation of << operator
create function pg_catalog.box_left(box, box) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.box_lt(box, box) returns boolean
  language internal;

-- implementation of * operator
create function pg_catalog.box_mul(box, point) returns box
  language internal;

-- I/O
create function pg_catalog.box_out(box) returns cstring
  language internal;

-- implementation of |&> operator
create function pg_catalog.box_overabove(box, box) returns boolean
  language internal;

-- implementation of &<| operator
create function pg_catalog.box_overbelow(box, box) returns boolean
  language internal;

-- implementation of && operator
create function pg_catalog.box_overlap(box, box) returns boolean
  language internal;

-- implementation of &< operator
create function pg_catalog.box_overleft(box, box) returns boolean
  language internal;

-- implementation of &> operator
create function pg_catalog.box_overright(box, box) returns boolean
  language internal;

-- I/O
create function pg_catalog.box_recv(internal) returns box
  language internal;

-- implementation of >> operator
create function pg_catalog.box_right(box, box) returns boolean
  language internal;

-- implementation of ~= operator
create function pg_catalog.box_same(box, box) returns boolean
  language internal;

-- I/O
create function pg_catalog.box_send(box) returns bytea
  language internal;

-- implementation of - operator
create function pg_catalog.box_sub(box, point) returns box
  language internal;

-- convert char to char(n)
create function pg_catalog.bpchar("char") returns character
  language internal;

-- adjust char() to typmod length
create function pg_catalog.bpchar(character, integer, boolean) returns character
  language internal;

-- convert name to char(n)
create function pg_catalog.bpchar(name) returns character
  language internal;

-- larger of two
create function pg_catalog.bpchar_larger(character, character) returns character
  language internal;

-- implementation of ~>=~ operator
create function pg_catalog.bpchar_pattern_ge(character, character) returns boolean
  language internal;

-- implementation of ~>~ operator
create function pg_catalog.bpchar_pattern_gt(character, character) returns boolean
  language internal;

-- implementation of ~<=~ operator
create function pg_catalog.bpchar_pattern_le(character, character) returns boolean
  language internal;

-- implementation of ~<~ operator
create function pg_catalog.bpchar_pattern_lt(character, character) returns boolean
  language internal;

-- smaller of two
create function pg_catalog.bpchar_smaller(character, character) returns character
  language internal;

-- sort support
create function pg_catalog.bpchar_sortsupport(internal) returns void
  language internal;

-- less-equal-greater
create function pg_catalog.bpcharcmp(character, character) returns integer
  language internal;

-- implementation of = operator
create function pg_catalog.bpchareq(character, character) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.bpcharge(character, character) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.bpchargt(character, character) returns boolean
  language internal;

-- implementation of ~~* operator
create function pg_catalog.bpchariclike(character, text) returns boolean
  language internal;

-- implementation of !~~* operator
create function pg_catalog.bpcharicnlike(character, text) returns boolean
  language internal;

-- implementation of ~* operator
create function pg_catalog.bpcharicregexeq(character, text) returns boolean
  language internal;

-- implementation of !~* operator
create function pg_catalog.bpcharicregexne(character, text) returns boolean
  language internal;

-- I/O
create function pg_catalog.bpcharin(cstring, oid, integer) returns character
  language internal;

-- implementation of <= operator
create function pg_catalog.bpcharle(character, character) returns boolean
  language internal;

-- implementation of ~~ operator
create function pg_catalog.bpcharlike(character, text) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.bpcharlt(character, character) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.bpcharne(character, character) returns boolean
  language internal;

-- implementation of !~~ operator
create function pg_catalog.bpcharnlike(character, text) returns boolean
  language internal;

-- I/O
create function pg_catalog.bpcharout(character) returns cstring
  language internal;

-- I/O
create function pg_catalog.bpcharrecv(internal, oid, integer) returns character
  language internal;

-- implementation of ~ operator
create function pg_catalog.bpcharregexeq(character, text) returns boolean
  language internal;

-- implementation of !~ operator
create function pg_catalog.bpcharregexne(character, text) returns boolean
  language internal;

-- I/O
create function pg_catalog.bpcharsend(character) returns bytea
  language internal;

-- I/O typmod
create function pg_catalog.bpchartypmodin(cstring[]) returns integer
  language internal;

-- I/O typmod
create function pg_catalog.bpchartypmodout(integer) returns cstring
  language internal;

-- BRIN bloom support
create function pg_catalog.brin_bloom_add_value(internal, internal, internal, internal) returns boolean
  language internal;

-- BRIN bloom support
create function pg_catalog.brin_bloom_consistent(internal, internal, internal, integer) returns boolean
  language internal;

-- BRIN bloom support
create function pg_catalog.brin_bloom_opcinfo(internal) returns internal
  language internal;

-- BRIN bloom support
create function pg_catalog.brin_bloom_options(internal) returns void
  language internal;

-- I/O
create function pg_catalog.brin_bloom_summary_in(cstring) returns pg_brin_bloom_summary
  language internal;

-- I/O
create function pg_catalog.brin_bloom_summary_out(pg_brin_bloom_summary) returns cstring
  language internal;

-- I/O
create function pg_catalog.brin_bloom_summary_recv(internal) returns pg_brin_bloom_summary
  language internal;

-- I/O
create function pg_catalog.brin_bloom_summary_send(pg_brin_bloom_summary) returns bytea
  language internal;

-- BRIN bloom support
create function pg_catalog.brin_bloom_union(internal, internal, internal) returns boolean
  language internal;

-- brin: desummarize page range
create function pg_catalog.brin_desummarize_range(regclass, bigint) returns void
  language internal;

-- BRIN inclusion support
create function pg_catalog.brin_inclusion_add_value(internal, internal, internal, internal) returns boolean
  language internal;

-- BRIN inclusion support
create function pg_catalog.brin_inclusion_consistent(internal, internal, internal) returns boolean
  language internal;

-- BRIN inclusion support
create function pg_catalog.brin_inclusion_opcinfo(internal) returns internal
  language internal;

-- BRIN inclusion support
create function pg_catalog.brin_inclusion_union(internal, internal, internal) returns boolean
  language internal;

-- BRIN minmax support
create function pg_catalog.brin_minmax_add_value(internal, internal, internal, internal) returns boolean
  language internal;

-- BRIN minmax support
create function pg_catalog.brin_minmax_consistent(internal, internal, internal) returns boolean
  language internal;

-- BRIN multi minmax support
create function pg_catalog.brin_minmax_multi_add_value(internal, internal, internal, internal) returns boolean
  language internal;

-- BRIN multi minmax support
create function pg_catalog.brin_minmax_multi_consistent(internal, internal, internal, integer) returns boolean
  language internal;

-- BRIN multi minmax date distance
create function pg_catalog.brin_minmax_multi_distance_date(internal, internal) returns double precision
  language internal;

-- BRIN multi minmax float4 distance
create function pg_catalog.brin_minmax_multi_distance_float4(internal, internal) returns double precision
  language internal;

-- BRIN multi minmax float8 distance
create function pg_catalog.brin_minmax_multi_distance_float8(internal, internal) returns double precision
  language internal;

-- BRIN multi minmax inet distance
create function pg_catalog.brin_minmax_multi_distance_inet(internal, internal) returns double precision
  language internal;

-- BRIN multi minmax int2 distance
create function pg_catalog.brin_minmax_multi_distance_int2(internal, internal) returns double precision
  language internal;

-- BRIN multi minmax int4 distance
create function pg_catalog.brin_minmax_multi_distance_int4(internal, internal) returns double precision
  language internal;

-- BRIN multi minmax int8 distance
create function pg_catalog.brin_minmax_multi_distance_int8(internal, internal) returns double precision
  language internal;

-- BRIN multi minmax interval distance
create function pg_catalog.brin_minmax_multi_distance_interval(internal, internal) returns double precision
  language internal;

-- BRIN multi minmax macaddr distance
create function pg_catalog.brin_minmax_multi_distance_macaddr(internal, internal) returns double precision
  language internal;

-- BRIN multi minmax macaddr8 distance
create function pg_catalog.brin_minmax_multi_distance_macaddr8(internal, internal) returns double precision
  language internal;

-- BRIN multi minmax numeric distance
create function pg_catalog.brin_minmax_multi_distance_numeric(internal, internal) returns double precision
  language internal;

-- BRIN multi minmax pg_lsn distance
create function pg_catalog.brin_minmax_multi_distance_pg_lsn(internal, internal) returns double precision
  language internal;

-- BRIN multi minmax tid distance
create function pg_catalog.brin_minmax_multi_distance_tid(internal, internal) returns double precision
  language internal;

-- BRIN multi minmax time distance
create function pg_catalog.brin_minmax_multi_distance_time(internal, internal) returns double precision
  language internal;

-- BRIN multi minmax timestamp distance
create function pg_catalog.brin_minmax_multi_distance_timestamp(internal, internal) returns double precision
  language internal;

-- BRIN multi minmax timetz distance
create function pg_catalog.brin_minmax_multi_distance_timetz(internal, internal) returns double precision
  language internal;

-- BRIN multi minmax uuid distance
create function pg_catalog.brin_minmax_multi_distance_uuid(internal, internal) returns double precision
  language internal;

-- BRIN multi minmax support
create function pg_catalog.brin_minmax_multi_opcinfo(internal) returns internal
  language internal;

-- BRIN multi minmax support
create function pg_catalog.brin_minmax_multi_options(internal) returns void
  language internal;

-- I/O
create function pg_catalog.brin_minmax_multi_summary_in(cstring) returns pg_brin_minmax_multi_summary
  language internal;

-- I/O
create function pg_catalog.brin_minmax_multi_summary_out(pg_brin_minmax_multi_summary) returns cstring
  language internal;

-- I/O
create function pg_catalog.brin_minmax_multi_summary_recv(internal) returns pg_brin_minmax_multi_summary
  language internal;

-- I/O
create function pg_catalog.brin_minmax_multi_summary_send(pg_brin_minmax_multi_summary) returns bytea
  language internal;

-- BRIN multi minmax support
create function pg_catalog.brin_minmax_multi_union(internal, internal, internal) returns boolean
  language internal;

-- BRIN minmax support
create function pg_catalog.brin_minmax_opcinfo(internal) returns internal
  language internal;

-- BRIN minmax support
create function pg_catalog.brin_minmax_union(internal, internal, internal) returns boolean
  language internal;

-- brin: standalone scan new table pages
create function pg_catalog.brin_summarize_new_values(regclass) returns integer
  language internal;

-- brin: standalone scan new table pages
create function pg_catalog.brin_summarize_range(regclass, bigint) returns integer
  language internal;

-- brin index access method handler
create function pg_catalog.brinhandler(internal) returns index_am_handler
  language internal;

-- broadcast address of network
create function pg_catalog.broadcast(inet) returns inet
  language internal;

-- less-equal-greater
create function pg_catalog.btarraycmp(anyarray, anyarray) returns integer
  language internal;

-- less-equal-greater
create function pg_catalog.btboolcmp(boolean, boolean) returns integer
  language internal;

-- skip support
create function pg_catalog.btboolskipsupport(internal) returns void
  language internal;

-- less-equal-greater
create function pg_catalog.btbpchar_pattern_cmp(character, character) returns integer
  language internal;

-- sort support
create function pg_catalog.btbpchar_pattern_sortsupport(internal) returns void
  language internal;

-- less-equal-greater
create function pg_catalog.btcharcmp("char", "char") returns integer
  language internal;

-- skip support
create function pg_catalog.btcharskipsupport(internal) returns void
  language internal;

-- equal image
create function pg_catalog.btequalimage(oid) returns boolean
  language internal;

-- less-equal-greater
create function pg_catalog.btfloat48cmp(real, double precision) returns integer
  language internal;

-- less-equal-greater
create function pg_catalog.btfloat4cmp(real, real) returns integer
  language internal;

-- sort support
create function pg_catalog.btfloat4sortsupport(internal) returns void
  language internal;

-- less-equal-greater
create function pg_catalog.btfloat84cmp(double precision, real) returns integer
  language internal;

-- less-equal-greater
create function pg_catalog.btfloat8cmp(double precision, double precision) returns integer
  language internal;

-- sort support
create function pg_catalog.btfloat8sortsupport(internal) returns void
  language internal;

-- btree index access method handler
create function pg_catalog.bthandler(internal) returns index_am_handler
  language internal;

-- less-equal-greater
create function pg_catalog.btint24cmp(smallint, integer) returns integer
  language internal;

-- less-equal-greater
create function pg_catalog.btint28cmp(smallint, bigint) returns integer
  language internal;

-- less-equal-greater
create function pg_catalog.btint2cmp(smallint, smallint) returns integer
  language internal;

-- skip support
create function pg_catalog.btint2skipsupport(internal) returns void
  language internal;

-- sort support
create function pg_catalog.btint2sortsupport(internal) returns void
  language internal;

-- less-equal-greater
create function pg_catalog.btint42cmp(integer, smallint) returns integer
  language internal;

-- less-equal-greater
create function pg_catalog.btint48cmp(integer, bigint) returns integer
  language internal;

-- less-equal-greater
create function pg_catalog.btint4cmp(integer, integer) returns integer
  language internal;

-- skip support
create function pg_catalog.btint4skipsupport(internal) returns void
  language internal;

-- sort support
create function pg_catalog.btint4sortsupport(internal) returns void
  language internal;

-- less-equal-greater
create function pg_catalog.btint82cmp(bigint, smallint) returns integer
  language internal;

-- less-equal-greater
create function pg_catalog.btint84cmp(bigint, integer) returns integer
  language internal;

-- less-equal-greater
create function pg_catalog.btint8cmp(bigint, bigint) returns integer
  language internal;

-- skip support
create function pg_catalog.btint8skipsupport(internal) returns void
  language internal;

-- sort support
create function pg_catalog.btint8sortsupport(internal) returns void
  language internal;

-- less-equal-greater
create function pg_catalog.btnamecmp(name, name) returns integer
  language internal;

-- sort support
create function pg_catalog.btnamesortsupport(internal) returns void
  language internal;

-- less-equal-greater
create function pg_catalog.btnametextcmp(name, text) returns integer
  language internal;

-- less-equal-greater
create function pg_catalog.btoidcmp(oid, oid) returns integer
  language internal;

-- skip support
create function pg_catalog.btoidskipsupport(internal) returns void
  language internal;

-- sort support
create function pg_catalog.btoidsortsupport(internal) returns void
  language internal;

-- less-equal-greater
create function pg_catalog.btoidvectorcmp(oidvector, oidvector) returns integer
  language internal;

-- less-equal-greater
create function pg_catalog.btrecordcmp(record, record) returns integer
  language internal;

-- less-equal-greater based on byte images
create function pg_catalog.btrecordimagecmp(record, record) returns integer
  language internal;

-- trim selected bytes from both ends of string
create function pg_catalog.btrim(bytea, bytea) returns bytea
  language internal;

-- trim spaces from both ends of string
create function pg_catalog.btrim(text) returns text
  language internal;

-- trim selected characters from both ends of string
create function pg_catalog.btrim(text, text) returns text
  language internal;

-- less-equal-greater
create function pg_catalog.bttext_pattern_cmp(text, text) returns integer
  language internal;

-- sort support
create function pg_catalog.bttext_pattern_sortsupport(internal) returns void
  language internal;

-- less-equal-greater
create function pg_catalog.bttextcmp(text, text) returns integer
  language internal;

-- less-equal-greater
create function pg_catalog.bttextnamecmp(text, name) returns integer
  language internal;

-- sort support
create function pg_catalog.bttextsortsupport(internal) returns void
  language internal;

-- less-equal-greater
create function pg_catalog.bttidcmp(tid, tid) returns integer
  language internal;

-- equal image
create function pg_catalog.btvarstrequalimage(oid) returns boolean
  language internal;

-- convert int8 to bytea
create function pg_catalog.bytea(bigint) returns bytea
  language internal;

-- convert int4 to bytea
create function pg_catalog.bytea(integer) returns bytea
  language internal;

-- convert int2 to bytea
create function pg_catalog.bytea(smallint) returns bytea
  language internal;

-- larger of two
create function pg_catalog.bytea_larger(bytea, bytea) returns bytea
  language internal;

-- smaller of two
create function pg_catalog.bytea_smaller(bytea, bytea) returns bytea
  language internal;

-- sort support
create function pg_catalog.bytea_sortsupport(internal) returns void
  language internal;

-- aggregate final function
create function pg_catalog.bytea_string_agg_finalfn(internal) returns bytea
  language internal;

-- aggregate transition function
create function pg_catalog.bytea_string_agg_transfn(internal, bytea, bytea) returns internal
  language internal;

-- implementation of || operator
create function pg_catalog.byteacat(bytea, bytea) returns bytea
  language internal;

-- less-equal-greater
create function pg_catalog.byteacmp(bytea, bytea) returns integer
  language internal;

-- implementation of = operator
create function pg_catalog.byteaeq(bytea, bytea) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.byteage(bytea, bytea) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.byteagt(bytea, bytea) returns boolean
  language internal;

-- I/O
create function pg_catalog.byteain(cstring) returns bytea
  language internal;

-- implementation of <= operator
create function pg_catalog.byteale(bytea, bytea) returns boolean
  language internal;

-- implementation of ~~ operator
create function pg_catalog.bytealike(bytea, bytea) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.bytealt(bytea, bytea) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.byteane(bytea, bytea) returns boolean
  language internal;

-- implementation of !~~ operator
create function pg_catalog.byteanlike(bytea, bytea) returns boolean
  language internal;

-- I/O
create function pg_catalog.byteaout(bytea) returns cstring
  language internal;

-- I/O
create function pg_catalog.bytearecv(internal) returns bytea
  language internal;

-- I/O
create function pg_catalog.byteasend(bytea) returns bytea
  language internal;

-- array cardinality
create function pg_catalog.cardinality(anyarray) returns integer
  language internal;

-- fold case
create function pg_catalog.casefold(text) returns text
  language internal;

-- less-equal-greater
create function pg_catalog.cash_cmp(money, money) returns integer
  language internal;

-- implementation of / operator
create function pg_catalog.cash_div_cash(money, money) returns double precision
  language internal;

-- implementation of / operator
create function pg_catalog.cash_div_flt4(money, real) returns money
  language internal;

-- implementation of / operator
create function pg_catalog.cash_div_flt8(money, double precision) returns money
  language internal;

-- implementation of / operator
create function pg_catalog.cash_div_int2(money, smallint) returns money
  language internal;

-- implementation of / operator
create function pg_catalog.cash_div_int4(money, integer) returns money
  language internal;

-- implementation of / operator
create function pg_catalog.cash_div_int8(money, bigint) returns money
  language internal;

-- implementation of = operator
create function pg_catalog.cash_eq(money, money) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.cash_ge(money, money) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.cash_gt(money, money) returns boolean
  language internal;

-- I/O
create function pg_catalog.cash_in(cstring) returns money
  language internal;

-- implementation of <= operator
create function pg_catalog.cash_le(money, money) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.cash_lt(money, money) returns boolean
  language internal;

-- implementation of - operator
create function pg_catalog.cash_mi(money, money) returns money
  language internal;

-- implementation of * operator
create function pg_catalog.cash_mul_flt4(money, real) returns money
  language internal;

-- implementation of * operator
create function pg_catalog.cash_mul_flt8(money, double precision) returns money
  language internal;

-- implementation of * operator
create function pg_catalog.cash_mul_int2(money, smallint) returns money
  language internal;

-- implementation of * operator
create function pg_catalog.cash_mul_int4(money, integer) returns money
  language internal;

-- implementation of * operator
create function pg_catalog.cash_mul_int8(money, bigint) returns money
  language internal;

-- implementation of <> operator
create function pg_catalog.cash_ne(money, money) returns boolean
  language internal;

-- I/O
create function pg_catalog.cash_out(money) returns cstring
  language internal;

-- implementation of + operator
create function pg_catalog.cash_pl(money, money) returns money
  language internal;

-- I/O
create function pg_catalog.cash_recv(internal) returns money
  language internal;

-- I/O
create function pg_catalog.cash_send(money) returns bytea
  language internal;

-- output money amount as words
create function pg_catalog.cash_words(money) returns text
  language internal;

-- larger of two
create function pg_catalog.cashlarger(money, money) returns money
  language internal;

-- smaller of two
create function pg_catalog.cashsmaller(money, money) returns money
  language internal;

-- cube root
create function pg_catalog.cbrt(double precision) returns double precision
  language internal;

-- nearest integer >= value
create function pg_catalog.ceil(double precision) returns double precision
  language internal;

-- nearest integer >= value
create function pg_catalog.ceil(numeric) returns numeric
  language internal;

-- nearest integer >= value
create function pg_catalog.ceiling(double precision) returns double precision
  language internal;

-- nearest integer >= value
create function pg_catalog.ceiling(numeric) returns numeric
  language internal;

-- center of
create function pg_catalog.center(box) returns point
  language internal;

-- center of
create function pg_catalog.center(circle) returns point
  language internal;

-- convert int4 to char
create function pg_catalog.char(integer) returns "char"
  language internal;

-- convert text to char
create function pg_catalog.char(text) returns "char"
  language internal;

-- character length
create function pg_catalog.char_length(character) returns integer
  language internal;

-- character length
create function pg_catalog.char_length(text) returns integer
  language internal;

-- character length
create function pg_catalog.character_length(character) returns integer
  language internal;

-- character length
create function pg_catalog.character_length(text) returns integer
  language internal;

-- implementation of = operator
create function pg_catalog.chareq("char", "char") returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.charge("char", "char") returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.chargt("char", "char") returns boolean
  language internal;

-- I/O
create function pg_catalog.charin(cstring) returns "char"
  language internal;

-- implementation of <= operator
create function pg_catalog.charle("char", "char") returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.charlt("char", "char") returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.charne("char", "char") returns boolean
  language internal;

-- I/O
create function pg_catalog.charout("char") returns cstring
  language internal;

-- I/O
create function pg_catalog.charrecv(internal) returns "char"
  language internal;

-- I/O
create function pg_catalog.charsend("char") returns bytea
  language internal;

-- convert int4 to char
create function pg_catalog.chr(integer) returns text
  language internal;

-- implementation of = operator
create function pg_catalog.cideq(cid, cid) returns boolean
  language internal;

-- I/O
create function pg_catalog.cidin(cstring) returns cid
  language internal;

-- I/O
create function pg_catalog.cidout(cid) returns cstring
  language internal;

-- convert inet to cidr
create function pg_catalog.cidr(inet) returns cidr
  language internal;

-- I/O
create function pg_catalog.cidr_in(cstring) returns cidr
  language internal;

-- I/O
create function pg_catalog.cidr_out(cidr) returns cstring
  language internal;

-- I/O
create function pg_catalog.cidr_recv(internal) returns cidr
  language internal;

-- I/O
create function pg_catalog.cidr_send(cidr) returns bytea
  language internal;

-- I/O
create function pg_catalog.cidrecv(internal) returns cid
  language internal;

-- I/O
create function pg_catalog.cidsend(cid) returns bytea
  language internal;

-- convert box to circle
create function pg_catalog.circle(box) returns circle
  language internal;

-- convert point and radius to circle
create function pg_catalog.circle(point, double precision) returns circle
  language internal;

-- convert polygon to circle
create function pg_catalog.circle(polygon) returns circle
  language internal;

-- implementation of |>> operator
create function pg_catalog.circle_above(circle, circle) returns boolean
  language internal;

-- implementation of + operator
create function pg_catalog.circle_add_pt(circle, point) returns circle
  language internal;

-- implementation of <<| operator
create function pg_catalog.circle_below(circle, circle) returns boolean
  language internal;

-- implementation of @@ operator
create function pg_catalog.circle_center(circle) returns point
  language internal;

-- implementation of @> operator
create function pg_catalog.circle_contain(circle, circle) returns boolean
  language internal;

-- implementation of @> operator
create function pg_catalog.circle_contain_pt(circle, point) returns boolean
  language internal;

-- implementation of <@ operator
create function pg_catalog.circle_contained(circle, circle) returns boolean
  language internal;

-- implementation of <-> operator
create function pg_catalog.circle_distance(circle, circle) returns double precision
  language internal;

-- implementation of / operator
create function pg_catalog.circle_div_pt(circle, point) returns circle
  language internal;

-- implementation of = operator
create function pg_catalog.circle_eq(circle, circle) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.circle_ge(circle, circle) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.circle_gt(circle, circle) returns boolean
  language internal;

-- I/O
create function pg_catalog.circle_in(cstring) returns circle
  language internal;

-- implementation of <= operator
create function pg_catalog.circle_le(circle, circle) returns boolean
  language internal;

-- implementation of << operator
create function pg_catalog.circle_left(circle, circle) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.circle_lt(circle, circle) returns boolean
  language internal;

-- implementation of * operator
create function pg_catalog.circle_mul_pt(circle, point) returns circle
  language internal;

-- implementation of <> operator
create function pg_catalog.circle_ne(circle, circle) returns boolean
  language internal;

-- I/O
create function pg_catalog.circle_out(circle) returns cstring
  language internal;

-- implementation of |&> operator
create function pg_catalog.circle_overabove(circle, circle) returns boolean
  language internal;

-- implementation of &<| operator
create function pg_catalog.circle_overbelow(circle, circle) returns boolean
  language internal;

-- implementation of && operator
create function pg_catalog.circle_overlap(circle, circle) returns boolean
  language internal;

-- implementation of &< operator
create function pg_catalog.circle_overleft(circle, circle) returns boolean
  language internal;

-- implementation of &> operator
create function pg_catalog.circle_overright(circle, circle) returns boolean
  language internal;

-- I/O
create function pg_catalog.circle_recv(internal) returns circle
  language internal;

-- implementation of >> operator
create function pg_catalog.circle_right(circle, circle) returns boolean
  language internal;

-- implementation of ~= operator
create function pg_catalog.circle_same(circle, circle) returns boolean
  language internal;

-- I/O
create function pg_catalog.circle_send(circle) returns bytea
  language internal;

-- implementation of - operator
create function pg_catalog.circle_sub_pt(circle, point) returns circle
  language internal;

-- current clock time
create function pg_catalog.clock_timestamp() returns timestamp with time zone
  language internal;

-- implementation of ## operator
create function pg_catalog.close_ls(line, lseg) returns point
  language internal;

-- implementation of ## operator
create function pg_catalog.close_lseg(lseg, lseg) returns point
  language internal;

-- implementation of ## operator
create function pg_catalog.close_pb(point, box) returns point
  language internal;

-- implementation of ## operator
create function pg_catalog.close_pl(point, line) returns point
  language internal;

-- implementation of ## operator
create function pg_catalog.close_ps(point, lseg) returns point
  language internal;

-- implementation of ## operator
create function pg_catalog.close_sb(lseg, box) returns point
  language internal;

-- get description for table column
create function pg_catalog.col_description(oid, integer) returns text
  language sql;

-- concatenate values
create function pg_catalog.concat(VARIADIC "any") returns text
  language internal;

-- concatenate values with separators
create function pg_catalog.concat_ws(text, VARIADIC "any") returns text
  language internal;

-- join selectivity for containment comparison operators
create function pg_catalog.contjoinsel(internal, oid, internal, smallint, internal) returns double precision
  language internal;

-- restriction selectivity for containment comparison operators
create function pg_catalog.contsel(internal, oid, internal, integer) returns double precision
  language internal;

-- convert string with specified encoding names
create function pg_catalog.convert(bytea, name, name) returns bytea
  language internal;

-- convert string with specified source encoding name
create function pg_catalog.convert_from(bytea, name) returns text
  language internal;

-- convert string with specified destination encoding name
create function pg_catalog.convert_to(text, name) returns bytea
  language internal;

-- correlation coefficient
create aggregate pg_catalog.corr(double precision, double precision) (
  sfunc = float8_regr_accum,
  stype = double precision[],
  finalfunc = float8_corr,
  combinefunc = float8_regr_combine,
  initcond = '{0,0,0,0,0,0}'
);

-- cosine
create function pg_catalog.cos(double precision) returns double precision
  language internal;

-- cosine, degrees
create function pg_catalog.cosd(double precision) returns double precision
  language internal;

-- hyperbolic cosine
create function pg_catalog.cosh(double precision) returns double precision
  language internal;

-- cotangent
create function pg_catalog.cot(double precision) returns double precision
  language internal;

-- cotangent, degrees
create function pg_catalog.cotd(double precision) returns double precision
  language internal;

-- number of input rows
create aggregate pg_catalog.count(*) (
  sfunc = int8inc,
  stype = bigint,
  combinefunc = int8pl,
  initcond = '0'
);

-- number of input rows for which the input expression is not null
create aggregate pg_catalog.count("any") (
  sfunc = int8inc_any,
  stype = bigint,
  combinefunc = int8pl,
  initcond = '0'
);

-- population covariance
create aggregate pg_catalog.covar_pop(double precision, double precision) (
  sfunc = float8_regr_accum,
  stype = double precision[],
  finalfunc = float8_covar_pop,
  combinefunc = float8_regr_combine,
  initcond = '{0,0,0,0,0,0}'
);

-- sample covariance
create aggregate pg_catalog.covar_samp(double precision, double precision) (
  sfunc = float8_regr_accum,
  stype = double precision[],
  finalfunc = float8_covar_samp,
  combinefunc = float8_regr_combine,
  initcond = '{0,0,0,0,0,0}'
);

-- CRC-32 value
create function pg_catalog.crc32(bytea) returns bigint
  language internal;

-- CRC-32C value
create function pg_catalog.crc32c(bytea) returns bigint
  language internal;

-- I/O
create function pg_catalog.cstring_in(cstring) returns cstring
  language internal;

-- I/O
create function pg_catalog.cstring_out(cstring) returns cstring
  language internal;

-- I/O
create function pg_catalog.cstring_recv(internal) returns cstring
  language internal;

-- I/O
create function pg_catalog.cstring_send(cstring) returns bytea
  language internal;

-- fractional row number within partition
create function pg_catalog.cume_dist() returns double precision
  language internal;

-- aggregate final function
create function pg_catalog.cume_dist_final(internal, VARIADIC "any") returns double precision
  language internal;

-- name of the current database
create function pg_catalog.current_database() returns name
  language internal;

-- get the currently executing query
create function pg_catalog.current_query() returns text
  language internal;

-- current schema name
create function pg_catalog.current_schema() returns name
  language internal;

-- current schema search list
create function pg_catalog.current_schemas(boolean) returns name[]
  language internal;

-- SHOW X as a function
create function pg_catalog.current_setting(text) returns text
  language internal;

-- SHOW X as a function, optionally no error for missing variable
create function pg_catalog.current_setting(text, boolean) returns text
  language internal;

-- current user name
create function pg_catalog.current_user() returns name
  language internal;

-- latest tid of a tuple
create function pg_catalog.currtid2(text, tid) returns tid
  language internal;

-- sequence current value
create function pg_catalog.currval(regclass) returns bigint
  language internal;

-- map rows from cursor to XML
create function pg_catalog.cursor_to_xml(cursor refcursor, count integer, nulls boolean, tableforest boolean, targetns text) returns xml
  language internal;

-- map cursor structure to XML Schema
create function pg_catalog.cursor_to_xmlschema(cursor refcursor, nulls boolean, tableforest boolean, targetns text) returns xml
  language internal;

-- map database contents to XML
create function pg_catalog.database_to_xml(nulls boolean, tableforest boolean, targetns text) returns xml
  language internal;

-- map database contents and structure to XML and XML Schema
create function pg_catalog.database_to_xml_and_xmlschema(nulls boolean, tableforest boolean, targetns text) returns xml
  language internal;

-- map database structure to XML Schema
create function pg_catalog.database_to_xmlschema(nulls boolean, tableforest boolean, targetns text) returns xml
  language internal;

-- convert timestamp with time zone to date
create function pg_catalog.date(timestamp with time zone) returns date
  language internal;

-- convert timestamp to date
create function pg_catalog.date(timestamp without time zone) returns date
  language internal;

-- add interval to timestamp with time zone
create function pg_catalog.date_add(timestamp with time zone, interval) returns timestamp with time zone
  language internal;

-- add interval to timestamp with time zone in specified time zone
create function pg_catalog.date_add(timestamp with time zone, interval, text) returns timestamp with time zone
  language internal;

-- bin timestamp with time zone into specified interval
create function pg_catalog.date_bin(interval, timestamp with time zone, timestamp with time zone) returns timestamp with time zone
  language internal;

-- bin timestamp into specified interval
create function pg_catalog.date_bin(interval, timestamp without time zone, timestamp without time zone) returns timestamp without time zone
  language internal;

-- less-equal-greater
create function pg_catalog.date_cmp(date, date) returns integer
  language internal;

-- less-equal-greater
create function pg_catalog.date_cmp_timestamp(date, timestamp without time zone) returns integer
  language internal;

-- less-equal-greater
create function pg_catalog.date_cmp_timestamptz(date, timestamp with time zone) returns integer
  language internal;

-- implementation of = operator
create function pg_catalog.date_eq(date, date) returns boolean
  language internal;

-- implementation of = operator
create function pg_catalog.date_eq_timestamp(date, timestamp without time zone) returns boolean
  language internal;

-- implementation of = operator
create function pg_catalog.date_eq_timestamptz(date, timestamp with time zone) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.date_ge(date, date) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.date_ge_timestamp(date, timestamp without time zone) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.date_ge_timestamptz(date, timestamp with time zone) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.date_gt(date, date) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.date_gt_timestamp(date, timestamp without time zone) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.date_gt_timestamptz(date, timestamp with time zone) returns boolean
  language internal;

-- I/O
create function pg_catalog.date_in(cstring) returns date
  language internal;

-- larger of two
create function pg_catalog.date_larger(date, date) returns date
  language internal;

-- implementation of <= operator
create function pg_catalog.date_le(date, date) returns boolean
  language internal;

-- implementation of <= operator
create function pg_catalog.date_le_timestamp(date, timestamp without time zone) returns boolean
  language internal;

-- implementation of <= operator
create function pg_catalog.date_le_timestamptz(date, timestamp with time zone) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.date_lt(date, date) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.date_lt_timestamp(date, timestamp without time zone) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.date_lt_timestamptz(date, timestamp with time zone) returns boolean
  language internal;

-- implementation of - operator
create function pg_catalog.date_mi(date, date) returns integer
  language internal;

-- implementation of - operator
create function pg_catalog.date_mi_interval(date, interval) returns timestamp without time zone
  language internal;

-- implementation of - operator
create function pg_catalog.date_mii(date, integer) returns date
  language internal;

-- implementation of <> operator
create function pg_catalog.date_ne(date, date) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.date_ne_timestamp(date, timestamp without time zone) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.date_ne_timestamptz(date, timestamp with time zone) returns boolean
  language internal;

-- I/O
create function pg_catalog.date_out(date) returns cstring
  language internal;

-- extract field from date
create function pg_catalog.date_part(text, date) returns double precision
  language sql;

-- extract field from interval
create function pg_catalog.date_part(text, interval) returns double precision
  language internal;

-- extract field from time with time zone
create function pg_catalog.date_part(text, time with time zone) returns double precision
  language internal;

-- extract field from time
create function pg_catalog.date_part(text, time without time zone) returns double precision
  language internal;

-- extract field from timestamp with time zone
create function pg_catalog.date_part(text, timestamp with time zone) returns double precision
  language internal;

-- extract field from timestamp
create function pg_catalog.date_part(text, timestamp without time zone) returns double precision
  language internal;

-- implementation of + operator
create function pg_catalog.date_pl_interval(date, interval) returns timestamp without time zone
  language internal;

-- implementation of + operator
create function pg_catalog.date_pli(date, integer) returns date
  language internal;

-- I/O
create function pg_catalog.date_recv(internal) returns date
  language internal;

-- I/O
create function pg_catalog.date_send(date) returns bytea
  language internal;

-- skip support
create function pg_catalog.date_skipsupport(internal) returns void
  language internal;

-- smaller of two
create function pg_catalog.date_smaller(date, date) returns date
  language internal;

-- sort support
create function pg_catalog.date_sortsupport(internal) returns void
  language internal;

-- subtract interval from timestamp with time zone
create function pg_catalog.date_subtract(timestamp with time zone, interval) returns timestamp with time zone
  language internal;

-- subtract interval from timestamp with time zone in specified time zone
create function pg_catalog.date_subtract(timestamp with time zone, interval, text) returns timestamp with time zone
  language internal;

-- truncate interval to specified units
create function pg_catalog.date_trunc(text, interval) returns interval
  language internal;

-- truncate timestamp with time zone to specified units
create function pg_catalog.date_trunc(text, timestamp with time zone) returns timestamp with time zone
  language internal;

-- truncate timestamp with time zone to specified units in specified time zone
create function pg_catalog.date_trunc(text, timestamp with time zone, text) returns timestamp with time zone
  language internal;

-- truncate timestamp to specified units
create function pg_catalog.date_trunc(text, timestamp without time zone) returns timestamp without time zone
  language internal;

-- datemultirange constructor
create function pg_catalog.datemultirange() returns datemultirange
  language internal;

-- datemultirange constructor
create function pg_catalog.datemultirange(daterange) returns datemultirange
  language internal;

-- datemultirange constructor
create function pg_catalog.datemultirange(VARIADIC daterange[]) returns datemultirange
  language internal;

-- daterange constructor
create function pg_catalog.daterange(date, date) returns daterange
  language internal;

-- daterange constructor
create function pg_catalog.daterange(date, date, text) returns daterange
  language internal;

-- convert a date range to canonical form
create function pg_catalog.daterange_canonical(daterange) returns daterange
  language internal;

-- float8 difference of two date values
create function pg_catalog.daterange_subdiff(date, date) returns double precision
  language internal;

-- implementation of + operator
create function pg_catalog.datetime_pl(date, time without time zone) returns timestamp without time zone
  language internal;

-- implementation of + operator
create function pg_catalog.datetimetz_pl(date, time with time zone) returns timestamp with time zone
  language internal;

-- implementation of ||/ operator
create function pg_catalog.dcbrt(double precision) returns double precision
  language internal;

-- convert ascii-encoded text string into bytea value
create function pg_catalog.decode(text, text) returns bytea
  language internal;

-- radians to degrees
create function pg_catalog.degrees(double precision) returns double precision
  language internal;

-- integer rank without gaps
create function pg_catalog.dense_rank() returns bigint
  language internal;

-- aggregate final function
create function pg_catalog.dense_rank_final(internal, VARIADIC "any") returns bigint
  language internal;

-- natural exponential (e^x)
create function pg_catalog.dexp(double precision) returns double precision
  language internal;

-- box diagonal
create function pg_catalog.diagonal(box) returns lseg
  language internal;

-- diameter of circle
create function pg_catalog.diameter(circle) returns double precision
  language internal;

-- (internal)
create function pg_catalog.dispell_init(internal) returns internal
  language internal;

-- (internal)
create function pg_catalog.dispell_lexize(internal, internal, internal, internal) returns internal
  language internal;

-- implementation of <-> operator
create function pg_catalog.dist_bp(box, point) returns double precision
  language internal;

-- implementation of <-> operator
create function pg_catalog.dist_bs(box, lseg) returns double precision
  language internal;

-- implementation of <-> operator
create function pg_catalog.dist_cpoint(circle, point) returns double precision
  language internal;

-- implementation of <-> operator
create function pg_catalog.dist_cpoly(circle, polygon) returns double precision
  language internal;

-- implementation of <-> operator
create function pg_catalog.dist_lp(line, point) returns double precision
  language internal;

-- implementation of <-> operator
create function pg_catalog.dist_ls(line, lseg) returns double precision
  language internal;

-- implementation of <-> operator
create function pg_catalog.dist_pathp(path, point) returns double precision
  language internal;

-- implementation of <-> operator
create function pg_catalog.dist_pb(point, box) returns double precision
  language internal;

-- implementation of <-> operator
create function pg_catalog.dist_pc(point, circle) returns double precision
  language internal;

-- implementation of <-> operator
create function pg_catalog.dist_pl(point, line) returns double precision
  language internal;

-- implementation of <-> operator
create function pg_catalog.dist_polyc(polygon, circle) returns double precision
  language internal;

-- implementation of <-> operator
create function pg_catalog.dist_polyp(polygon, point) returns double precision
  language internal;

-- implementation of <-> operator
create function pg_catalog.dist_ppath(point, path) returns double precision
  language internal;

-- implementation of <-> operator
create function pg_catalog.dist_ppoly(point, polygon) returns double precision
  language internal;

-- implementation of <-> operator
create function pg_catalog.dist_ps(point, lseg) returns double precision
  language internal;

-- implementation of <-> operator
create function pg_catalog.dist_sb(lseg, box) returns double precision
  language internal;

-- implementation of <-> operator
create function pg_catalog.dist_sl(lseg, line) returns double precision
  language internal;

-- implementation of <-> operator
create function pg_catalog.dist_sp(lseg, point) returns double precision
  language internal;

-- trunc(x/y)
create function pg_catalog.div(numeric, numeric) returns numeric
  language internal;

-- natural logarithm
create function pg_catalog.dlog1(double precision) returns double precision
  language internal;

-- base 10 logarithm
create function pg_catalog.dlog10(double precision) returns double precision
  language internal;

-- I/O
create function pg_catalog.domain_in(cstring, oid, integer) returns "any"
  language internal;

-- I/O
create function pg_catalog.domain_recv(internal, oid, integer) returns "any"
  language internal;

-- implementation of ^ operator
create function pg_catalog.dpow(double precision, double precision) returns double precision
  language internal;

-- round to nearest integer
create function pg_catalog.dround(double precision) returns double precision
  language internal;

-- (internal)
create function pg_catalog.dsimple_init(internal) returns internal
  language internal;

-- (internal)
create function pg_catalog.dsimple_lexize(internal, internal, internal, internal) returns internal
  language internal;

create function pg_catalog.dsnowball_init(internal) returns internal
  language c;

create function pg_catalog.dsnowball_lexize(internal, internal, internal, internal) returns internal
  language c;

-- implementation of |/ operator
create function pg_catalog.dsqrt(double precision) returns double precision
  language internal;

-- (internal)
create function pg_catalog.dsynonym_init(internal) returns internal
  language internal;

-- (internal)
create function pg_catalog.dsynonym_lexize(internal, internal, internal, internal) returns internal
  language internal;

-- truncate to integer
create function pg_catalog.dtrunc(double precision) returns double precision
  language internal;

-- implementation of <@ operator
create function pg_catalog.elem_contained_by_multirange(anyelement, anymultirange) returns boolean
  language internal;

-- implementation of <@ operator
create function pg_catalog.elem_contained_by_range(anyelement, anyrange) returns boolean
  language internal;

-- planner support for elem_contained_by_range
create function pg_catalog.elem_contained_by_range_support(internal) returns internal
  language internal;

-- convert bytea value into some ascii-only text string
create function pg_catalog.encode(bytea, text) returns text
  language internal;

-- less-equal-greater
create function pg_catalog.enum_cmp(anyenum, anyenum) returns integer
  language internal;

-- implementation of = operator
create function pg_catalog.enum_eq(anyenum, anyenum) returns boolean
  language internal;

-- first value of the input enum type
create function pg_catalog.enum_first(anyenum) returns anyenum
  language internal;

-- implementation of >= operator
create function pg_catalog.enum_ge(anyenum, anyenum) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.enum_gt(anyenum, anyenum) returns boolean
  language internal;

-- I/O
create function pg_catalog.enum_in(cstring, oid) returns anyenum
  language internal;

-- larger of two
create function pg_catalog.enum_larger(anyenum, anyenum) returns anyenum
  language internal;

-- last value of the input enum type
create function pg_catalog.enum_last(anyenum) returns anyenum
  language internal;

-- implementation of <= operator
create function pg_catalog.enum_le(anyenum, anyenum) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.enum_lt(anyenum, anyenum) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.enum_ne(anyenum, anyenum) returns boolean
  language internal;

-- I/O
create function pg_catalog.enum_out(anyenum) returns cstring
  language internal;

-- range of the given enum type, as an ordered array
create function pg_catalog.enum_range(anyenum) returns anyarray
  language internal;

-- range between the two given enum values, as an ordered array
create function pg_catalog.enum_range(anyenum, anyenum) returns anyarray
  language internal;

-- I/O
create function pg_catalog.enum_recv(internal, oid) returns anyenum
  language internal;

-- I/O
create function pg_catalog.enum_send(anyenum) returns bytea
  language internal;

-- smaller of two
create function pg_catalog.enum_smaller(anyenum, anyenum) returns anyenum
  language internal;

-- join selectivity of = and related operators
create function pg_catalog.eqjoinsel(internal, oid, internal, smallint, internal) returns double precision
  language internal;

-- restriction selectivity of = and related operators
create function pg_catalog.eqsel(internal, oid, internal, integer) returns double precision
  language internal;

-- error function
create function pg_catalog.erf(double precision) returns double precision
  language internal;

-- complementary error function
create function pg_catalog.erfc(double precision) returns double precision
  language internal;

-- internal conversion function for EUC_CN to MULE_INTERNAL
create function pg_catalog.euc_cn_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for EUC_CN to UTF8
create function pg_catalog.euc_cn_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for EUC_JIS_2004 to SHIFT_JIS_2004
create function pg_catalog.euc_jis_2004_to_shift_jis_2004(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for EUC_JIS_2004 to UTF8
create function pg_catalog.euc_jis_2004_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for EUC_JP to MULE_INTERNAL
create function pg_catalog.euc_jp_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for EUC_JP to SJIS
create function pg_catalog.euc_jp_to_sjis(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for EUC_JP to UTF8
create function pg_catalog.euc_jp_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for EUC_KR to MULE_INTERNAL
create function pg_catalog.euc_kr_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for EUC_KR to UTF8
create function pg_catalog.euc_kr_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for EUC_TW to BIG5
create function pg_catalog.euc_tw_to_big5(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for EUC_TW to MULE_INTERNAL
create function pg_catalog.euc_tw_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for EUC_TW to UTF8
create function pg_catalog.euc_tw_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- I/O
create function pg_catalog.event_trigger_in(cstring) returns event_trigger
  language internal;

-- I/O
create function pg_catalog.event_trigger_out(event_trigger) returns cstring
  language internal;

-- boolean-and aggregate
create aggregate pg_catalog.every(boolean) (
  sfunc = booland_statefunc,
  stype = boolean,
  combinefunc = booland_statefunc
);

-- natural exponential (e^x)
create function pg_catalog.exp(double precision) returns double precision
  language internal;

-- natural exponential (e^x)
create function pg_catalog.exp(numeric) returns numeric
  language internal;

-- extract field from date
create function pg_catalog.extract(text, date) returns numeric
  language internal;

-- extract field from interval
create function pg_catalog.extract(text, interval) returns numeric
  language internal;

-- extract field from time with time zone
create function pg_catalog.extract(text, time with time zone) returns numeric
  language internal;

-- extract field from time
create function pg_catalog.extract(text, time without time zone) returns numeric
  language internal;

-- extract field from timestamp with time zone
create function pg_catalog.extract(text, timestamp with time zone) returns numeric
  language internal;

-- extract field from timestamp
create function pg_catalog.extract(text, timestamp without time zone) returns numeric
  language internal;

-- factorial
create function pg_catalog.factorial(bigint) returns numeric
  language internal;

-- address family (4 for IPv4, 6 for IPv6)
create function pg_catalog.family(inet) returns integer
  language internal;

-- I/O
create function pg_catalog.fdw_handler_in(cstring) returns fdw_handler
  language internal;

-- I/O
create function pg_catalog.fdw_handler_out(fdw_handler) returns cstring
  language internal;

-- fetch the first row value
create function pg_catalog.first_value(anyelement) returns anyelement
  language internal;

-- convert int8 to float4
create function pg_catalog.float4(bigint) returns real
  language internal;

-- convert float8 to float4
create function pg_catalog.float4(double precision) returns real
  language internal;

-- convert int4 to float4
create function pg_catalog.float4(integer) returns real
  language internal;

-- convert jsonb to float4
create function pg_catalog.float4(jsonb) returns real
  language internal;

-- convert numeric to float4
create function pg_catalog.float4(numeric) returns real
  language internal;

-- convert int2 to float4
create function pg_catalog.float4(smallint) returns real
  language internal;

-- implementation of / operator
create function pg_catalog.float48div(real, double precision) returns double precision
  language internal;

-- implementation of = operator
create function pg_catalog.float48eq(real, double precision) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.float48ge(real, double precision) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.float48gt(real, double precision) returns boolean
  language internal;

-- implementation of <= operator
create function pg_catalog.float48le(real, double precision) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.float48lt(real, double precision) returns boolean
  language internal;

-- implementation of - operator
create function pg_catalog.float48mi(real, double precision) returns double precision
  language internal;

-- implementation of * operator
create function pg_catalog.float48mul(real, double precision) returns double precision
  language internal;

-- implementation of <> operator
create function pg_catalog.float48ne(real, double precision) returns boolean
  language internal;

-- implementation of + operator
create function pg_catalog.float48pl(real, double precision) returns double precision
  language internal;

-- aggregate transition function
create function pg_catalog.float4_accum(double precision[], real) returns double precision[]
  language internal;

-- implementation of @ operator
create function pg_catalog.float4abs(real) returns real
  language internal;

-- implementation of / operator
create function pg_catalog.float4div(real, real) returns real
  language internal;

-- implementation of = operator
create function pg_catalog.float4eq(real, real) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.float4ge(real, real) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.float4gt(real, real) returns boolean
  language internal;

-- I/O
create function pg_catalog.float4in(cstring) returns real
  language internal;

-- larger of two
create function pg_catalog.float4larger(real, real) returns real
  language internal;

-- implementation of <= operator
create function pg_catalog.float4le(real, real) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.float4lt(real, real) returns boolean
  language internal;

-- implementation of - operator
create function pg_catalog.float4mi(real, real) returns real
  language internal;

-- implementation of * operator
create function pg_catalog.float4mul(real, real) returns real
  language internal;

-- implementation of <> operator
create function pg_catalog.float4ne(real, real) returns boolean
  language internal;

-- I/O
create function pg_catalog.float4out(real) returns cstring
  language internal;

-- implementation of + operator
create function pg_catalog.float4pl(real, real) returns real
  language internal;

-- I/O
create function pg_catalog.float4recv(internal) returns real
  language internal;

-- I/O
create function pg_catalog.float4send(real) returns bytea
  language internal;

-- smaller of two
create function pg_catalog.float4smaller(real, real) returns real
  language internal;

-- implementation of - operator
create function pg_catalog.float4um(real) returns real
  language internal;

-- implementation of + operator
create function pg_catalog.float4up(real) returns real
  language internal;

-- convert int8 to float8
create function pg_catalog.float8(bigint) returns double precision
  language internal;

-- convert int4 to float8
create function pg_catalog.float8(integer) returns double precision
  language internal;

-- convert jsonb to float8
create function pg_catalog.float8(jsonb) returns double precision
  language internal;

-- convert numeric to float8
create function pg_catalog.float8(numeric) returns double precision
  language internal;

-- convert float4 to float8
create function pg_catalog.float8(real) returns double precision
  language internal;

-- convert int2 to float8
create function pg_catalog.float8(smallint) returns double precision
  language internal;

-- implementation of / operator
create function pg_catalog.float84div(double precision, real) returns double precision
  language internal;

-- implementation of = operator
create function pg_catalog.float84eq(double precision, real) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.float84ge(double precision, real) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.float84gt(double precision, real) returns boolean
  language internal;

-- implementation of <= operator
create function pg_catalog.float84le(double precision, real) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.float84lt(double precision, real) returns boolean
  language internal;

-- implementation of - operator
create function pg_catalog.float84mi(double precision, real) returns double precision
  language internal;

-- implementation of * operator
create function pg_catalog.float84mul(double precision, real) returns double precision
  language internal;

-- implementation of <> operator
create function pg_catalog.float84ne(double precision, real) returns boolean
  language internal;

-- implementation of + operator
create function pg_catalog.float84pl(double precision, real) returns double precision
  language internal;

-- aggregate transition function
create function pg_catalog.float8_accum(double precision[], double precision) returns double precision[]
  language internal;

-- aggregate final function
create function pg_catalog.float8_avg(double precision[]) returns double precision
  language internal;

-- aggregate combine function
create function pg_catalog.float8_combine(double precision[], double precision[]) returns double precision[]
  language internal;

-- aggregate final function
create function pg_catalog.float8_corr(double precision[]) returns double precision
  language internal;

-- aggregate final function
create function pg_catalog.float8_covar_pop(double precision[]) returns double precision
  language internal;

-- aggregate final function
create function pg_catalog.float8_covar_samp(double precision[]) returns double precision
  language internal;

-- aggregate transition function
create function pg_catalog.float8_regr_accum(double precision[], double precision, double precision) returns double precision[]
  language internal;

-- aggregate final function
create function pg_catalog.float8_regr_avgx(double precision[]) returns double precision
  language internal;

-- aggregate final function
create function pg_catalog.float8_regr_avgy(double precision[]) returns double precision
  language internal;

-- aggregate combine function
create function pg_catalog.float8_regr_combine(double precision[], double precision[]) returns double precision[]
  language internal;

-- aggregate final function
create function pg_catalog.float8_regr_intercept(double precision[]) returns double precision
  language internal;

-- aggregate final function
create function pg_catalog.float8_regr_r2(double precision[]) returns double precision
  language internal;

-- aggregate final function
create function pg_catalog.float8_regr_slope(double precision[]) returns double precision
  language internal;

-- aggregate final function
create function pg_catalog.float8_regr_sxx(double precision[]) returns double precision
  language internal;

-- aggregate final function
create function pg_catalog.float8_regr_sxy(double precision[]) returns double precision
  language internal;

-- aggregate final function
create function pg_catalog.float8_regr_syy(double precision[]) returns double precision
  language internal;

-- aggregate final function
create function pg_catalog.float8_stddev_pop(double precision[]) returns double precision
  language internal;

-- aggregate final function
create function pg_catalog.float8_stddev_samp(double precision[]) returns double precision
  language internal;

-- aggregate final function
create function pg_catalog.float8_var_pop(double precision[]) returns double precision
  language internal;

-- aggregate final function
create function pg_catalog.float8_var_samp(double precision[]) returns double precision
  language internal;

-- implementation of @ operator
create function pg_catalog.float8abs(double precision) returns double precision
  language internal;

-- implementation of / operator
create function pg_catalog.float8div(double precision, double precision) returns double precision
  language internal;

-- implementation of = operator
create function pg_catalog.float8eq(double precision, double precision) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.float8ge(double precision, double precision) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.float8gt(double precision, double precision) returns boolean
  language internal;

-- I/O
create function pg_catalog.float8in(cstring) returns double precision
  language internal;

-- larger of two
create function pg_catalog.float8larger(double precision, double precision) returns double precision
  language internal;

-- implementation of <= operator
create function pg_catalog.float8le(double precision, double precision) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.float8lt(double precision, double precision) returns boolean
  language internal;

-- implementation of - operator
create function pg_catalog.float8mi(double precision, double precision) returns double precision
  language internal;

-- implementation of * operator
create function pg_catalog.float8mul(double precision, double precision) returns double precision
  language internal;

-- implementation of <> operator
create function pg_catalog.float8ne(double precision, double precision) returns boolean
  language internal;

-- I/O
create function pg_catalog.float8out(double precision) returns cstring
  language internal;

-- implementation of + operator
create function pg_catalog.float8pl(double precision, double precision) returns double precision
  language internal;

-- I/O
create function pg_catalog.float8recv(internal) returns double precision
  language internal;

-- I/O
create function pg_catalog.float8send(double precision) returns bytea
  language internal;

-- smaller of two
create function pg_catalog.float8smaller(double precision, double precision) returns double precision
  language internal;

-- implementation of - operator
create function pg_catalog.float8um(double precision) returns double precision
  language internal;

-- implementation of + operator
create function pg_catalog.float8up(double precision) returns double precision
  language internal;

-- nearest integer <= value
create function pg_catalog.floor(double precision) returns double precision
  language internal;

-- nearest integer <= value
create function pg_catalog.floor(numeric) returns numeric
  language internal;

-- implementation of * operator
create function pg_catalog.flt4_mul_cash(real, money) returns money
  language internal;

-- implementation of * operator
create function pg_catalog.flt8_mul_cash(double precision, money) returns money
  language internal;

-- (internal)
create function pg_catalog.fmgr_c_validator(oid) returns void
  language internal;

-- (internal)
create function pg_catalog.fmgr_internal_validator(oid) returns void
  language internal;

-- (internal)
create function pg_catalog.fmgr_sql_validator(oid) returns void
  language internal;

-- format text message
create function pg_catalog.format(text) returns text
  language internal;

-- format text message
create function pg_catalog.format(text, VARIADIC "any") returns text
  language internal;

-- format a type oid and atttypmod to canonical SQL
create function pg_catalog.format_type(oid, integer) returns text
  language internal;

-- gamma function
create function pg_catalog.gamma(double precision) returns double precision
  language internal;

-- internal conversion function for GB18030 to UTF8
create function pg_catalog.gb18030_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for GBK to UTF8
create function pg_catalog.gbk_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- greatest common divisor
create function pg_catalog.gcd(bigint, bigint) returns bigint
  language internal;

-- greatest common divisor
create function pg_catalog.gcd(integer, integer) returns integer
  language internal;

-- greatest common divisor
create function pg_catalog.gcd(numeric, numeric) returns numeric
  language internal;

-- generate random UUID
create function pg_catalog.gen_random_uuid() returns uuid
  language internal;

-- non-persistent series generator
create function pg_catalog.generate_series(bigint, bigint) returns SETOF bigint
  language internal;

-- non-persistent series generator
create function pg_catalog.generate_series(bigint, bigint, bigint) returns SETOF bigint
  language internal;

-- non-persistent series generator
create function pg_catalog.generate_series(integer, integer) returns SETOF integer
  language internal;

-- non-persistent series generator
create function pg_catalog.generate_series(integer, integer, integer) returns SETOF integer
  language internal;

-- non-persistent series generator
create function pg_catalog.generate_series(numeric, numeric) returns SETOF numeric
  language internal;

-- non-persistent series generator
create function pg_catalog.generate_series(numeric, numeric, numeric) returns SETOF numeric
  language internal;

-- non-persistent series generator
create function pg_catalog.generate_series(timestamp with time zone, timestamp with time zone, interval) returns SETOF timestamp with time zone
  language internal;

-- non-persistent series generator
create function pg_catalog.generate_series(timestamp with time zone, timestamp with time zone, interval, text) returns SETOF timestamp with time zone
  language internal;

-- non-persistent series generator
create function pg_catalog.generate_series(timestamp without time zone, timestamp without time zone, interval) returns SETOF timestamp without time zone
  language internal;

-- planner support for generate_series
create function pg_catalog.generate_series_int4_support(internal) returns internal
  language internal;

-- planner support for generate_series
create function pg_catalog.generate_series_int8_support(internal) returns internal
  language internal;

-- planner support for generate_series
create function pg_catalog.generate_series_numeric_support(internal) returns internal
  language internal;

-- planner support for generate_series
create function pg_catalog.generate_series_timestamp_support(internal) returns internal
  language internal;

-- array subscripts generator
create function pg_catalog.generate_subscripts(anyarray, integer) returns SETOF integer
  language internal;

-- array subscripts generator
create function pg_catalog.generate_subscripts(anyarray, integer, boolean) returns SETOF integer
  language internal;

-- get bit
create function pg_catalog.get_bit(bit, integer) returns integer
  language internal;

-- get bit
create function pg_catalog.get_bit(bytea, bigint) returns integer
  language internal;

-- get byte
create function pg_catalog.get_byte(bytea, integer) returns integer
  language internal;

-- get current tsearch configuration
create function pg_catalog.get_current_ts_config() returns regconfig
  language internal;

-- encoding name of current database
create function pg_catalog.getdatabaseencoding() returns name
  language internal;

-- deprecated, use current_user instead
create function pg_catalog.getpgusername() returns name
  language internal;

-- clean up GIN pending list
create function pg_catalog.gin_clean_pending_list(regclass) returns bigint
  language internal;

-- GIN tsvector support
create function pg_catalog.gin_cmp_prefix(text, text, smallint, internal) returns integer
  language internal;

-- GIN tsvector support
create function pg_catalog.gin_cmp_tslexeme(text, text) returns integer
  language internal;

-- GIN support
create function pg_catalog.gin_compare_jsonb(text, text) returns integer
  language internal;

-- GIN support
create function pg_catalog.gin_consistent_jsonb(internal, smallint, jsonb, integer, internal, internal, internal, internal) returns boolean
  language internal;

-- GIN support
create function pg_catalog.gin_consistent_jsonb_path(internal, smallint, jsonb, integer, internal, internal, internal, internal) returns boolean
  language internal;

-- GIN support
create function pg_catalog.gin_extract_jsonb(jsonb, internal, internal) returns internal
  language internal;

-- GIN support
create function pg_catalog.gin_extract_jsonb_path(jsonb, internal, internal) returns internal
  language internal;

-- GIN support
create function pg_catalog.gin_extract_jsonb_query(jsonb, internal, smallint, internal, internal, internal, internal) returns internal
  language internal;

-- GIN support
create function pg_catalog.gin_extract_jsonb_query_path(jsonb, internal, smallint, internal, internal, internal, internal) returns internal
  language internal;

-- GIN tsvector support (obsolete)
create function pg_catalog.gin_extract_tsquery(tsquery, internal, smallint, internal, internal) returns internal
  language internal;

-- GIN tsvector support (obsolete)
create function pg_catalog.gin_extract_tsquery(tsquery, internal, smallint, internal, internal, internal, internal) returns internal
  language internal;

-- GIN tsvector support
create function pg_catalog.gin_extract_tsquery(tsvector, internal, smallint, internal, internal, internal, internal) returns internal
  language internal;

-- GIN tsvector support (obsolete)
create function pg_catalog.gin_extract_tsvector(tsvector, internal) returns internal
  language internal;

-- GIN tsvector support
create function pg_catalog.gin_extract_tsvector(tsvector, internal, internal) returns internal
  language internal;

-- GIN support
create function pg_catalog.gin_triconsistent_jsonb(internal, smallint, jsonb, integer, internal, internal, internal) returns "char"
  language internal;

-- GIN support
create function pg_catalog.gin_triconsistent_jsonb_path(internal, smallint, jsonb, integer, internal, internal, internal) returns "char"
  language internal;

-- GIN tsvector support (obsolete)
create function pg_catalog.gin_tsquery_consistent(internal, smallint, tsquery, integer, internal, internal) returns boolean
  language internal;

-- GIN tsvector support (obsolete)
create function pg_catalog.gin_tsquery_consistent(internal, smallint, tsquery, integer, internal, internal, internal, internal) returns boolean
  language internal;

-- GIN tsvector support
create function pg_catalog.gin_tsquery_consistent(internal, smallint, tsvector, integer, internal, internal, internal, internal) returns boolean
  language internal;

-- GIN tsvector support
create function pg_catalog.gin_tsquery_triconsistent(internal, smallint, tsvector, integer, internal, internal, internal) returns "char"
  language internal;

-- GIN array support
create function pg_catalog.ginarrayconsistent(internal, smallint, anyarray, integer, internal, internal, internal, internal) returns boolean
  language internal;

-- GIN array support (obsolete)
create function pg_catalog.ginarrayextract(anyarray, internal) returns internal
  language internal;

-- GIN array support
create function pg_catalog.ginarrayextract(anyarray, internal, internal) returns internal
  language internal;

-- GIN array support
create function pg_catalog.ginarraytriconsistent(internal, smallint, anyarray, integer, internal, internal, internal) returns "char"
  language internal;

-- gin index access method handler
create function pg_catalog.ginhandler(internal) returns index_am_handler
  language internal;

-- GIN array support
create function pg_catalog.ginqueryarrayextract(anyarray, internal, smallint, internal, internal, internal, internal) returns internal
  language internal;

-- GiST support
create function pg_catalog.gist_box_consistent(internal, box, smallint, oid, internal) returns boolean
  language internal;

-- GiST support
create function pg_catalog.gist_box_distance(internal, box, smallint, oid, internal) returns double precision
  language internal;

-- GiST support
create function pg_catalog.gist_box_penalty(internal, internal, internal) returns internal
  language internal;

-- GiST support
create function pg_catalog.gist_box_picksplit(internal, internal) returns internal
  language internal;

-- GiST support
create function pg_catalog.gist_box_same(box, box, internal) returns internal
  language internal;

-- GiST support
create function pg_catalog.gist_box_union(internal, internal) returns box
  language internal;

-- GiST support
create function pg_catalog.gist_circle_compress(internal) returns internal
  language internal;

-- GiST support
create function pg_catalog.gist_circle_consistent(internal, circle, smallint, oid, internal) returns boolean
  language internal;

-- GiST support
create function pg_catalog.gist_circle_distance(internal, circle, smallint, oid, internal) returns double precision
  language internal;

-- GiST support
create function pg_catalog.gist_point_compress(internal) returns internal
  language internal;

-- GiST support
create function pg_catalog.gist_point_consistent(internal, point, smallint, oid, internal) returns boolean
  language internal;

-- GiST support
create function pg_catalog.gist_point_distance(internal, point, smallint, oid, internal) returns double precision
  language internal;

-- GiST support
create function pg_catalog.gist_point_fetch(internal) returns internal
  language internal;

-- sort support
create function pg_catalog.gist_point_sortsupport(internal) returns void
  language internal;

-- GiST support
create function pg_catalog.gist_poly_compress(internal) returns internal
  language internal;

-- GiST support
create function pg_catalog.gist_poly_consistent(internal, polygon, smallint, oid, internal) returns boolean
  language internal;

-- GiST support
create function pg_catalog.gist_poly_distance(internal, polygon, smallint, oid, internal) returns double precision
  language internal;

-- GiST support
create function pg_catalog.gist_translate_cmptype_common(integer) returns smallint
  language internal;

-- gist index access method handler
create function pg_catalog.gisthandler(internal) returns index_am_handler
  language internal;

-- GiST tsquery support
create function pg_catalog.gtsquery_compress(internal) returns internal
  language internal;

-- GiST tsquery support (obsolete)
create function pg_catalog.gtsquery_consistent(internal, internal, integer, oid, internal) returns boolean
  language internal;

-- GiST tsquery support
create function pg_catalog.gtsquery_consistent(internal, tsquery, smallint, oid, internal) returns boolean
  language internal;

-- GiST tsquery support
create function pg_catalog.gtsquery_penalty(internal, internal, internal) returns internal
  language internal;

-- GiST tsquery support
create function pg_catalog.gtsquery_picksplit(internal, internal) returns internal
  language internal;

-- GiST tsquery support
create function pg_catalog.gtsquery_same(bigint, bigint, internal) returns internal
  language internal;

-- GiST tsquery support
create function pg_catalog.gtsquery_union(internal, internal) returns bigint
  language internal;

-- GiST tsvector support
create function pg_catalog.gtsvector_compress(internal) returns internal
  language internal;

-- GiST tsvector support (obsolete)
create function pg_catalog.gtsvector_consistent(internal, gtsvector, integer, oid, internal) returns boolean
  language internal;

-- GiST tsvector support
create function pg_catalog.gtsvector_consistent(internal, tsvector, smallint, oid, internal) returns boolean
  language internal;

-- GiST tsvector support
create function pg_catalog.gtsvector_decompress(internal) returns internal
  language internal;

-- GiST tsvector support
create function pg_catalog.gtsvector_options(internal) returns void
  language internal;

-- GiST tsvector support
create function pg_catalog.gtsvector_penalty(internal, internal, internal) returns internal
  language internal;

-- GiST tsvector support
create function pg_catalog.gtsvector_picksplit(internal, internal) returns internal
  language internal;

-- GiST tsvector support
create function pg_catalog.gtsvector_same(gtsvector, gtsvector, internal) returns internal
  language internal;

-- GiST tsvector support
create function pg_catalog.gtsvector_union(internal, internal) returns gtsvector
  language internal;

-- I/O
create function pg_catalog.gtsvectorin(cstring) returns gtsvector
  language internal;

-- I/O
create function pg_catalog.gtsvectorout(gtsvector) returns cstring
  language internal;

-- user privilege on any column by username, rel oid
create function pg_catalog.has_any_column_privilege(name, oid, text) returns boolean
  language internal;

-- user privilege on any column by username, rel name
create function pg_catalog.has_any_column_privilege(name, text, text) returns boolean
  language internal;

-- user privilege on any column by user oid, rel oid
create function pg_catalog.has_any_column_privilege(oid, oid, text) returns boolean
  language internal;

-- current user privilege on any column by rel oid
create function pg_catalog.has_any_column_privilege(oid, text) returns boolean
  language internal;

-- user privilege on any column by user oid, rel name
create function pg_catalog.has_any_column_privilege(oid, text, text) returns boolean
  language internal;

-- current user privilege on any column by rel name
create function pg_catalog.has_any_column_privilege(text, text) returns boolean
  language internal;

-- user privilege on column by username, rel oid, col attnum
create function pg_catalog.has_column_privilege(name, oid, smallint, text) returns boolean
  language internal;

-- user privilege on column by username, rel oid, col name
create function pg_catalog.has_column_privilege(name, oid, text, text) returns boolean
  language internal;

-- user privilege on column by username, rel name, col attnum
create function pg_catalog.has_column_privilege(name, text, smallint, text) returns boolean
  language internal;

-- user privilege on column by username, rel name, col name
create function pg_catalog.has_column_privilege(name, text, text, text) returns boolean
  language internal;

-- user privilege on column by user oid, rel oid, col attnum
create function pg_catalog.has_column_privilege(oid, oid, smallint, text) returns boolean
  language internal;

-- user privilege on column by user oid, rel oid, col name
create function pg_catalog.has_column_privilege(oid, oid, text, text) returns boolean
  language internal;

-- current user privilege on column by rel oid, col attnum
create function pg_catalog.has_column_privilege(oid, smallint, text) returns boolean
  language internal;

-- user privilege on column by user oid, rel name, col attnum
create function pg_catalog.has_column_privilege(oid, text, smallint, text) returns boolean
  language internal;

-- current user privilege on column by rel oid, col name
create function pg_catalog.has_column_privilege(oid, text, text) returns boolean
  language internal;

-- user privilege on column by user oid, rel name, col name
create function pg_catalog.has_column_privilege(oid, text, text, text) returns boolean
  language internal;

-- current user privilege on column by rel name, col attnum
create function pg_catalog.has_column_privilege(text, smallint, text) returns boolean
  language internal;

-- current user privilege on column by rel name, col name
create function pg_catalog.has_column_privilege(text, text, text) returns boolean
  language internal;

-- user privilege on database by username, database oid
create function pg_catalog.has_database_privilege(name, oid, text) returns boolean
  language internal;

-- user privilege on database by username, database name
create function pg_catalog.has_database_privilege(name, text, text) returns boolean
  language internal;

-- user privilege on database by user oid, database oid
create function pg_catalog.has_database_privilege(oid, oid, text) returns boolean
  language internal;

-- current user privilege on database by database oid
create function pg_catalog.has_database_privilege(oid, text) returns boolean
  language internal;

-- user privilege on database by user oid, database name
create function pg_catalog.has_database_privilege(oid, text, text) returns boolean
  language internal;

-- current user privilege on database by database name
create function pg_catalog.has_database_privilege(text, text) returns boolean
  language internal;

-- user privilege on foreign data wrapper by username, foreign data wrapper oid
create function pg_catalog.has_foreign_data_wrapper_privilege(name, oid, text) returns boolean
  language internal;

-- user privilege on foreign data wrapper by username, foreign data wrapper name
create function pg_catalog.has_foreign_data_wrapper_privilege(name, text, text) returns boolean
  language internal;

-- user privilege on foreign data wrapper by user oid, foreign data wrapper oid
create function pg_catalog.has_foreign_data_wrapper_privilege(oid, oid, text) returns boolean
  language internal;

-- current user privilege on foreign data wrapper by foreign data wrapper oid
create function pg_catalog.has_foreign_data_wrapper_privilege(oid, text) returns boolean
  language internal;

-- user privilege on foreign data wrapper by user oid, foreign data wrapper name
create function pg_catalog.has_foreign_data_wrapper_privilege(oid, text, text) returns boolean
  language internal;

-- current user privilege on foreign data wrapper by foreign data wrapper name
create function pg_catalog.has_foreign_data_wrapper_privilege(text, text) returns boolean
  language internal;

-- user privilege on function by username, function oid
create function pg_catalog.has_function_privilege(name, oid, text) returns boolean
  language internal;

-- user privilege on function by username, function name
create function pg_catalog.has_function_privilege(name, text, text) returns boolean
  language internal;

-- user privilege on function by user oid, function oid
create function pg_catalog.has_function_privilege(oid, oid, text) returns boolean
  language internal;

-- current user privilege on function by function oid
create function pg_catalog.has_function_privilege(oid, text) returns boolean
  language internal;

-- user privilege on function by user oid, function name
create function pg_catalog.has_function_privilege(oid, text, text) returns boolean
  language internal;

-- current user privilege on function by function name
create function pg_catalog.has_function_privilege(text, text) returns boolean
  language internal;

-- user privilege on language by username, language oid
create function pg_catalog.has_language_privilege(name, oid, text) returns boolean
  language internal;

-- user privilege on language by username, language name
create function pg_catalog.has_language_privilege(name, text, text) returns boolean
  language internal;

-- user privilege on language by user oid, language oid
create function pg_catalog.has_language_privilege(oid, oid, text) returns boolean
  language internal;

-- current user privilege on language by language oid
create function pg_catalog.has_language_privilege(oid, text) returns boolean
  language internal;

-- user privilege on language by user oid, language name
create function pg_catalog.has_language_privilege(oid, text, text) returns boolean
  language internal;

-- current user privilege on language by language name
create function pg_catalog.has_language_privilege(text, text) returns boolean
  language internal;

-- user privilege on large object by username, large object oid
create function pg_catalog.has_largeobject_privilege(name, oid, text) returns boolean
  language internal;

-- user privilege on large object by user oid, large object oid
create function pg_catalog.has_largeobject_privilege(oid, oid, text) returns boolean
  language internal;

-- current user privilege on large object by large object oid
create function pg_catalog.has_largeobject_privilege(oid, text) returns boolean
  language internal;

-- user privilege on parameter by username, parameter name
create function pg_catalog.has_parameter_privilege(name, text, text) returns boolean
  language internal;

-- user privilege on parameter by user oid, parameter name
create function pg_catalog.has_parameter_privilege(oid, text, text) returns boolean
  language internal;

-- current user privilege on parameter by parameter name
create function pg_catalog.has_parameter_privilege(text, text) returns boolean
  language internal;

-- user privilege on schema by username, schema oid
create function pg_catalog.has_schema_privilege(name, oid, text) returns boolean
  language internal;

-- user privilege on schema by username, schema name
create function pg_catalog.has_schema_privilege(name, text, text) returns boolean
  language internal;

-- user privilege on schema by user oid, schema oid
create function pg_catalog.has_schema_privilege(oid, oid, text) returns boolean
  language internal;

-- current user privilege on schema by schema oid
create function pg_catalog.has_schema_privilege(oid, text) returns boolean
  language internal;

-- user privilege on schema by user oid, schema name
create function pg_catalog.has_schema_privilege(oid, text, text) returns boolean
  language internal;

-- current user privilege on schema by schema name
create function pg_catalog.has_schema_privilege(text, text) returns boolean
  language internal;

-- user privilege on sequence by username, seq oid
create function pg_catalog.has_sequence_privilege(name, oid, text) returns boolean
  language internal;

-- user privilege on sequence by username, seq name
create function pg_catalog.has_sequence_privilege(name, text, text) returns boolean
  language internal;

-- user privilege on sequence by user oid, seq oid
create function pg_catalog.has_sequence_privilege(oid, oid, text) returns boolean
  language internal;

-- current user privilege on sequence by seq oid
create function pg_catalog.has_sequence_privilege(oid, text) returns boolean
  language internal;

-- user privilege on sequence by user oid, seq name
create function pg_catalog.has_sequence_privilege(oid, text, text) returns boolean
  language internal;

-- current user privilege on sequence by seq name
create function pg_catalog.has_sequence_privilege(text, text) returns boolean
  language internal;

-- user privilege on server by username, server oid
create function pg_catalog.has_server_privilege(name, oid, text) returns boolean
  language internal;

-- user privilege on server by username, server name
create function pg_catalog.has_server_privilege(name, text, text) returns boolean
  language internal;

-- user privilege on server by user oid, server oid
create function pg_catalog.has_server_privilege(oid, oid, text) returns boolean
  language internal;

-- current user privilege on server by server oid
create function pg_catalog.has_server_privilege(oid, text) returns boolean
  language internal;

-- user privilege on server by user oid, server name
create function pg_catalog.has_server_privilege(oid, text, text) returns boolean
  language internal;

-- current user privilege on server by server name
create function pg_catalog.has_server_privilege(text, text) returns boolean
  language internal;

-- user privilege on relation by username, rel oid
create function pg_catalog.has_table_privilege(name, oid, text) returns boolean
  language internal;

-- user privilege on relation by username, rel name
create function pg_catalog.has_table_privilege(name, text, text) returns boolean
  language internal;

-- user privilege on relation by user oid, rel oid
create function pg_catalog.has_table_privilege(oid, oid, text) returns boolean
  language internal;

-- current user privilege on relation by rel oid
create function pg_catalog.has_table_privilege(oid, text) returns boolean
  language internal;

-- user privilege on relation by user oid, rel name
create function pg_catalog.has_table_privilege(oid, text, text) returns boolean
  language internal;

-- current user privilege on relation by rel name
create function pg_catalog.has_table_privilege(text, text) returns boolean
  language internal;

-- user privilege on tablespace by username, tablespace oid
create function pg_catalog.has_tablespace_privilege(name, oid, text) returns boolean
  language internal;

-- user privilege on tablespace by username, tablespace name
create function pg_catalog.has_tablespace_privilege(name, text, text) returns boolean
  language internal;

-- user privilege on tablespace by user oid, tablespace oid
create function pg_catalog.has_tablespace_privilege(oid, oid, text) returns boolean
  language internal;

-- current user privilege on tablespace by tablespace oid
create function pg_catalog.has_tablespace_privilege(oid, text) returns boolean
  language internal;

-- user privilege on tablespace by user oid, tablespace name
create function pg_catalog.has_tablespace_privilege(oid, text, text) returns boolean
  language internal;

-- current user privilege on tablespace by tablespace name
create function pg_catalog.has_tablespace_privilege(text, text) returns boolean
  language internal;

-- user privilege on type by username, type oid
create function pg_catalog.has_type_privilege(name, oid, text) returns boolean
  language internal;

-- user privilege on type by username, type name
create function pg_catalog.has_type_privilege(name, text, text) returns boolean
  language internal;

-- user privilege on type by user oid, type oid
create function pg_catalog.has_type_privilege(oid, oid, text) returns boolean
  language internal;

-- current user privilege on type by type oid
create function pg_catalog.has_type_privilege(oid, text) returns boolean
  language internal;

-- user privilege on type by user oid, type name
create function pg_catalog.has_type_privilege(oid, text, text) returns boolean
  language internal;

-- current user privilege on type by type name
create function pg_catalog.has_type_privilege(text, text) returns boolean
  language internal;

-- hash
create function pg_catalog.hash_aclitem(aclitem) returns integer
  language internal;

-- hash
create function pg_catalog.hash_aclitem_extended(aclitem, bigint) returns bigint
  language internal;

-- hash
create function pg_catalog.hash_array(anyarray) returns integer
  language internal;

-- hash
create function pg_catalog.hash_array_extended(anyarray, bigint) returns bigint
  language internal;

-- hash a multirange
create function pg_catalog.hash_multirange(anymultirange) returns integer
  language internal;

-- hash a multirange
create function pg_catalog.hash_multirange_extended(anymultirange, bigint) returns bigint
  language internal;

-- hash
create function pg_catalog.hash_numeric(numeric) returns integer
  language internal;

-- hash
create function pg_catalog.hash_numeric_extended(numeric, bigint) returns bigint
  language internal;

-- hash a range
create function pg_catalog.hash_range(anyrange) returns integer
  language internal;

-- hash a range
create function pg_catalog.hash_range_extended(anyrange, bigint) returns bigint
  language internal;

-- hash
create function pg_catalog.hash_record(record) returns integer
  language internal;

-- hash
create function pg_catalog.hash_record_extended(record, bigint) returns bigint
  language internal;

-- hash
create function pg_catalog.hashbool(boolean) returns integer
  language internal;

-- hash
create function pg_catalog.hashboolextended(boolean, bigint) returns bigint
  language internal;

-- hash
create function pg_catalog.hashbpchar(character) returns integer
  language internal;

-- hash
create function pg_catalog.hashbpcharextended(character, bigint) returns bigint
  language internal;

-- hash
create function pg_catalog.hashbytea(bytea) returns integer
  language internal;

-- hash
create function pg_catalog.hashbyteaextended(bytea, bigint) returns bigint
  language internal;

-- hash
create function pg_catalog.hashchar("char") returns integer
  language internal;

-- hash
create function pg_catalog.hashcharextended("char", bigint) returns bigint
  language internal;

-- hash
create function pg_catalog.hashcid(cid) returns integer
  language internal;

-- hash
create function pg_catalog.hashcidextended(cid, bigint) returns bigint
  language internal;

-- hash
create function pg_catalog.hashdate(date) returns integer
  language internal;

-- hash
create function pg_catalog.hashdateextended(date, bigint) returns bigint
  language internal;

-- hash
create function pg_catalog.hashenum(anyenum) returns integer
  language internal;

-- hash
create function pg_catalog.hashenumextended(anyenum, bigint) returns bigint
  language internal;

-- hash
create function pg_catalog.hashfloat4(real) returns integer
  language internal;

-- hash
create function pg_catalog.hashfloat4extended(real, bigint) returns bigint
  language internal;

-- hash
create function pg_catalog.hashfloat8(double precision) returns integer
  language internal;

-- hash
create function pg_catalog.hashfloat8extended(double precision, bigint) returns bigint
  language internal;

-- hash index access method handler
create function pg_catalog.hashhandler(internal) returns index_am_handler
  language internal;

-- hash
create function pg_catalog.hashinet(inet) returns integer
  language internal;

-- hash
create function pg_catalog.hashinetextended(inet, bigint) returns bigint
  language internal;

-- hash
create function pg_catalog.hashint2(smallint) returns integer
  language internal;

-- hash
create function pg_catalog.hashint2extended(smallint, bigint) returns bigint
  language internal;

-- hash
create function pg_catalog.hashint4(integer) returns integer
  language internal;

-- hash
create function pg_catalog.hashint4extended(integer, bigint) returns bigint
  language internal;

-- hash
create function pg_catalog.hashint8(bigint) returns integer
  language internal;

-- hash
create function pg_catalog.hashint8extended(bigint, bigint) returns bigint
  language internal;

-- hash
create function pg_catalog.hashmacaddr(macaddr) returns integer
  language internal;

-- hash
create function pg_catalog.hashmacaddr8(macaddr8) returns integer
  language internal;

-- hash
create function pg_catalog.hashmacaddr8extended(macaddr8, bigint) returns bigint
  language internal;

-- hash
create function pg_catalog.hashmacaddrextended(macaddr, bigint) returns bigint
  language internal;

-- hash
create function pg_catalog.hashname(name) returns integer
  language internal;

-- hash
create function pg_catalog.hashnameextended(name, bigint) returns bigint
  language internal;

-- hash
create function pg_catalog.hashoid(oid) returns integer
  language internal;

-- hash
create function pg_catalog.hashoidextended(oid, bigint) returns bigint
  language internal;

-- hash
create function pg_catalog.hashoidvector(oidvector) returns integer
  language internal;

-- hash
create function pg_catalog.hashoidvectorextended(oidvector, bigint) returns bigint
  language internal;

-- hash
create function pg_catalog.hashtext(text) returns integer
  language internal;

-- hash
create function pg_catalog.hashtextextended(text, bigint) returns bigint
  language internal;

-- hash
create function pg_catalog.hashtid(tid) returns integer
  language internal;

-- hash
create function pg_catalog.hashtidextended(tid, bigint) returns bigint
  language internal;

-- hash
create function pg_catalog.hashvarlena(internal) returns integer
  language internal;

-- hash
create function pg_catalog.hashvarlenaextended(internal, bigint) returns bigint
  language internal;

-- hash
create function pg_catalog.hashxid(xid) returns integer
  language internal;

-- hash
create function pg_catalog.hashxid8(xid8) returns integer
  language internal;

-- hash
create function pg_catalog.hashxid8extended(xid8, bigint) returns bigint
  language internal;

-- hash
create function pg_catalog.hashxidextended(xid, bigint) returns bigint
  language internal;

-- row-oriented heap table access method handler
create function pg_catalog.heap_tableam_handler(internal) returns table_am_handler
  language internal;

-- box height
create function pg_catalog.height(box) returns double precision
  language internal;

-- show address octets only
create function pg_catalog.host(inet) returns text
  language internal;

-- hostmask of address
create function pg_catalog.hostmask(inet) returns inet
  language internal;

-- join selectivity of ILIKE
create function pg_catalog.iclikejoinsel(internal, oid, internal, smallint, internal) returns double precision
  language internal;

-- restriction selectivity of ILIKE
create function pg_catalog.iclikesel(internal, oid, internal, integer) returns double precision
  language internal;

-- join selectivity of NOT ILIKE
create function pg_catalog.icnlikejoinsel(internal, oid, internal, smallint, internal) returns double precision
  language internal;

-- restriction selectivity of NOT ILIKE
create function pg_catalog.icnlikesel(internal, oid, internal, integer) returns double precision
  language internal;

-- join selectivity of case-insensitive regex match
create function pg_catalog.icregexeqjoinsel(internal, oid, internal, smallint, internal) returns double precision
  language internal;

-- restriction selectivity of case-insensitive regex match
create function pg_catalog.icregexeqsel(internal, oid, internal, integer) returns double precision
  language internal;

-- join selectivity of case-insensitive regex non-match
create function pg_catalog.icregexnejoinsel(internal, oid, internal, smallint, internal) returns double precision
  language internal;

-- restriction selectivity of case-insensitive regex non-match
create function pg_catalog.icregexnesel(internal, oid, internal, integer) returns double precision
  language internal;

-- Unicode version used by ICU, if enabled
create function pg_catalog.icu_unicode_version() returns text
  language internal;

-- window RANGE support
create function pg_catalog.in_range(bigint, bigint, bigint, boolean, boolean) returns boolean
  language internal;

-- window RANGE support
create function pg_catalog.in_range(date, date, interval, boolean, boolean) returns boolean
  language internal;

-- window RANGE support
create function pg_catalog.in_range(double precision, double precision, double precision, boolean, boolean) returns boolean
  language internal;

-- window RANGE support
create function pg_catalog.in_range(integer, integer, bigint, boolean, boolean) returns boolean
  language internal;

-- window RANGE support
create function pg_catalog.in_range(integer, integer, integer, boolean, boolean) returns boolean
  language internal;

-- window RANGE support
create function pg_catalog.in_range(integer, integer, smallint, boolean, boolean) returns boolean
  language internal;

-- window RANGE support
create function pg_catalog.in_range(interval, interval, interval, boolean, boolean) returns boolean
  language internal;

-- window RANGE support
create function pg_catalog.in_range(numeric, numeric, numeric, boolean, boolean) returns boolean
  language internal;

-- window RANGE support
create function pg_catalog.in_range(real, real, double precision, boolean, boolean) returns boolean
  language internal;

-- window RANGE support
create function pg_catalog.in_range(smallint, smallint, bigint, boolean, boolean) returns boolean
  language internal;

-- window RANGE support
create function pg_catalog.in_range(smallint, smallint, integer, boolean, boolean) returns boolean
  language internal;

-- window RANGE support
create function pg_catalog.in_range(smallint, smallint, smallint, boolean, boolean) returns boolean
  language internal;

-- window RANGE support
create function pg_catalog.in_range(time with time zone, time with time zone, interval, boolean, boolean) returns boolean
  language internal;

-- window RANGE support
create function pg_catalog.in_range(time without time zone, time without time zone, interval, boolean, boolean) returns boolean
  language internal;

-- window RANGE support
create function pg_catalog.in_range(timestamp with time zone, timestamp with time zone, interval, boolean, boolean) returns boolean
  language internal;

-- window RANGE support
create function pg_catalog.in_range(timestamp without time zone, timestamp without time zone, interval, boolean, boolean) returns boolean
  language internal;

-- I/O
create function pg_catalog.index_am_handler_in(cstring) returns index_am_handler
  language internal;

-- I/O
create function pg_catalog.index_am_handler_out(index_am_handler) returns cstring
  language internal;

-- inet address of the client
create function pg_catalog.inet_client_addr() returns inet
  language internal;

-- client's port number for this connection
create function pg_catalog.inet_client_port() returns integer
  language internal;

-- GiST support
create function pg_catalog.inet_gist_compress(internal) returns internal
  language internal;

-- GiST support
create function pg_catalog.inet_gist_consistent(internal, inet, smallint, oid, internal) returns boolean
  language internal;

-- GiST support
create function pg_catalog.inet_gist_fetch(internal) returns internal
  language internal;

-- GiST support
create function pg_catalog.inet_gist_penalty(internal, internal, internal) returns internal
  language internal;

-- GiST support
create function pg_catalog.inet_gist_picksplit(internal, internal) returns internal
  language internal;

-- GiST support
create function pg_catalog.inet_gist_same(inet, inet, internal) returns internal
  language internal;

-- GiST support
create function pg_catalog.inet_gist_union(internal, internal) returns inet
  language internal;

-- I/O
create function pg_catalog.inet_in(cstring) returns inet
  language internal;

-- the smallest network which includes both of the given networks
create function pg_catalog.inet_merge(inet, inet) returns cidr
  language internal;

-- I/O
create function pg_catalog.inet_out(inet) returns cstring
  language internal;

-- I/O
create function pg_catalog.inet_recv(internal) returns inet
  language internal;

-- are the addresses from the same family?
create function pg_catalog.inet_same_family(inet, inet) returns boolean
  language internal;

-- I/O
create function pg_catalog.inet_send(inet) returns bytea
  language internal;

-- inet address of the server
create function pg_catalog.inet_server_addr() returns inet
  language internal;

-- server's port number for this connection
create function pg_catalog.inet_server_port() returns integer
  language internal;

-- SP-GiST support
create function pg_catalog.inet_spg_choose(internal, internal) returns void
  language internal;

-- SP-GiST support
create function pg_catalog.inet_spg_config(internal, internal) returns void
  language internal;

-- SP-GiST support
create function pg_catalog.inet_spg_inner_consistent(internal, internal) returns void
  language internal;

-- SP-GiST support
create function pg_catalog.inet_spg_leaf_consistent(internal, internal) returns boolean
  language internal;

-- SP-GiST support
create function pg_catalog.inet_spg_picksplit(internal, internal) returns void
  language internal;

-- implementation of & operator
create function pg_catalog.inetand(inet, inet) returns inet
  language internal;

-- implementation of - operator
create function pg_catalog.inetmi(inet, inet) returns bigint
  language internal;

-- implementation of - operator
create function pg_catalog.inetmi_int8(inet, bigint) returns inet
  language internal;

-- implementation of ~ operator
create function pg_catalog.inetnot(inet) returns inet
  language internal;

-- implementation of | operator
create function pg_catalog.inetor(inet, inet) returns inet
  language internal;

-- implementation of + operator
create function pg_catalog.inetpl(inet, bigint) returns inet
  language internal;

-- capitalize each word
create function pg_catalog.initcap(text) returns text
  language internal;

-- convert int8 to int2
create function pg_catalog.int2(bigint) returns smallint
  language internal;

-- convert bytea to int2
create function pg_catalog.int2(bytea) returns smallint
  language internal;

-- convert float8 to int2
create function pg_catalog.int2(double precision) returns smallint
  language internal;

-- convert int4 to int2
create function pg_catalog.int2(integer) returns smallint
  language internal;

-- convert jsonb to int2
create function pg_catalog.int2(jsonb) returns smallint
  language internal;

-- convert numeric to int2
create function pg_catalog.int2(numeric) returns smallint
  language internal;

-- convert float4 to int2
create function pg_catalog.int2(real) returns smallint
  language internal;

-- implementation of / operator
create function pg_catalog.int24div(smallint, integer) returns integer
  language internal;

-- implementation of = operator
create function pg_catalog.int24eq(smallint, integer) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.int24ge(smallint, integer) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.int24gt(smallint, integer) returns boolean
  language internal;

-- implementation of <= operator
create function pg_catalog.int24le(smallint, integer) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.int24lt(smallint, integer) returns boolean
  language internal;

-- implementation of - operator
create function pg_catalog.int24mi(smallint, integer) returns integer
  language internal;

-- implementation of * operator
create function pg_catalog.int24mul(smallint, integer) returns integer
  language internal;

-- implementation of <> operator
create function pg_catalog.int24ne(smallint, integer) returns boolean
  language internal;

-- implementation of + operator
create function pg_catalog.int24pl(smallint, integer) returns integer
  language internal;

-- implementation of / operator
create function pg_catalog.int28div(smallint, bigint) returns bigint
  language internal;

-- implementation of = operator
create function pg_catalog.int28eq(smallint, bigint) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.int28ge(smallint, bigint) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.int28gt(smallint, bigint) returns boolean
  language internal;

-- implementation of <= operator
create function pg_catalog.int28le(smallint, bigint) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.int28lt(smallint, bigint) returns boolean
  language internal;

-- implementation of - operator
create function pg_catalog.int28mi(smallint, bigint) returns bigint
  language internal;

-- implementation of * operator
create function pg_catalog.int28mul(smallint, bigint) returns bigint
  language internal;

-- implementation of <> operator
create function pg_catalog.int28ne(smallint, bigint) returns boolean
  language internal;

-- implementation of + operator
create function pg_catalog.int28pl(smallint, bigint) returns bigint
  language internal;

-- aggregate transition function
create function pg_catalog.int2_accum(internal, smallint) returns internal
  language internal;

-- aggregate transition function
create function pg_catalog.int2_accum_inv(internal, smallint) returns internal
  language internal;

-- aggregate transition function
create function pg_catalog.int2_avg_accum(bigint[], smallint) returns bigint[]
  language internal;

-- aggregate transition function
create function pg_catalog.int2_avg_accum_inv(bigint[], smallint) returns bigint[]
  language internal;

-- implementation of * operator
create function pg_catalog.int2_mul_cash(smallint, money) returns money
  language internal;

-- aggregate transition function
create function pg_catalog.int2_sum(bigint, smallint) returns bigint
  language internal;

-- implementation of @ operator
create function pg_catalog.int2abs(smallint) returns smallint
  language internal;

-- implementation of & operator
create function pg_catalog.int2and(smallint, smallint) returns smallint
  language internal;

-- implementation of / operator
create function pg_catalog.int2div(smallint, smallint) returns smallint
  language internal;

-- implementation of = operator
create function pg_catalog.int2eq(smallint, smallint) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.int2ge(smallint, smallint) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.int2gt(smallint, smallint) returns boolean
  language internal;

-- I/O
create function pg_catalog.int2in(cstring) returns smallint
  language internal;

-- aggregate final function
create function pg_catalog.int2int4_sum(bigint[]) returns bigint
  language internal;

-- larger of two
create function pg_catalog.int2larger(smallint, smallint) returns smallint
  language internal;

-- implementation of <= operator
create function pg_catalog.int2le(smallint, smallint) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.int2lt(smallint, smallint) returns boolean
  language internal;

-- implementation of - operator
create function pg_catalog.int2mi(smallint, smallint) returns smallint
  language internal;

-- implementation of % operator
create function pg_catalog.int2mod(smallint, smallint) returns smallint
  language internal;

-- implementation of * operator
create function pg_catalog.int2mul(smallint, smallint) returns smallint
  language internal;

-- implementation of <> operator
create function pg_catalog.int2ne(smallint, smallint) returns boolean
  language internal;

-- implementation of ~ operator
create function pg_catalog.int2not(smallint) returns smallint
  language internal;

-- implementation of | operator
create function pg_catalog.int2or(smallint, smallint) returns smallint
  language internal;

-- I/O
create function pg_catalog.int2out(smallint) returns cstring
  language internal;

-- implementation of + operator
create function pg_catalog.int2pl(smallint, smallint) returns smallint
  language internal;

-- I/O
create function pg_catalog.int2recv(internal) returns smallint
  language internal;

-- I/O
create function pg_catalog.int2send(smallint) returns bytea
  language internal;

-- implementation of << operator
create function pg_catalog.int2shl(smallint, integer) returns smallint
  language internal;

-- implementation of >> operator
create function pg_catalog.int2shr(smallint, integer) returns smallint
  language internal;

-- smaller of two
create function pg_catalog.int2smaller(smallint, smallint) returns smallint
  language internal;

-- implementation of - operator
create function pg_catalog.int2um(smallint) returns smallint
  language internal;

-- implementation of + operator
create function pg_catalog.int2up(smallint) returns smallint
  language internal;

-- I/O
create function pg_catalog.int2vectorin(cstring) returns int2vector
  language internal;

-- I/O
create function pg_catalog.int2vectorout(int2vector) returns cstring
  language internal;

-- I/O
create function pg_catalog.int2vectorrecv(internal) returns int2vector
  language internal;

-- I/O
create function pg_catalog.int2vectorsend(int2vector) returns bytea
  language internal;

-- implementation of # operator
create function pg_catalog.int2xor(smallint, smallint) returns smallint
  language internal;

-- convert char to int4
create function pg_catalog.int4("char") returns integer
  language internal;

-- convert int8 to int4
create function pg_catalog.int4(bigint) returns integer
  language internal;

-- convert bitstring to int4
create function pg_catalog.int4(bit) returns integer
  language internal;

-- convert boolean to int4
create function pg_catalog.int4(boolean) returns integer
  language internal;

-- convert bytea to int4
create function pg_catalog.int4(bytea) returns integer
  language internal;

-- convert float8 to int4
create function pg_catalog.int4(double precision) returns integer
  language internal;

-- convert jsonb to int4
create function pg_catalog.int4(jsonb) returns integer
  language internal;

-- convert numeric to int4
create function pg_catalog.int4(numeric) returns integer
  language internal;

-- convert float4 to int4
create function pg_catalog.int4(real) returns integer
  language internal;

-- convert int2 to int4
create function pg_catalog.int4(smallint) returns integer
  language internal;

-- implementation of / operator
create function pg_catalog.int42div(integer, smallint) returns integer
  language internal;

-- implementation of = operator
create function pg_catalog.int42eq(integer, smallint) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.int42ge(integer, smallint) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.int42gt(integer, smallint) returns boolean
  language internal;

-- implementation of <= operator
create function pg_catalog.int42le(integer, smallint) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.int42lt(integer, smallint) returns boolean
  language internal;

-- implementation of - operator
create function pg_catalog.int42mi(integer, smallint) returns integer
  language internal;

-- implementation of * operator
create function pg_catalog.int42mul(integer, smallint) returns integer
  language internal;

-- implementation of <> operator
create function pg_catalog.int42ne(integer, smallint) returns boolean
  language internal;

-- implementation of + operator
create function pg_catalog.int42pl(integer, smallint) returns integer
  language internal;

-- implementation of / operator
create function pg_catalog.int48div(integer, bigint) returns bigint
  language internal;

-- implementation of = operator
create function pg_catalog.int48eq(integer, bigint) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.int48ge(integer, bigint) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.int48gt(integer, bigint) returns boolean
  language internal;

-- implementation of <= operator
create function pg_catalog.int48le(integer, bigint) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.int48lt(integer, bigint) returns boolean
  language internal;

-- implementation of - operator
create function pg_catalog.int48mi(integer, bigint) returns bigint
  language internal;

-- implementation of * operator
create function pg_catalog.int48mul(integer, bigint) returns bigint
  language internal;

-- implementation of <> operator
create function pg_catalog.int48ne(integer, bigint) returns boolean
  language internal;

-- implementation of + operator
create function pg_catalog.int48pl(integer, bigint) returns bigint
  language internal;

-- aggregate transition function
create function pg_catalog.int4_accum(internal, integer) returns internal
  language internal;

-- aggregate transition function
create function pg_catalog.int4_accum_inv(internal, integer) returns internal
  language internal;

-- aggregate transition function
create function pg_catalog.int4_avg_accum(bigint[], integer) returns bigint[]
  language internal;

-- aggregate transition function
create function pg_catalog.int4_avg_accum_inv(bigint[], integer) returns bigint[]
  language internal;

-- aggregate combine function
create function pg_catalog.int4_avg_combine(bigint[], bigint[]) returns bigint[]
  language internal;

-- implementation of * operator
create function pg_catalog.int4_mul_cash(integer, money) returns money
  language internal;

-- aggregate transition function
create function pg_catalog.int4_sum(bigint, integer) returns bigint
  language internal;

-- implementation of @ operator
create function pg_catalog.int4abs(integer) returns integer
  language internal;

-- implementation of & operator
create function pg_catalog.int4and(integer, integer) returns integer
  language internal;

-- implementation of / operator
create function pg_catalog.int4div(integer, integer) returns integer
  language internal;

-- implementation of = operator
create function pg_catalog.int4eq(integer, integer) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.int4ge(integer, integer) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.int4gt(integer, integer) returns boolean
  language internal;

-- I/O
create function pg_catalog.int4in(cstring) returns integer
  language internal;

-- increment
create function pg_catalog.int4inc(integer) returns integer
  language internal;

-- larger of two
create function pg_catalog.int4larger(integer, integer) returns integer
  language internal;

-- implementation of <= operator
create function pg_catalog.int4le(integer, integer) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.int4lt(integer, integer) returns boolean
  language internal;

-- implementation of - operator
create function pg_catalog.int4mi(integer, integer) returns integer
  language internal;

-- implementation of % operator
create function pg_catalog.int4mod(integer, integer) returns integer
  language internal;

-- implementation of * operator
create function pg_catalog.int4mul(integer, integer) returns integer
  language internal;

-- int4multirange constructor
create function pg_catalog.int4multirange() returns int4multirange
  language internal;

-- int4multirange constructor
create function pg_catalog.int4multirange(int4range) returns int4multirange
  language internal;

-- int4multirange constructor
create function pg_catalog.int4multirange(VARIADIC int4range[]) returns int4multirange
  language internal;

-- implementation of <> operator
create function pg_catalog.int4ne(integer, integer) returns boolean
  language internal;

-- implementation of ~ operator
create function pg_catalog.int4not(integer) returns integer
  language internal;

-- implementation of | operator
create function pg_catalog.int4or(integer, integer) returns integer
  language internal;

-- I/O
create function pg_catalog.int4out(integer) returns cstring
  language internal;

-- implementation of + operator
create function pg_catalog.int4pl(integer, integer) returns integer
  language internal;

-- int4range constructor
create function pg_catalog.int4range(integer, integer) returns int4range
  language internal;

-- int4range constructor
create function pg_catalog.int4range(integer, integer, text) returns int4range
  language internal;

-- convert an int4 range to canonical form
create function pg_catalog.int4range_canonical(int4range) returns int4range
  language internal;

-- float8 difference of two int4 values
create function pg_catalog.int4range_subdiff(integer, integer) returns double precision
  language internal;

-- I/O
create function pg_catalog.int4recv(internal) returns integer
  language internal;

-- I/O
create function pg_catalog.int4send(integer) returns bytea
  language internal;

-- implementation of << operator
create function pg_catalog.int4shl(integer, integer) returns integer
  language internal;

-- implementation of >> operator
create function pg_catalog.int4shr(integer, integer) returns integer
  language internal;

-- smaller of two
create function pg_catalog.int4smaller(integer, integer) returns integer
  language internal;

-- implementation of - operator
create function pg_catalog.int4um(integer) returns integer
  language internal;

-- implementation of + operator
create function pg_catalog.int4up(integer) returns integer
  language internal;

-- implementation of # operator
create function pg_catalog.int4xor(integer, integer) returns integer
  language internal;

-- convert bitstring to int8
create function pg_catalog.int8(bit) returns bigint
  language internal;

-- convert bytea to int8
create function pg_catalog.int8(bytea) returns bigint
  language internal;

-- convert float8 to int8
create function pg_catalog.int8(double precision) returns bigint
  language internal;

-- convert int4 to int8
create function pg_catalog.int8(integer) returns bigint
  language internal;

-- convert jsonb to int8
create function pg_catalog.int8(jsonb) returns bigint
  language internal;

-- convert numeric to int8
create function pg_catalog.int8(numeric) returns bigint
  language internal;

-- convert oid to int8
create function pg_catalog.int8(oid) returns bigint
  language internal;

-- convert float4 to int8
create function pg_catalog.int8(real) returns bigint
  language internal;

-- convert int2 to int8
create function pg_catalog.int8(smallint) returns bigint
  language internal;

-- implementation of / operator
create function pg_catalog.int82div(bigint, smallint) returns bigint
  language internal;

-- implementation of = operator
create function pg_catalog.int82eq(bigint, smallint) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.int82ge(bigint, smallint) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.int82gt(bigint, smallint) returns boolean
  language internal;

-- implementation of <= operator
create function pg_catalog.int82le(bigint, smallint) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.int82lt(bigint, smallint) returns boolean
  language internal;

-- implementation of - operator
create function pg_catalog.int82mi(bigint, smallint) returns bigint
  language internal;

-- implementation of * operator
create function pg_catalog.int82mul(bigint, smallint) returns bigint
  language internal;

-- implementation of <> operator
create function pg_catalog.int82ne(bigint, smallint) returns boolean
  language internal;

-- implementation of + operator
create function pg_catalog.int82pl(bigint, smallint) returns bigint
  language internal;

-- implementation of / operator
create function pg_catalog.int84div(bigint, integer) returns bigint
  language internal;

-- implementation of = operator
create function pg_catalog.int84eq(bigint, integer) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.int84ge(bigint, integer) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.int84gt(bigint, integer) returns boolean
  language internal;

-- implementation of <= operator
create function pg_catalog.int84le(bigint, integer) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.int84lt(bigint, integer) returns boolean
  language internal;

-- implementation of - operator
create function pg_catalog.int84mi(bigint, integer) returns bigint
  language internal;

-- implementation of * operator
create function pg_catalog.int84mul(bigint, integer) returns bigint
  language internal;

-- implementation of <> operator
create function pg_catalog.int84ne(bigint, integer) returns boolean
  language internal;

-- implementation of + operator
create function pg_catalog.int84pl(bigint, integer) returns bigint
  language internal;

-- aggregate transition function
create function pg_catalog.int8_accum(internal, bigint) returns internal
  language internal;

-- aggregate transition function
create function pg_catalog.int8_accum_inv(internal, bigint) returns internal
  language internal;

-- aggregate final function
create function pg_catalog.int8_avg(bigint[]) returns numeric
  language internal;

-- aggregate transition function
create function pg_catalog.int8_avg_accum(internal, bigint) returns internal
  language internal;

-- aggregate transition function
create function pg_catalog.int8_avg_accum_inv(internal, bigint) returns internal
  language internal;

-- aggregate combine function
create function pg_catalog.int8_avg_combine(internal, internal) returns internal
  language internal;

-- aggregate deserial function
create function pg_catalog.int8_avg_deserialize(bytea, internal) returns internal
  language internal;

-- aggregate serial function
create function pg_catalog.int8_avg_serialize(internal) returns bytea
  language internal;

-- implementation of * operator
create function pg_catalog.int8_mul_cash(bigint, money) returns money
  language internal;

-- aggregate transition function
create function pg_catalog.int8_sum(numeric, bigint) returns numeric
  language internal;

-- implementation of @ operator
create function pg_catalog.int8abs(bigint) returns bigint
  language internal;

-- implementation of & operator
create function pg_catalog.int8and(bigint, bigint) returns bigint
  language internal;

-- decrement
create function pg_catalog.int8dec(bigint) returns bigint
  language internal;

-- decrement, ignores second argument
create function pg_catalog.int8dec_any(bigint, "any") returns bigint
  language internal;

-- implementation of / operator
create function pg_catalog.int8div(bigint, bigint) returns bigint
  language internal;

-- implementation of = operator
create function pg_catalog.int8eq(bigint, bigint) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.int8ge(bigint, bigint) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.int8gt(bigint, bigint) returns boolean
  language internal;

-- I/O
create function pg_catalog.int8in(cstring) returns bigint
  language internal;

-- increment
create function pg_catalog.int8inc(bigint) returns bigint
  language internal;

-- increment, ignores second argument
create function pg_catalog.int8inc_any(bigint, "any") returns bigint
  language internal;

-- aggregate transition function
create function pg_catalog.int8inc_float8_float8(bigint, double precision, double precision) returns bigint
  language internal;

-- planner support for count run condition
create function pg_catalog.int8inc_support(internal) returns internal
  language internal;

-- larger of two
create function pg_catalog.int8larger(bigint, bigint) returns bigint
  language internal;

-- implementation of <= operator
create function pg_catalog.int8le(bigint, bigint) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.int8lt(bigint, bigint) returns boolean
  language internal;

-- implementation of - operator
create function pg_catalog.int8mi(bigint, bigint) returns bigint
  language internal;

-- implementation of % operator
create function pg_catalog.int8mod(bigint, bigint) returns bigint
  language internal;

-- implementation of * operator
create function pg_catalog.int8mul(bigint, bigint) returns bigint
  language internal;

-- int8multirange constructor
create function pg_catalog.int8multirange() returns int8multirange
  language internal;

-- int8multirange constructor
create function pg_catalog.int8multirange(int8range) returns int8multirange
  language internal;

-- int8multirange constructor
create function pg_catalog.int8multirange(VARIADIC int8range[]) returns int8multirange
  language internal;

-- implementation of <> operator
create function pg_catalog.int8ne(bigint, bigint) returns boolean
  language internal;

-- implementation of ~ operator
create function pg_catalog.int8not(bigint) returns bigint
  language internal;

-- implementation of | operator
create function pg_catalog.int8or(bigint, bigint) returns bigint
  language internal;

-- I/O
create function pg_catalog.int8out(bigint) returns cstring
  language internal;

-- implementation of + operator
create function pg_catalog.int8pl(bigint, bigint) returns bigint
  language internal;

-- implementation of + operator
create function pg_catalog.int8pl_inet(bigint, inet) returns inet
  language sql;

-- int8range constructor
create function pg_catalog.int8range(bigint, bigint) returns int8range
  language internal;

-- int8range constructor
create function pg_catalog.int8range(bigint, bigint, text) returns int8range
  language internal;

-- convert an int8 range to canonical form
create function pg_catalog.int8range_canonical(int8range) returns int8range
  language internal;

-- float8 difference of two int8 values
create function pg_catalog.int8range_subdiff(bigint, bigint) returns double precision
  language internal;

-- I/O
create function pg_catalog.int8recv(internal) returns bigint
  language internal;

-- I/O
create function pg_catalog.int8send(bigint) returns bytea
  language internal;

-- implementation of << operator
create function pg_catalog.int8shl(bigint, integer) returns bigint
  language internal;

-- implementation of >> operator
create function pg_catalog.int8shr(bigint, integer) returns bigint
  language internal;

-- smaller of two
create function pg_catalog.int8smaller(bigint, bigint) returns bigint
  language internal;

-- implementation of - operator
create function pg_catalog.int8um(bigint) returns bigint
  language internal;

-- implementation of + operator
create function pg_catalog.int8up(bigint) returns bigint
  language internal;

-- implementation of # operator
create function pg_catalog.int8xor(bigint, bigint) returns bigint
  language internal;

-- implementation of + operator
create function pg_catalog.integer_pl_date(integer, date) returns date
  language sql;

-- implementation of ?# operator
create function pg_catalog.inter_lb(line, box) returns boolean
  language internal;

-- implementation of ?# operator
create function pg_catalog.inter_sb(lseg, box) returns boolean
  language internal;

-- implementation of ?# operator
create function pg_catalog.inter_sl(lseg, line) returns boolean
  language internal;

-- I/O
create function pg_catalog.internal_in(cstring) returns internal
  language internal;

-- I/O
create function pg_catalog.internal_out(internal) returns cstring
  language internal;

-- adjust interval precision
create function pg_catalog.interval(interval, integer) returns interval
  language internal;

-- convert time to interval
create function pg_catalog.interval(time without time zone) returns interval
  language internal;

-- aggregate final function
create function pg_catalog.interval_avg(internal) returns interval
  language internal;

-- aggregate transition function
create function pg_catalog.interval_avg_accum(internal, interval) returns internal
  language internal;

-- aggregate transition function
create function pg_catalog.interval_avg_accum_inv(internal, interval) returns internal
  language internal;

-- aggregate combine function
create function pg_catalog.interval_avg_combine(internal, internal) returns internal
  language internal;

-- aggregate deserial function
create function pg_catalog.interval_avg_deserialize(bytea, internal) returns internal
  language internal;

-- aggregate serial function
create function pg_catalog.interval_avg_serialize(internal) returns bytea
  language internal;

-- less-equal-greater
create function pg_catalog.interval_cmp(interval, interval) returns integer
  language internal;

-- implementation of / operator
create function pg_catalog.interval_div(interval, double precision) returns interval
  language internal;

-- implementation of = operator
create function pg_catalog.interval_eq(interval, interval) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.interval_ge(interval, interval) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.interval_gt(interval, interval) returns boolean
  language internal;

-- hash
create function pg_catalog.interval_hash(interval) returns integer
  language internal;

-- hash
create function pg_catalog.interval_hash_extended(interval, bigint) returns bigint
  language internal;

-- I/O
create function pg_catalog.interval_in(cstring, oid, integer) returns interval
  language internal;

-- larger of two
create function pg_catalog.interval_larger(interval, interval) returns interval
  language internal;

-- implementation of <= operator
create function pg_catalog.interval_le(interval, interval) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.interval_lt(interval, interval) returns boolean
  language internal;

-- implementation of - operator
create function pg_catalog.interval_mi(interval, interval) returns interval
  language internal;

-- implementation of * operator
create function pg_catalog.interval_mul(interval, double precision) returns interval
  language internal;

-- implementation of <> operator
create function pg_catalog.interval_ne(interval, interval) returns boolean
  language internal;

-- I/O
create function pg_catalog.interval_out(interval) returns cstring
  language internal;

-- implementation of + operator
create function pg_catalog.interval_pl(interval, interval) returns interval
  language internal;

-- implementation of + operator
create function pg_catalog.interval_pl_date(interval, date) returns timestamp without time zone
  language sql;

-- implementation of + operator
create function pg_catalog.interval_pl_time(interval, time without time zone) returns time without time zone
  language sql;

-- implementation of + operator
create function pg_catalog.interval_pl_timestamp(interval, timestamp without time zone) returns timestamp without time zone
  language sql;

-- implementation of + operator
create function pg_catalog.interval_pl_timestamptz(interval, timestamp with time zone) returns timestamp with time zone
  language sql;

-- implementation of + operator
create function pg_catalog.interval_pl_timetz(interval, time with time zone) returns time with time zone
  language sql;

-- I/O
create function pg_catalog.interval_recv(internal, oid, integer) returns interval
  language internal;

-- I/O
create function pg_catalog.interval_send(interval) returns bytea
  language internal;

-- smaller of two
create function pg_catalog.interval_smaller(interval, interval) returns interval
  language internal;

-- aggregate final function
create function pg_catalog.interval_sum(internal) returns interval
  language internal;

-- planner support for interval length coercion
create function pg_catalog.interval_support(internal) returns internal
  language internal;

-- implementation of - operator
create function pg_catalog.interval_um(interval) returns interval
  language internal;

-- I/O typmod
create function pg_catalog.intervaltypmodin(cstring[]) returns integer
  language internal;

-- I/O typmod
create function pg_catalog.intervaltypmodout(integer) returns cstring
  language internal;

-- check Unicode normalization
create function pg_catalog.is_normalized(text, text DEFAULT 'NFC'::text) returns boolean
  language internal;

-- path closed?
create function pg_catalog.isclosed(path) returns boolean
  language internal;

-- is the multirange empty?
create function pg_catalog.isempty(anymultirange) returns boolean
  language internal;

-- is the range empty?
create function pg_catalog.isempty(anyrange) returns boolean
  language internal;

-- finite date?
create function pg_catalog.isfinite(date) returns boolean
  language internal;

-- finite interval?
create function pg_catalog.isfinite(interval) returns boolean
  language internal;

-- finite timestamp?
create function pg_catalog.isfinite(timestamp with time zone) returns boolean
  language internal;

-- finite timestamp?
create function pg_catalog.isfinite(timestamp without time zone) returns boolean
  language internal;

-- horizontal
create function pg_catalog.ishorizontal(line) returns boolean
  language internal;

-- horizontal
create function pg_catalog.ishorizontal(lseg) returns boolean
  language internal;

-- horizontally aligned
create function pg_catalog.ishorizontal(point, point) returns boolean
  language internal;

-- internal conversion function for LATIN1 to UTF8
create function pg_catalog.iso8859_1_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for ISO-8859 2-16 to UTF8
create function pg_catalog.iso8859_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for ISO-8859-5 to KOI8R
create function pg_catalog.iso_to_koi8r(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for ISO-8859-5 to MULE_INTERNAL
create function pg_catalog.iso_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for ISO-8859-5 to WIN1251
create function pg_catalog.iso_to_win1251(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for ISO-8859-5 to WIN866
create function pg_catalog.iso_to_win866(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- path open?
create function pg_catalog.isopen(path) returns boolean
  language internal;

-- parallel
create function pg_catalog.isparallel(line, line) returns boolean
  language internal;

-- parallel
create function pg_catalog.isparallel(lseg, lseg) returns boolean
  language internal;

-- perpendicular
create function pg_catalog.isperp(line, line) returns boolean
  language internal;

-- perpendicular
create function pg_catalog.isperp(lseg, lseg) returns boolean
  language internal;

-- vertical
create function pg_catalog.isvertical(line) returns boolean
  language internal;

-- vertical
create function pg_catalog.isvertical(lseg) returns boolean
  language internal;

-- vertically aligned
create function pg_catalog.isvertical(point, point) returns boolean
  language internal;

-- internal conversion function for JOHAB to UTF8
create function pg_catalog.johab_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- aggregate input into json
create aggregate pg_catalog.json_agg(anyelement) (
  sfunc = json_agg_transfn,
  stype = internal,
  finalfunc = json_agg_finalfn
);

-- json aggregate final function
create function pg_catalog.json_agg_finalfn(internal) returns json
  language internal;

-- aggregate input into json
create aggregate pg_catalog.json_agg_strict(anyelement) (
  sfunc = json_agg_strict_transfn,
  stype = internal,
  finalfunc = json_agg_finalfn
);

-- json aggregate transition function
create function pg_catalog.json_agg_strict_transfn(internal, anyelement) returns internal
  language internal;

-- json aggregate transition function
create function pg_catalog.json_agg_transfn(internal, anyelement) returns internal
  language internal;

-- implementation of -> operator
create function pg_catalog.json_array_element(from_json json, element_index integer) returns json
  language internal;

-- implementation of ->> operator
create function pg_catalog.json_array_element_text(from_json json, element_index integer) returns text
  language internal;

-- key value pairs of a json object
create function pg_catalog.json_array_elements(from_json json, OUT value json) returns SETOF json
  language internal;

-- elements of json array
create function pg_catalog.json_array_elements_text(from_json json, OUT value text) returns SETOF text
  language internal;

-- length of json array
create function pg_catalog.json_array_length(json) returns integer
  language internal;

-- build an empty json array
create function pg_catalog.json_build_array() returns json
  language internal;

-- build a json array from any inputs
create function pg_catalog.json_build_array(VARIADIC "any") returns json
  language internal;

-- build an empty json object
create function pg_catalog.json_build_object() returns json
  language internal;

-- build a json object from pairwise key/value inputs
create function pg_catalog.json_build_object(VARIADIC "any") returns json
  language internal;

-- key value pairs of a json object
create function pg_catalog.json_each(from_json json, OUT key text, OUT value json) returns SETOF record
  language internal;

-- key value pairs of a json object
create function pg_catalog.json_each_text(from_json json, OUT key text, OUT value text) returns SETOF record
  language internal;

-- get value from json with path elements
create function pg_catalog.json_extract_path(from_json json, VARIADIC path_elems text[]) returns json
  language internal;

-- get value from json as text with path elements
create function pg_catalog.json_extract_path_text(from_json json, VARIADIC path_elems text[]) returns text
  language internal;

-- I/O
create function pg_catalog.json_in(cstring) returns json
  language internal;

-- map text array of key value pairs to json object
create function pg_catalog.json_object(text[]) returns json
  language internal;

-- map text arrays of keys and values to json object
create function pg_catalog.json_object(text[], text[]) returns json
  language internal;

-- aggregate input into a json object
create aggregate pg_catalog.json_object_agg(key "any", value "any") (
  sfunc = json_object_agg_transfn,
  stype = internal,
  finalfunc = json_object_agg_finalfn
);

-- json object aggregate final function
create function pg_catalog.json_object_agg_finalfn(internal) returns json
  language internal;

-- aggregate non-NULL input into a json object
create aggregate pg_catalog.json_object_agg_strict(key "any", value "any") (
  sfunc = json_object_agg_strict_transfn,
  stype = internal,
  finalfunc = json_object_agg_finalfn
);

-- json object aggregate transition function
create function pg_catalog.json_object_agg_strict_transfn(internal, "any", "any") returns internal
  language internal;

-- json object aggregate transition function
create function pg_catalog.json_object_agg_transfn(internal, "any", "any") returns internal
  language internal;

-- aggregate input into a json object with unique keys
create aggregate pg_catalog.json_object_agg_unique(key "any", value "any") (
  sfunc = json_object_agg_unique_transfn,
  stype = internal,
  finalfunc = json_object_agg_finalfn
);

-- aggregate non-NULL input into a json object with unique keys
create aggregate pg_catalog.json_object_agg_unique_strict(key "any", value "any") (
  sfunc = json_object_agg_unique_strict_transfn,
  stype = internal,
  finalfunc = json_object_agg_finalfn
);

-- json object aggregate transition function
create function pg_catalog.json_object_agg_unique_strict_transfn(internal, "any", "any") returns internal
  language internal;

-- json object aggregate transition function
create function pg_catalog.json_object_agg_unique_transfn(internal, "any", "any") returns internal
  language internal;

-- implementation of -> operator
create function pg_catalog.json_object_field(from_json json, field_name text) returns json
  language internal;

-- implementation of ->> operator
create function pg_catalog.json_object_field_text(from_json json, field_name text) returns text
  language internal;

-- get json object keys
create function pg_catalog.json_object_keys(json) returns SETOF text
  language internal;

-- I/O
create function pg_catalog.json_out(json) returns cstring
  language internal;

-- get record fields from a json object
create function pg_catalog.json_populate_record(base anyelement, from_json json, use_json_as_text boolean DEFAULT false) returns anyelement
  language internal;

-- get set of records with fields from a json array of objects
create function pg_catalog.json_populate_recordset(base anyelement, from_json json, use_json_as_text boolean DEFAULT false) returns SETOF anyelement
  language internal;

-- I/O
create function pg_catalog.json_recv(internal) returns json
  language internal;

-- I/O
create function pg_catalog.json_send(json) returns bytea
  language internal;

-- remove object fields with null values from json
create function pg_catalog.json_strip_nulls(target json, strip_in_arrays boolean DEFAULT false) returns json
  language internal;

-- get record fields from a json object
create function pg_catalog.json_to_record(json) returns record
  language internal;

-- get set of records with fields from a json array of objects
create function pg_catalog.json_to_recordset(json) returns SETOF record
  language internal;

-- transform specified values from json to tsvector
create function pg_catalog.json_to_tsvector(json, jsonb) returns tsvector
  language internal;

-- transform specified values from json to tsvector
create function pg_catalog.json_to_tsvector(regconfig, json, jsonb) returns tsvector
  language internal;

-- get the type of a json value
create function pg_catalog.json_typeof(json) returns text
  language internal;

-- aggregate input into jsonb
create aggregate pg_catalog.jsonb_agg(anyelement) (
  sfunc = jsonb_agg_transfn,
  stype = internal,
  finalfunc = jsonb_agg_finalfn
);

-- jsonb aggregate final function
create function pg_catalog.jsonb_agg_finalfn(internal) returns jsonb
  language internal;

-- aggregate input into jsonb skipping nulls
create aggregate pg_catalog.jsonb_agg_strict(anyelement) (
  sfunc = jsonb_agg_strict_transfn,
  stype = internal,
  finalfunc = jsonb_agg_finalfn
);

-- jsonb aggregate transition function
create function pg_catalog.jsonb_agg_strict_transfn(internal, anyelement) returns internal
  language internal;

-- jsonb aggregate transition function
create function pg_catalog.jsonb_agg_transfn(internal, anyelement) returns internal
  language internal;

-- implementation of -> operator
create function pg_catalog.jsonb_array_element(from_json jsonb, element_index integer) returns jsonb
  language internal;

-- implementation of ->> operator
create function pg_catalog.jsonb_array_element_text(from_json jsonb, element_index integer) returns text
  language internal;

-- elements of a jsonb array
create function pg_catalog.jsonb_array_elements(from_json jsonb, OUT value jsonb) returns SETOF jsonb
  language internal;

-- elements of jsonb array
create function pg_catalog.jsonb_array_elements_text(from_json jsonb, OUT value text) returns SETOF text
  language internal;

-- length of jsonb array
create function pg_catalog.jsonb_array_length(jsonb) returns integer
  language internal;

-- build an empty jsonb array
create function pg_catalog.jsonb_build_array() returns jsonb
  language internal;

-- build a jsonb array from any inputs
create function pg_catalog.jsonb_build_array(VARIADIC "any") returns jsonb
  language internal;

-- build an empty jsonb object
create function pg_catalog.jsonb_build_object() returns jsonb
  language internal;

-- build a jsonb object from pairwise key/value inputs
create function pg_catalog.jsonb_build_object(VARIADIC "any") returns jsonb
  language internal;

-- less-equal-greater
create function pg_catalog.jsonb_cmp(jsonb, jsonb) returns integer
  language internal;

-- implementation of || operator
create function pg_catalog.jsonb_concat(jsonb, jsonb) returns jsonb
  language internal;

-- implementation of <@ operator
create function pg_catalog.jsonb_contained(jsonb, jsonb) returns boolean
  language internal;

-- implementation of @> operator
create function pg_catalog.jsonb_contains(jsonb, jsonb) returns boolean
  language internal;

-- implementation of - operator
create function pg_catalog.jsonb_delete(from_json jsonb, VARIADIC path_elems text[]) returns jsonb
  language internal;

-- implementation of - operator
create function pg_catalog.jsonb_delete(jsonb, integer) returns jsonb
  language internal;

-- implementation of - operator
create function pg_catalog.jsonb_delete(jsonb, text) returns jsonb
  language internal;

-- implementation of #- operator
create function pg_catalog.jsonb_delete_path(jsonb, text[]) returns jsonb
  language internal;

-- key value pairs of a jsonb object
create function pg_catalog.jsonb_each(from_json jsonb, OUT key text, OUT value jsonb) returns SETOF record
  language internal;

-- key value pairs of a jsonb object
create function pg_catalog.jsonb_each_text(from_json jsonb, OUT key text, OUT value text) returns SETOF record
  language internal;

-- implementation of = operator
create function pg_catalog.jsonb_eq(jsonb, jsonb) returns boolean
  language internal;

-- implementation of ? operator
create function pg_catalog.jsonb_exists(jsonb, text) returns boolean
  language internal;

-- implementation of ?& operator
create function pg_catalog.jsonb_exists_all(jsonb, text[]) returns boolean
  language internal;

-- implementation of ?| operator
create function pg_catalog.jsonb_exists_any(jsonb, text[]) returns boolean
  language internal;

-- get value from jsonb with path elements
create function pg_catalog.jsonb_extract_path(from_json jsonb, VARIADIC path_elems text[]) returns jsonb
  language internal;

-- get value from jsonb as text with path elements
create function pg_catalog.jsonb_extract_path_text(from_json jsonb, VARIADIC path_elems text[]) returns text
  language internal;

-- implementation of >= operator
create function pg_catalog.jsonb_ge(jsonb, jsonb) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.jsonb_gt(jsonb, jsonb) returns boolean
  language internal;

-- hash
create function pg_catalog.jsonb_hash(jsonb) returns integer
  language internal;

-- hash
create function pg_catalog.jsonb_hash_extended(jsonb, bigint) returns bigint
  language internal;

-- I/O
create function pg_catalog.jsonb_in(cstring) returns jsonb
  language internal;

-- Insert value into a jsonb
create function pg_catalog.jsonb_insert(jsonb_in jsonb, path text[], replacement jsonb, insert_after boolean DEFAULT false) returns jsonb
  language internal;

-- implementation of <= operator
create function pg_catalog.jsonb_le(jsonb, jsonb) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.jsonb_lt(jsonb, jsonb) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.jsonb_ne(jsonb, jsonb) returns boolean
  language internal;

-- map text array of key value pairs to jsonb object
create function pg_catalog.jsonb_object(text[]) returns jsonb
  language internal;

-- map text array of key value pairs to jsonb object
create function pg_catalog.jsonb_object(text[], text[]) returns jsonb
  language internal;

-- aggregate inputs into jsonb object
create aggregate pg_catalog.jsonb_object_agg(key "any", value "any") (
  sfunc = jsonb_object_agg_transfn,
  stype = internal,
  finalfunc = jsonb_object_agg_finalfn
);

-- jsonb object aggregate final function
create function pg_catalog.jsonb_object_agg_finalfn(internal) returns jsonb
  language internal;

-- aggregate non-NULL inputs into jsonb object
create aggregate pg_catalog.jsonb_object_agg_strict(key "any", value "any") (
  sfunc = jsonb_object_agg_strict_transfn,
  stype = internal,
  finalfunc = jsonb_object_agg_finalfn
);

-- jsonb object aggregate transition function
create function pg_catalog.jsonb_object_agg_strict_transfn(internal, "any", "any") returns internal
  language internal;

-- jsonb object aggregate transition function
create function pg_catalog.jsonb_object_agg_transfn(internal, "any", "any") returns internal
  language internal;

-- aggregate inputs into jsonb object checking key uniqueness
create aggregate pg_catalog.jsonb_object_agg_unique(key "any", value "any") (
  sfunc = jsonb_object_agg_unique_transfn,
  stype = internal,
  finalfunc = jsonb_object_agg_finalfn
);

-- aggregate non-NULL inputs into jsonb object checking key uniqueness
create aggregate pg_catalog.jsonb_object_agg_unique_strict(key "any", value "any") (
  sfunc = jsonb_object_agg_unique_strict_transfn,
  stype = internal,
  finalfunc = jsonb_object_agg_finalfn
);

-- jsonb object aggregate transition function
create function pg_catalog.jsonb_object_agg_unique_strict_transfn(internal, "any", "any") returns internal
  language internal;

-- jsonb object aggregate transition function
create function pg_catalog.jsonb_object_agg_unique_transfn(internal, "any", "any") returns internal
  language internal;

-- implementation of -> operator
create function pg_catalog.jsonb_object_field(from_json jsonb, field_name text) returns jsonb
  language internal;

-- implementation of ->> operator
create function pg_catalog.jsonb_object_field_text(from_json jsonb, field_name text) returns text
  language internal;

-- get jsonb object keys
create function pg_catalog.jsonb_object_keys(jsonb) returns SETOF text
  language internal;

-- I/O
create function pg_catalog.jsonb_out(jsonb) returns cstring
  language internal;

-- jsonpath exists test
create function pg_catalog.jsonb_path_exists(target jsonb, path jsonpath, vars jsonb DEFAULT '{}'::jsonb, silent boolean DEFAULT false) returns boolean
  language internal;

-- implementation of @? operator
create function pg_catalog.jsonb_path_exists_opr(jsonb, jsonpath) returns boolean
  language internal;

-- jsonpath exists test with timezone
create function pg_catalog.jsonb_path_exists_tz(target jsonb, path jsonpath, vars jsonb DEFAULT '{}'::jsonb, silent boolean DEFAULT false) returns boolean
  language internal;

-- jsonpath match
create function pg_catalog.jsonb_path_match(target jsonb, path jsonpath, vars jsonb DEFAULT '{}'::jsonb, silent boolean DEFAULT false) returns boolean
  language internal;

-- implementation of @@ operator
create function pg_catalog.jsonb_path_match_opr(jsonb, jsonpath) returns boolean
  language internal;

-- jsonpath match with timezone
create function pg_catalog.jsonb_path_match_tz(target jsonb, path jsonpath, vars jsonb DEFAULT '{}'::jsonb, silent boolean DEFAULT false) returns boolean
  language internal;

-- jsonpath query
create function pg_catalog.jsonb_path_query(target jsonb, path jsonpath, vars jsonb DEFAULT '{}'::jsonb, silent boolean DEFAULT false) returns SETOF jsonb
  language internal;

-- jsonpath query wrapped into array
create function pg_catalog.jsonb_path_query_array(target jsonb, path jsonpath, vars jsonb DEFAULT '{}'::jsonb, silent boolean DEFAULT false) returns jsonb
  language internal;

-- jsonpath query wrapped into array with timezone
create function pg_catalog.jsonb_path_query_array_tz(target jsonb, path jsonpath, vars jsonb DEFAULT '{}'::jsonb, silent boolean DEFAULT false) returns jsonb
  language internal;

-- jsonpath query first item
create function pg_catalog.jsonb_path_query_first(target jsonb, path jsonpath, vars jsonb DEFAULT '{}'::jsonb, silent boolean DEFAULT false) returns jsonb
  language internal;

-- jsonpath query first item with timezone
create function pg_catalog.jsonb_path_query_first_tz(target jsonb, path jsonpath, vars jsonb DEFAULT '{}'::jsonb, silent boolean DEFAULT false) returns jsonb
  language internal;

-- jsonpath query with timezone
create function pg_catalog.jsonb_path_query_tz(target jsonb, path jsonpath, vars jsonb DEFAULT '{}'::jsonb, silent boolean DEFAULT false) returns SETOF jsonb
  language internal;

-- get record fields from a jsonb object
create function pg_catalog.jsonb_populate_record(anyelement, jsonb) returns anyelement
  language internal;

-- test get record fields from a jsonb object
create function pg_catalog.jsonb_populate_record_valid(anyelement, jsonb) returns boolean
  language internal;

-- get set of records with fields from a jsonb array of objects
create function pg_catalog.jsonb_populate_recordset(anyelement, jsonb) returns SETOF anyelement
  language internal;

-- Indented text from jsonb
create function pg_catalog.jsonb_pretty(jsonb) returns text
  language internal;

-- I/O
create function pg_catalog.jsonb_recv(internal) returns jsonb
  language internal;

-- I/O
create function pg_catalog.jsonb_send(jsonb) returns bytea
  language internal;

-- Set part of a jsonb
create function pg_catalog.jsonb_set(jsonb_in jsonb, path text[], replacement jsonb, create_if_missing boolean DEFAULT true) returns jsonb
  language internal;

-- Set part of a jsonb, handle NULL value
create function pg_catalog.jsonb_set_lax(jsonb_in jsonb, path text[], replacement jsonb, create_if_missing boolean DEFAULT true, null_value_treatment text DEFAULT 'use_json_null'::text) returns jsonb
  language internal;

-- remove object fields with null values from jsonb
create function pg_catalog.jsonb_strip_nulls(target jsonb, strip_in_arrays boolean DEFAULT false) returns jsonb
  language internal;

-- jsonb subscripting logic
create function pg_catalog.jsonb_subscript_handler(internal) returns internal
  language internal;

-- get record fields from a jsonb object
create function pg_catalog.jsonb_to_record(jsonb) returns record
  language internal;

-- get set of records with fields from a jsonb array of objects
create function pg_catalog.jsonb_to_recordset(jsonb) returns SETOF record
  language internal;

-- transform specified values from jsonb to tsvector
create function pg_catalog.jsonb_to_tsvector(jsonb, jsonb) returns tsvector
  language internal;

-- transform specified values from jsonb to tsvector
create function pg_catalog.jsonb_to_tsvector(regconfig, jsonb, jsonb) returns tsvector
  language internal;

-- get the type of a jsonb value
create function pg_catalog.jsonb_typeof(jsonb) returns text
  language internal;

-- I/O
create function pg_catalog.jsonpath_in(cstring) returns jsonpath
  language internal;

-- I/O
create function pg_catalog.jsonpath_out(jsonpath) returns cstring
  language internal;

-- I/O
create function pg_catalog.jsonpath_recv(internal) returns jsonpath
  language internal;

-- I/O
create function pg_catalog.jsonpath_send(jsonpath) returns bytea
  language internal;

-- promote groups of 30 days to numbers of months
create function pg_catalog.justify_days(interval) returns interval
  language internal;

-- promote groups of 24 hours to numbers of days
create function pg_catalog.justify_hours(interval) returns interval
  language internal;

-- promote groups of 24 hours to numbers of days and promote groups of 30 days to numbers of months
create function pg_catalog.justify_interval(interval) returns interval
  language internal;

-- internal conversion function for KOI8R to ISO-8859-5
create function pg_catalog.koi8r_to_iso(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for KOI8R to MULE_INTERNAL
create function pg_catalog.koi8r_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for KOI8R to UTF8
create function pg_catalog.koi8r_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for KOI8R to WIN1251
create function pg_catalog.koi8r_to_win1251(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for KOI8R to WIN866
create function pg_catalog.koi8r_to_win866(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for KOI8U to UTF8
create function pg_catalog.koi8u_to_utf8(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- fetch the Nth preceding row value with default
create function pg_catalog.lag(anycompatible, integer, anycompatible) returns anycompatible
  language internal;

-- fetch the preceding row value
create function pg_catalog.lag(anyelement) returns anyelement
  language internal;

-- fetch the Nth preceding row value
create function pg_catalog.lag(anyelement, integer) returns anyelement
  language internal;

-- I/O
create function pg_catalog.language_handler_in(cstring) returns language_handler
  language internal;

-- I/O
create function pg_catalog.language_handler_out(language_handler) returns cstring
  language internal;

-- fetch the last row value
create function pg_catalog.last_value(anyelement) returns anyelement
  language internal;

-- current value from last used sequence
create function pg_catalog.lastval() returns bigint
  language internal;

-- internal conversion function for LATIN1 to MULE_INTERNAL
create function pg_catalog.latin1_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for LATIN2 to MULE_INTERNAL
create function pg_catalog.latin2_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for LATIN2 to WIN1250
create function pg_catalog.latin2_to_win1250(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for LATIN3 to MULE_INTERNAL
create function pg_catalog.latin3_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for LATIN4 to MULE_INTERNAL
create function pg_catalog.latin4_to_mic(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- least common multiple
create function pg_catalog.lcm(bigint, bigint) returns bigint
  language internal;

-- least common multiple
create function pg_catalog.lcm(integer, integer) returns integer
  language internal;

-- least common multiple
create function pg_catalog.lcm(numeric, numeric) returns numeric
  language internal;

-- fetch the Nth following row value with default
create function pg_catalog.lead(anycompatible, integer, anycompatible) returns anycompatible
  language internal;

-- fetch the following row value
create function pg_catalog.lead(anyelement) returns anyelement
  language internal;

-- fetch the Nth following row value
create function pg_catalog.lead(anyelement, integer) returns anyelement
  language internal;

-- extract the first n characters
create function pg_catalog.left(text, integer) returns text
  language internal;

-- bitstring length
create function pg_catalog.length(bit) returns integer
  language internal;

-- octet length
create function pg_catalog.length(bytea) returns integer
  language internal;

-- length of string in specified encoding
create function pg_catalog.length(bytea, name) returns integer
  language internal;

-- character length
create function pg_catalog.length(character) returns integer
  language internal;

-- distance between endpoints
create function pg_catalog.length(lseg) returns double precision
  language internal;

-- sum of path segments
create function pg_catalog.length(path) returns double precision
  language internal;

-- length
create function pg_catalog.length(text) returns integer
  language internal;

-- number of lexemes
create function pg_catalog.length(tsvector) returns integer
  language internal;

-- natural logarithm of absolute value of gamma function
create function pg_catalog.lgamma(double precision) returns double precision
  language internal;

-- matches LIKE expression
create function pg_catalog.like(bytea, bytea) returns boolean
  language internal;

-- matches LIKE expression
create function pg_catalog.like(name, text) returns boolean
  language internal;

-- matches LIKE expression
create function pg_catalog.like(text, text) returns boolean
  language internal;

-- convert LIKE pattern to use backslash escapes
create function pg_catalog.like_escape(bytea, bytea) returns bytea
  language internal;

-- convert LIKE pattern to use backslash escapes
create function pg_catalog.like_escape(text, text) returns text
  language internal;

-- join selectivity of LIKE
create function pg_catalog.likejoinsel(internal, oid, internal, smallint, internal) returns double precision
  language internal;

-- restriction selectivity of LIKE
create function pg_catalog.likesel(internal, oid, internal, integer) returns double precision
  language internal;

-- construct line from points
create function pg_catalog.line(point, point) returns line
  language internal;

-- implementation of <-> operator
create function pg_catalog.line_distance(line, line) returns double precision
  language internal;

-- implementation of = operator
create function pg_catalog.line_eq(line, line) returns boolean
  language internal;

-- implementation of ?- operator
create function pg_catalog.line_horizontal(line) returns boolean
  language internal;

-- I/O
create function pg_catalog.line_in(cstring) returns line
  language internal;

-- implementation of # operator
create function pg_catalog.line_interpt(line, line) returns point
  language internal;

-- implementation of ?# operator
create function pg_catalog.line_intersect(line, line) returns boolean
  language internal;

-- I/O
create function pg_catalog.line_out(line) returns cstring
  language internal;

-- implementation of ?|| operator
create function pg_catalog.line_parallel(line, line) returns boolean
  language internal;

-- implementation of ?-| operator
create function pg_catalog.line_perp(line, line) returns boolean
  language internal;

-- I/O
create function pg_catalog.line_recv(internal) returns line
  language internal;

-- I/O
create function pg_catalog.line_send(line) returns bytea
  language internal;

-- implementation of ?| operator
create function pg_catalog.line_vertical(line) returns boolean
  language internal;

-- natural logarithm
create function pg_catalog.ln(double precision) returns double precision
  language internal;

-- natural logarithm
create function pg_catalog.ln(numeric) returns numeric
  language internal;

-- large object close
create function pg_catalog.lo_close(integer) returns integer
  language internal;

-- large object create
create function pg_catalog.lo_creat(integer) returns oid
  language internal;

-- large object create
create function pg_catalog.lo_create(oid) returns oid
  language internal;

-- large object export
create function pg_catalog.lo_export(oid, text) returns integer
  language internal;

-- create new large object with given content
create function pg_catalog.lo_from_bytea(oid, bytea) returns oid
  language internal;

-- read entire large object
create function pg_catalog.lo_get(oid) returns bytea
  language internal;

-- read large object from offset for length
create function pg_catalog.lo_get(oid, bigint, integer) returns bytea
  language internal;

-- large object import
create function pg_catalog.lo_import(text) returns oid
  language internal;

-- large object import
create function pg_catalog.lo_import(text, oid) returns oid
  language internal;

-- large object seek
create function pg_catalog.lo_lseek(integer, integer, integer) returns integer
  language internal;

-- large object seek (64 bit)
create function pg_catalog.lo_lseek64(integer, bigint, integer) returns bigint
  language internal;

-- large object open
create function pg_catalog.lo_open(oid, integer) returns integer
  language internal;

-- write data at offset
create function pg_catalog.lo_put(oid, bigint, bytea) returns void
  language internal;

-- large object position
create function pg_catalog.lo_tell(integer) returns integer
  language internal;

-- large object position (64 bit)
create function pg_catalog.lo_tell64(integer) returns bigint
  language internal;

-- truncate large object
create function pg_catalog.lo_truncate(integer, integer) returns integer
  language internal;

-- truncate large object (64 bit)
create function pg_catalog.lo_truncate64(integer, bigint) returns integer
  language internal;

-- large object unlink (delete)
create function pg_catalog.lo_unlink(oid) returns integer
  language internal;

-- base 10 logarithm
create function pg_catalog.log(double precision) returns double precision
  language internal;

-- base 10 logarithm
create function pg_catalog.log(numeric) returns numeric
  language sql;

-- logarithm base m of n
create function pg_catalog.log(numeric, numeric) returns numeric
  language internal;

-- base 10 logarithm
create function pg_catalog.log10(double precision) returns double precision
  language internal;

-- base 10 logarithm
create function pg_catalog.log10(numeric) returns numeric
  language sql;

-- large object read
create function pg_catalog.loread(integer, integer) returns bytea
  language internal;

-- lower bound of multirange
create function pg_catalog.lower(anymultirange) returns anyelement
  language internal;

-- lower bound of range
create function pg_catalog.lower(anyrange) returns anyelement
  language internal;

-- lowercase
create function pg_catalog.lower(text) returns text
  language internal;

-- is the multirange's lower bound inclusive?
create function pg_catalog.lower_inc(anymultirange) returns boolean
  language internal;

-- is the range's lower bound inclusive?
create function pg_catalog.lower_inc(anyrange) returns boolean
  language internal;

-- is the multirange's lower bound infinite?
create function pg_catalog.lower_inf(anymultirange) returns boolean
  language internal;

-- is the range's lower bound infinite?
create function pg_catalog.lower_inf(anyrange) returns boolean
  language internal;

-- large object write
create function pg_catalog.lowrite(integer, bytea) returns integer
  language internal;

-- left-pad string to length
create function pg_catalog.lpad(text, integer) returns text
  language sql;

-- left-pad string to length
create function pg_catalog.lpad(text, integer, text) returns text
  language internal;

-- diagonal of
create function pg_catalog.lseg(box) returns lseg
  language internal;

-- convert points to line segment
create function pg_catalog.lseg(point, point) returns lseg
  language internal;

-- implementation of @@ operator
create function pg_catalog.lseg_center(lseg) returns point
  language internal;

-- implementation of <-> operator
create function pg_catalog.lseg_distance(lseg, lseg) returns double precision
  language internal;

-- implementation of = operator
create function pg_catalog.lseg_eq(lseg, lseg) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.lseg_ge(lseg, lseg) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.lseg_gt(lseg, lseg) returns boolean
  language internal;

-- implementation of ?- operator
create function pg_catalog.lseg_horizontal(lseg) returns boolean
  language internal;

-- I/O
create function pg_catalog.lseg_in(cstring) returns lseg
  language internal;

-- implementation of # operator
create function pg_catalog.lseg_interpt(lseg, lseg) returns point
  language internal;

-- implementation of ?# operator
create function pg_catalog.lseg_intersect(lseg, lseg) returns boolean
  language internal;

-- implementation of <= operator
create function pg_catalog.lseg_le(lseg, lseg) returns boolean
  language internal;

-- implementation of @-@ operator
create function pg_catalog.lseg_length(lseg) returns double precision
  language internal;

-- implementation of < operator
create function pg_catalog.lseg_lt(lseg, lseg) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.lseg_ne(lseg, lseg) returns boolean
  language internal;

-- I/O
create function pg_catalog.lseg_out(lseg) returns cstring
  language internal;

-- implementation of ?|| operator
create function pg_catalog.lseg_parallel(lseg, lseg) returns boolean
  language internal;

-- implementation of ?-| operator
create function pg_catalog.lseg_perp(lseg, lseg) returns boolean
  language internal;

-- I/O
create function pg_catalog.lseg_recv(internal) returns lseg
  language internal;

-- I/O
create function pg_catalog.lseg_send(lseg) returns bytea
  language internal;

-- implementation of ?| operator
create function pg_catalog.lseg_vertical(lseg) returns boolean
  language internal;

-- trim selected bytes from left end of string
create function pg_catalog.ltrim(bytea, bytea) returns bytea
  language internal;

-- trim spaces from left end of string
create function pg_catalog.ltrim(text) returns text
  language internal;

-- trim selected characters from left end of string
create function pg_catalog.ltrim(text, text) returns text
  language internal;

-- convert macaddr8 to macaddr
create function pg_catalog.macaddr(macaddr8) returns macaddr
  language internal;

-- convert macaddr to macaddr8
create function pg_catalog.macaddr8(macaddr) returns macaddr8
  language internal;

-- implementation of & operator
create function pg_catalog.macaddr8_and(macaddr8, macaddr8) returns macaddr8
  language internal;

-- less-equal-greater
create function pg_catalog.macaddr8_cmp(macaddr8, macaddr8) returns integer
  language internal;

-- implementation of = operator
create function pg_catalog.macaddr8_eq(macaddr8, macaddr8) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.macaddr8_ge(macaddr8, macaddr8) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.macaddr8_gt(macaddr8, macaddr8) returns boolean
  language internal;

-- I/O
create function pg_catalog.macaddr8_in(cstring) returns macaddr8
  language internal;

-- implementation of <= operator
create function pg_catalog.macaddr8_le(macaddr8, macaddr8) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.macaddr8_lt(macaddr8, macaddr8) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.macaddr8_ne(macaddr8, macaddr8) returns boolean
  language internal;

-- implementation of ~ operator
create function pg_catalog.macaddr8_not(macaddr8) returns macaddr8
  language internal;

-- implementation of | operator
create function pg_catalog.macaddr8_or(macaddr8, macaddr8) returns macaddr8
  language internal;

-- I/O
create function pg_catalog.macaddr8_out(macaddr8) returns cstring
  language internal;

-- I/O
create function pg_catalog.macaddr8_recv(internal) returns macaddr8
  language internal;

-- I/O
create function pg_catalog.macaddr8_send(macaddr8) returns bytea
  language internal;

-- set 7th bit in macaddr8
create function pg_catalog.macaddr8_set7bit(macaddr8) returns macaddr8
  language internal;

-- implementation of & operator
create function pg_catalog.macaddr_and(macaddr, macaddr) returns macaddr
  language internal;

-- less-equal-greater
create function pg_catalog.macaddr_cmp(macaddr, macaddr) returns integer
  language internal;

-- implementation of = operator
create function pg_catalog.macaddr_eq(macaddr, macaddr) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.macaddr_ge(macaddr, macaddr) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.macaddr_gt(macaddr, macaddr) returns boolean
  language internal;

-- I/O
create function pg_catalog.macaddr_in(cstring) returns macaddr
  language internal;

-- implementation of <= operator
create function pg_catalog.macaddr_le(macaddr, macaddr) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.macaddr_lt(macaddr, macaddr) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.macaddr_ne(macaddr, macaddr) returns boolean
  language internal;

-- implementation of ~ operator
create function pg_catalog.macaddr_not(macaddr) returns macaddr
  language internal;

-- implementation of | operator
create function pg_catalog.macaddr_or(macaddr, macaddr) returns macaddr
  language internal;

-- I/O
create function pg_catalog.macaddr_out(macaddr) returns cstring
  language internal;

-- I/O
create function pg_catalog.macaddr_recv(internal) returns macaddr
  language internal;

-- I/O
create function pg_catalog.macaddr_send(macaddr) returns bytea
  language internal;

-- sort support
create function pg_catalog.macaddr_sortsupport(internal) returns void
  language internal;

-- construct date
create function pg_catalog.make_date(year integer, month integer, day integer) returns date
  language internal;

-- construct interval
create function pg_catalog.make_interval(years integer DEFAULT 0, months integer DEFAULT 0, weeks integer DEFAULT 0, days integer DEFAULT 0, hours integer DEFAULT 0, mins integer DEFAULT 0, secs double precision DEFAULT 0.0) returns interval
  language internal;

-- construct time
create function pg_catalog.make_time(hour integer, min integer, sec double precision) returns time without time zone
  language internal;

-- construct timestamp
create function pg_catalog.make_timestamp(year integer, month integer, mday integer, hour integer, min integer, sec double precision) returns timestamp without time zone
  language internal;

-- construct timestamp with time zone
create function pg_catalog.make_timestamptz(year integer, month integer, mday integer, hour integer, min integer, sec double precision) returns timestamp with time zone
  language internal;

-- construct timestamp with time zone
create function pg_catalog.make_timestamptz(year integer, month integer, mday integer, hour integer, min integer, sec double precision, timezone text) returns timestamp with time zone
  language internal;

-- make ACL item
create function pg_catalog.makeaclitem(oid, oid, text, boolean) returns aclitem
  language internal;

-- netmask length
create function pg_catalog.masklen(inet) returns integer
  language internal;

-- join selectivity for generic matching operators
create function pg_catalog.matchingjoinsel(internal, oid, internal, smallint, internal) returns double precision
  language internal;

-- restriction selectivity for generic matching operators
create function pg_catalog.matchingsel(internal, oid, internal, integer) returns double precision
  language internal;

-- maximum value of all anyarray input values
create aggregate pg_catalog.max(anyarray) (
  sfunc = array_larger,
  stype = anyarray,
  combinefunc = array_larger
);

-- maximum value of all enum input values
create aggregate pg_catalog.max(anyenum) (
  sfunc = enum_larger,
  stype = anyenum,
  combinefunc = enum_larger
);

-- maximum value of all bigint input values
create aggregate pg_catalog.max(bigint) (
  sfunc = int8larger,
  stype = bigint,
  combinefunc = int8larger
);

-- maximum value of all bytea input values
create aggregate pg_catalog.max(bytea) (
  sfunc = bytea_larger,
  stype = bytea,
  combinefunc = bytea_larger
);

-- maximum value of all bpchar input values
create aggregate pg_catalog.max(character) (
  sfunc = bpchar_larger,
  stype = character,
  combinefunc = bpchar_larger
);

-- maximum value of all date input values
create aggregate pg_catalog.max(date) (
  sfunc = date_larger,
  stype = date,
  combinefunc = date_larger
);

-- maximum value of all float8 input values
create aggregate pg_catalog.max(double precision) (
  sfunc = float8larger,
  stype = double precision,
  combinefunc = float8larger
);

-- maximum value of all inet input values
create aggregate pg_catalog.max(inet) (
  sfunc = network_larger,
  stype = inet,
  combinefunc = network_larger
);

-- maximum value of all integer input values
create aggregate pg_catalog.max(integer) (
  sfunc = int4larger,
  stype = integer,
  combinefunc = int4larger
);

-- maximum value of all interval input values
create aggregate pg_catalog.max(interval) (
  sfunc = interval_larger,
  stype = interval,
  combinefunc = interval_larger
);

-- maximum value of all money input values
create aggregate pg_catalog.max(money) (
  sfunc = cashlarger,
  stype = money,
  combinefunc = cashlarger
);

-- maximum value of all numeric input values
create aggregate pg_catalog.max(numeric) (
  sfunc = numeric_larger,
  stype = numeric,
  combinefunc = numeric_larger
);

-- maximum value of all oid input values
create aggregate pg_catalog.max(oid) (
  sfunc = oidlarger,
  stype = oid,
  combinefunc = oidlarger
);

-- maximum value of all pg_lsn input values
create aggregate pg_catalog.max(pg_lsn) (
  sfunc = pg_lsn_larger,
  stype = pg_lsn,
  combinefunc = pg_lsn_larger
);

-- maximum value of all float4 input values
create aggregate pg_catalog.max(real) (
  sfunc = float4larger,
  stype = real,
  combinefunc = float4larger
);

-- maximum value of all record input values
create aggregate pg_catalog.max(record) (
  sfunc = record_larger,
  stype = record,
  combinefunc = record_larger
);

-- maximum value of all smallint input values
create aggregate pg_catalog.max(smallint) (
  sfunc = int2larger,
  stype = smallint,
  combinefunc = int2larger
);

-- maximum value of all text input values
create aggregate pg_catalog.max(text) (
  sfunc = text_larger,
  stype = text,
  combinefunc = text_larger
);

-- maximum value of all tid input values
create aggregate pg_catalog.max(tid) (
  sfunc = tidlarger,
  stype = tid,
  combinefunc = tidlarger
);

-- maximum value of all time with time zone input values
create aggregate pg_catalog.max(time with time zone) (
  sfunc = timetz_larger,
  stype = time with time zone,
  combinefunc = timetz_larger
);

-- maximum value of all time input values
create aggregate pg_catalog.max(time without time zone) (
  sfunc = time_larger,
  stype = time without time zone,
  combinefunc = time_larger
);

-- maximum value of all timestamp with time zone input values
create aggregate pg_catalog.max(timestamp with time zone) (
  sfunc = timestamptz_larger,
  stype = timestamp with time zone,
  combinefunc = timestamptz_larger
);

-- maximum value of all timestamp input values
create aggregate pg_catalog.max(timestamp without time zone) (
  sfunc = timestamp_larger,
  stype = timestamp without time zone,
  combinefunc = timestamp_larger
);

-- maximum value of all xid8 input values
create aggregate pg_catalog.max(xid8) (
  sfunc = xid8_larger,
  stype = xid8,
  combinefunc = xid8_larger
);

-- MD5 hash
create function pg_catalog.md5(bytea) returns text
  language internal;

-- MD5 hash
create function pg_catalog.md5(text) returns text
  language internal;

-- internal conversion function for MULE_INTERNAL to BIG5
create function pg_catalog.mic_to_big5(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for MULE_INTERNAL to EUC_CN
create function pg_catalog.mic_to_euc_cn(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for MULE_INTERNAL to EUC_JP
create function pg_catalog.mic_to_euc_jp(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for MULE_INTERNAL to EUC_KR
create function pg_catalog.mic_to_euc_kr(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for MULE_INTERNAL to EUC_TW
create function pg_catalog.mic_to_euc_tw(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for MULE_INTERNAL to ISO-8859-5
create function pg_catalog.mic_to_iso(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for MULE_INTERNAL to KOI8R
create function pg_catalog.mic_to_koi8r(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for MULE_INTERNAL to LATIN1
create function pg_catalog.mic_to_latin1(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for MULE_INTERNAL to LATIN2
create function pg_catalog.mic_to_latin2(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for MULE_INTERNAL to LATIN3
create function pg_catalog.mic_to_latin3(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for MULE_INTERNAL to LATIN4
create function pg_catalog.mic_to_latin4(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for MULE_INTERNAL to SJIS
create function pg_catalog.mic_to_sjis(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for MULE_INTERNAL to WIN1250
create function pg_catalog.mic_to_win1250(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for MULE_INTERNAL to WIN1251
create function pg_catalog.mic_to_win1251(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- internal conversion function for MULE_INTERNAL to WIN866
create function pg_catalog.mic_to_win866(integer, integer, cstring, internal, integer, boolean) returns integer
  language c;

-- minimum value of all anyarray input values
create aggregate pg_catalog.min(anyarray) (
  sfunc = array_smaller,
  stype = anyarray,
  combinefunc = array_smaller
);

-- minimum value of all enum input values
create aggregate pg_catalog.min(anyenum) (
  sfunc = enum_smaller,
  stype = anyenum,
  combinefunc = enum_smaller
);

-- minimum value of all bigint input values
create aggregate pg_catalog.min(bigint) (
  sfunc = int8smaller,
  stype = bigint,
  combinefunc = int8smaller
);

-- minimum value of all bytea input values
create aggregate pg_catalog.min(bytea) (
  sfunc = bytea_smaller,
  stype = bytea,
  combinefunc = bytea_smaller
);

-- minimum value of all bpchar input values
create aggregate pg_catalog.min(character) (
  sfunc = bpchar_smaller,
  stype = character,
  combinefunc = bpchar_smaller
);

-- minimum value of all date input values
create aggregate pg_catalog.min(date) (
  sfunc = date_smaller,
  stype = date,
  combinefunc = date_smaller
);

-- minimum value of all float8 input values
create aggregate pg_catalog.min(double precision) (
  sfunc = float8smaller,
  stype = double precision,
  combinefunc = float8smaller
);

-- minimum value of all inet input values
create aggregate pg_catalog.min(inet) (
  sfunc = network_smaller,
  stype = inet,
  combinefunc = network_smaller
);

-- minimum value of all integer input values
create aggregate pg_catalog.min(integer) (
  sfunc = int4smaller,
  stype = integer,
  combinefunc = int4smaller
);

-- minimum value of all interval input values
create aggregate pg_catalog.min(interval) (
  sfunc = interval_smaller,
  stype = interval,
  combinefunc = interval_smaller
);

-- minimum value of all money input values
create aggregate pg_catalog.min(money) (
  sfunc = cashsmaller,
  stype = money,
  combinefunc = cashsmaller
);

-- minimum value of all numeric input values
create aggregate pg_catalog.min(numeric) (
  sfunc = numeric_smaller,
  stype = numeric,
  combinefunc = numeric_smaller
);

-- minimum value of all oid input values
create aggregate pg_catalog.min(oid) (
  sfunc = oidsmaller,
  stype = oid,
  combinefunc = oidsmaller
);

-- minimum value of all pg_lsn input values
create aggregate pg_catalog.min(pg_lsn) (
  sfunc = pg_lsn_smaller,
  stype = pg_lsn,
  combinefunc = pg_lsn_smaller
);

-- minimum value of all float4 input values
create aggregate pg_catalog.min(real) (
  sfunc = float4smaller,
  stype = real,
  combinefunc = float4smaller
);

-- minimum value of all record input values
create aggregate pg_catalog.min(record) (
  sfunc = record_smaller,
  stype = record,
  combinefunc = record_smaller
);

-- minimum value of all smallint input values
create aggregate pg_catalog.min(smallint) (
  sfunc = int2smaller,
  stype = smallint,
  combinefunc = int2smaller
);

-- minimum value of all text values
create aggregate pg_catalog.min(text) (
  sfunc = text_smaller,
  stype = text,
  combinefunc = text_smaller
);

-- minimum value of all tid input values
create aggregate pg_catalog.min(tid) (
  sfunc = tidsmaller,
  stype = tid,
  combinefunc = tidsmaller
);

-- minimum value of all time with time zone input values
create aggregate pg_catalog.min(time with time zone) (
  sfunc = timetz_smaller,
  stype = time with time zone,
  combinefunc = timetz_smaller
);

-- minimum value of all time input values
create aggregate pg_catalog.min(time without time zone) (
  sfunc = time_smaller,
  stype = time without time zone,
  combinefunc = time_smaller
);

-- minimum value of all timestamp with time zone input values
create aggregate pg_catalog.min(timestamp with time zone) (
  sfunc = timestamptz_smaller,
  stype = timestamp with time zone,
  combinefunc = timestamptz_smaller
);

-- minimum value of all timestamp input values
create aggregate pg_catalog.min(timestamp without time zone) (
  sfunc = timestamp_smaller,
  stype = timestamp without time zone,
  combinefunc = timestamp_smaller
);

-- minimum value of all xid8 input values
create aggregate pg_catalog.min(xid8) (
  sfunc = xid8_smaller,
  stype = xid8,
  combinefunc = xid8_smaller
);

-- minimum scale needed to represent the value
create function pg_catalog.min_scale(numeric) returns integer
  language internal;

-- modulus
create function pg_catalog.mod(bigint, bigint) returns bigint
  language internal;

-- modulus
create function pg_catalog.mod(integer, integer) returns integer
  language internal;

-- modulus
create function pg_catalog.mod(numeric, numeric) returns numeric
  language internal;

-- modulus
create function pg_catalog.mod(smallint, smallint) returns smallint
  language internal;

-- aggregate final function
create function pg_catalog.mode_final(internal, anyelement) returns anyelement
  language internal;

-- convert int8 to money
create function pg_catalog.money(bigint) returns money
  language internal;

-- convert int4 to money
create function pg_catalog.money(integer) returns money
  language internal;

-- convert numeric to money
create function pg_catalog.money(numeric) returns money
  language internal;

-- implementation of * operator
create function pg_catalog.mul_d_interval(double precision, interval) returns interval
  language internal;

-- anymultirange cast
create function pg_catalog.multirange(anyrange) returns anymultirange
  language internal;

-- implementation of -|- operator
create function pg_catalog.multirange_adjacent_multirange(anymultirange, anymultirange) returns boolean
  language internal;

-- implementation of -|- operator
create function pg_catalog.multirange_adjacent_range(anymultirange, anyrange) returns boolean
  language internal;

-- implementation of >> operator
create function pg_catalog.multirange_after_multirange(anymultirange, anymultirange) returns boolean
  language internal;

-- implementation of >> operator
create function pg_catalog.multirange_after_range(anymultirange, anyrange) returns boolean
  language internal;

-- aggregate final function
create function pg_catalog.multirange_agg_finalfn(internal, anymultirange) returns anymultirange
  language internal;

-- aggregate transition function
create function pg_catalog.multirange_agg_transfn(internal, anymultirange) returns internal
  language internal;

-- implementation of << operator
create function pg_catalog.multirange_before_multirange(anymultirange, anymultirange) returns boolean
  language internal;

-- implementation of << operator
create function pg_catalog.multirange_before_range(anymultirange, anyrange) returns boolean
  language internal;

-- less-equal-greater
create function pg_catalog.multirange_cmp(anymultirange, anymultirange) returns integer
  language internal;

-- implementation of <@ operator
create function pg_catalog.multirange_contained_by_multirange(anymultirange, anymultirange) returns boolean
  language internal;

-- implementation of <@ operator
create function pg_catalog.multirange_contained_by_range(anymultirange, anyrange) returns boolean
  language internal;

-- implementation of @> operator
create function pg_catalog.multirange_contains_elem(anymultirange, anyelement) returns boolean
  language internal;

-- implementation of @> operator
create function pg_catalog.multirange_contains_multirange(anymultirange, anymultirange) returns boolean
  language internal;

-- implementation of @> operator
create function pg_catalog.multirange_contains_range(anymultirange, anyrange) returns boolean
  language internal;

-- implementation of = operator
create function pg_catalog.multirange_eq(anymultirange, anymultirange) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.multirange_ge(anymultirange, anymultirange) returns boolean
  language internal;

-- GiST support
create function pg_catalog.multirange_gist_compress(internal) returns internal
  language internal;

-- GiST support
create function pg_catalog.multirange_gist_consistent(internal, anymultirange, smallint, oid, internal) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.multirange_gt(anymultirange, anymultirange) returns boolean
  language internal;

-- I/O
create function pg_catalog.multirange_in(cstring, oid, integer) returns anymultirange
  language internal;

-- implementation of * operator
create function pg_catalog.multirange_intersect(anymultirange, anymultirange) returns anymultirange
  language internal;

-- range aggregate by intersecting
create function pg_catalog.multirange_intersect_agg_transfn(anymultirange, anymultirange) returns anymultirange
  language internal;

-- implementation of <= operator
create function pg_catalog.multirange_le(anymultirange, anymultirange) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.multirange_lt(anymultirange, anymultirange) returns boolean
  language internal;

-- implementation of - operator
create function pg_catalog.multirange_minus(anymultirange, anymultirange) returns anymultirange
  language internal;

-- implementation of <> operator
create function pg_catalog.multirange_ne(anymultirange, anymultirange) returns boolean
  language internal;

-- I/O
create function pg_catalog.multirange_out(anymultirange) returns cstring
  language internal;

-- implementation of && operator
create function pg_catalog.multirange_overlaps_multirange(anymultirange, anymultirange) returns boolean
  language internal;

-- implementation of && operator
create function pg_catalog.multirange_overlaps_range(anymultirange, anyrange) returns boolean
  language internal;

-- implementation of &< operator
create function pg_catalog.multirange_overleft_multirange(anymultirange, anymultirange) returns boolean
  language internal;

-- implementation of &< operator
create function pg_catalog.multirange_overleft_range(anymultirange, anyrange) returns boolean
  language internal;

-- implementation of &> operator
create function pg_catalog.multirange_overright_multirange(anymultirange, anymultirange) returns boolean
  language internal;

-- implementation of &> operator
create function pg_catalog.multirange_overright_range(anymultirange, anyrange) returns boolean
  language internal;

-- I/O
create function pg_catalog.multirange_recv(internal, oid, integer) returns anymultirange
  language internal;

-- I/O
create function pg_catalog.multirange_send(anymultirange) returns bytea
  language internal;

-- multirange typanalyze
create function pg_catalog.multirange_typanalyze(internal) returns boolean
  language internal;

-- implementation of + operator
create function pg_catalog.multirange_union(anymultirange, anymultirange) returns anymultirange
  language internal;

-- restriction selectivity for multirange operators
create function pg_catalog.multirangesel(internal, oid, internal, integer) returns double precision
  language internal;

-- age of a multi-transaction ID, in multi-transactions before current multi-transaction
create function pg_catalog.mxid_age(xid) returns integer
  language internal;

-- convert char(n) to name
create function pg_catalog.name(character) returns name
  language internal;

-- convert varchar to name
create function pg_catalog.name(character varying) returns name
  language internal;

-- convert text to name
create function pg_catalog.name(text) returns name
  language internal;

-- concatenate name and oid
create function pg_catalog.nameconcatoid(name, oid) returns name
  language internal;

-- implementation of = operator
create function pg_catalog.nameeq(name, name) returns boolean
  language internal;

-- implementation of = operator
create function pg_catalog.nameeqtext(name, text) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.namege(name, name) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.namegetext(name, text) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.namegt(name, name) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.namegttext(name, text) returns boolean
  language internal;

-- implementation of ~~* operator
create function pg_catalog.nameiclike(name, text) returns boolean
  language internal;

-- implementation of !~~* operator
create function pg_catalog.nameicnlike(name, text) returns boolean
  language internal;

-- implementation of ~* operator
create function pg_catalog.nameicregexeq(name, text) returns boolean
  language internal;

-- implementation of !~* operator
create function pg_catalog.nameicregexne(name, text) returns boolean
  language internal;

-- I/O
create function pg_catalog.namein(cstring) returns name
  language internal;

-- implementation of <= operator
create function pg_catalog.namele(name, name) returns boolean
  language internal;

-- implementation of <= operator
create function pg_catalog.nameletext(name, text) returns boolean
  language internal;

-- implementation of ~~ operator
create function pg_catalog.namelike(name, text) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.namelt(name, name) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.namelttext(name, text) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.namene(name, name) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.namenetext(name, text) returns boolean
  language internal;

-- implementation of !~~ operator
create function pg_catalog.namenlike(name, text) returns boolean
  language internal;

-- I/O
create function pg_catalog.nameout(name) returns cstring
  language internal;

-- I/O
create function pg_catalog.namerecv(internal) returns name
  language internal;

-- implementation of ~ operator
create function pg_catalog.nameregexeq(name, text) returns boolean
  language internal;

-- implementation of !~ operator
create function pg_catalog.nameregexne(name, text) returns boolean
  language internal;

-- I/O
create function pg_catalog.namesend(name) returns bytea
  language internal;

-- join selectivity of <> and related operators
create function pg_catalog.neqjoinsel(internal, oid, internal, smallint, internal) returns double precision
  language internal;

-- restriction selectivity of <> and related operators
create function pg_catalog.neqsel(internal, oid, internal, integer) returns double precision
  language internal;

-- netmask of address
create function pg_catalog.netmask(inet) returns inet
  language internal;

-- network part of address
create function pg_catalog.network(inet) returns cidr
  language internal;

-- less-equal-greater
create function pg_catalog.network_cmp(inet, inet) returns integer
  language internal;

-- implementation of = operator
create function pg_catalog.network_eq(inet, inet) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.network_ge(inet, inet) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.network_gt(inet, inet) returns boolean
  language internal;

-- larger of two
create function pg_catalog.network_larger(inet, inet) returns inet
  language internal;

-- implementation of <= operator
create function pg_catalog.network_le(inet, inet) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.network_lt(inet, inet) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.network_ne(inet, inet) returns boolean
  language internal;

-- implementation of && operator
create function pg_catalog.network_overlap(inet, inet) returns boolean
  language internal;

-- smaller of two
create function pg_catalog.network_smaller(inet, inet) returns inet
  language internal;

-- sort support
create function pg_catalog.network_sortsupport(internal) returns void
  language internal;

-- implementation of << operator
create function pg_catalog.network_sub(inet, inet) returns boolean
  language internal;

-- implementation of <<= operator
create function pg_catalog.network_subeq(inet, inet) returns boolean
  language internal;

-- planner support for network_sub/superset
create function pg_catalog.network_subset_support(internal) returns internal
  language internal;

-- implementation of >> operator
create function pg_catalog.network_sup(inet, inet) returns boolean
  language internal;

-- implementation of >>= operator
create function pg_catalog.network_supeq(inet, inet) returns boolean
  language internal;

-- join selectivity for network operators
create function pg_catalog.networkjoinsel(internal, oid, internal, smallint, internal) returns double precision
  language internal;

-- restriction selectivity for network operators
create function pg_catalog.networksel(internal, oid, internal, integer) returns double precision
  language internal;

-- sequence next value
create function pg_catalog.nextval(regclass) returns bigint
  language internal;

-- join selectivity of NOT LIKE
create function pg_catalog.nlikejoinsel(internal, oid, internal, smallint, internal) returns double precision
  language internal;

-- restriction selectivity of NOT LIKE
create function pg_catalog.nlikesel(internal, oid, internal, integer) returns double precision
  language internal;

-- Unicode normalization
create function pg_catalog.normalize(text, text DEFAULT 'NFC'::text) returns text
  language internal;

-- does not match LIKE expression
create function pg_catalog.notlike(bytea, bytea) returns boolean
  language internal;

-- does not match LIKE expression
create function pg_catalog.notlike(name, text) returns boolean
  language internal;

-- does not match LIKE expression
create function pg_catalog.notlike(text, text) returns boolean
  language internal;

-- current transaction time
create function pg_catalog.now() returns timestamp with time zone
  language internal;

-- number of points
create function pg_catalog.npoints(path) returns integer
  language internal;

-- number of points
create function pg_catalog.npoints(polygon) returns integer
  language internal;

-- fetch the Nth row value
create function pg_catalog.nth_value(anyelement, integer) returns anyelement
  language internal;

-- split rows into N groups
create function pg_catalog.ntile(integer) returns integer
  language internal;

-- count the number of non-NULL arguments
create function pg_catalog.num_nonnulls(VARIADIC "any") returns integer
  language internal;

-- count the number of NULL arguments
create function pg_catalog.num_nulls(VARIADIC "any") returns integer
  language internal;

-- convert int8 to numeric
create function pg_catalog.numeric(bigint) returns numeric
  language internal;

-- convert float8 to numeric
create function pg_catalog.numeric(double precision) returns numeric
  language internal;

-- convert int4 to numeric
create function pg_catalog.numeric(integer) returns numeric
  language internal;

-- convert jsonb to numeric
create function pg_catalog.numeric(jsonb) returns numeric
  language internal;

-- convert money to numeric
create function pg_catalog.numeric(money) returns numeric
  language internal;

-- adjust numeric to typmod precision/scale
create function pg_catalog.numeric(numeric, integer) returns numeric
  language internal;

-- convert float4 to numeric
create function pg_catalog.numeric(real) returns numeric
  language internal;

-- convert int2 to numeric
create function pg_catalog.numeric(smallint) returns numeric
  language internal;

-- implementation of @ operator
create function pg_catalog.numeric_abs(numeric) returns numeric
  language internal;

-- aggregate transition function
create function pg_catalog.numeric_accum(internal, numeric) returns internal
  language internal;

-- aggregate transition function
create function pg_catalog.numeric_accum_inv(internal, numeric) returns internal
  language internal;

-- implementation of + operator
create function pg_catalog.numeric_add(numeric, numeric) returns numeric
  language internal;

-- aggregate final function
create function pg_catalog.numeric_avg(internal) returns numeric
  language internal;

-- aggregate transition function
create function pg_catalog.numeric_avg_accum(internal, numeric) returns internal
  language internal;

-- aggregate combine function
create function pg_catalog.numeric_avg_combine(internal, internal) returns internal
  language internal;

-- aggregate deserial function
create function pg_catalog.numeric_avg_deserialize(bytea, internal) returns internal
  language internal;

-- aggregate serial function
create function pg_catalog.numeric_avg_serialize(internal) returns bytea
  language internal;

-- less-equal-greater
create function pg_catalog.numeric_cmp(numeric, numeric) returns integer
  language internal;

-- aggregate combine function
create function pg_catalog.numeric_combine(internal, internal) returns internal
  language internal;

-- aggregate deserial function
create function pg_catalog.numeric_deserialize(bytea, internal) returns internal
  language internal;

-- implementation of / operator
create function pg_catalog.numeric_div(numeric, numeric) returns numeric
  language internal;

-- trunc(x/y)
create function pg_catalog.numeric_div_trunc(numeric, numeric) returns numeric
  language internal;

-- implementation of = operator
create function pg_catalog.numeric_eq(numeric, numeric) returns boolean
  language internal;

-- natural exponential (e^x)
create function pg_catalog.numeric_exp(numeric) returns numeric
  language internal;

-- implementation of >= operator
create function pg_catalog.numeric_ge(numeric, numeric) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.numeric_gt(numeric, numeric) returns boolean
  language internal;

-- I/O
create function pg_catalog.numeric_in(cstring, oid, integer) returns numeric
  language internal;

-- increment by one
create function pg_catalog.numeric_inc(numeric) returns numeric
  language internal;

-- larger of two
create function pg_catalog.numeric_larger(numeric, numeric) returns numeric
  language internal;

-- implementation of <= operator
create function pg_catalog.numeric_le(numeric, numeric) returns boolean
  language internal;

-- natural logarithm
create function pg_catalog.numeric_ln(numeric) returns numeric
  language internal;

-- logarithm base m of n
create function pg_catalog.numeric_log(numeric, numeric) returns numeric
  language internal;

-- implementation of < operator
create function pg_catalog.numeric_lt(numeric, numeric) returns boolean
  language internal;

-- implementation of % operator
create function pg_catalog.numeric_mod(numeric, numeric) returns numeric
  language internal;

-- implementation of * operator
create function pg_catalog.numeric_mul(numeric, numeric) returns numeric
  language internal;

-- implementation of <> operator
create function pg_catalog.numeric_ne(numeric, numeric) returns boolean
  language internal;

-- I/O
create function pg_catalog.numeric_out(numeric) returns cstring
  language internal;

-- implementation of + operator
create function pg_catalog.numeric_pl_pg_lsn(numeric, pg_lsn) returns pg_lsn
  language sql;

-- aggregate final function
create function pg_catalog.numeric_poly_avg(internal) returns numeric
  language internal;

-- aggregate combine function
create function pg_catalog.numeric_poly_combine(internal, internal) returns internal
  language internal;

-- aggregate deserial function
create function pg_catalog.numeric_poly_deserialize(bytea, internal) returns internal
  language internal;

-- aggregate serial function
create function pg_catalog.numeric_poly_serialize(internal) returns bytea
  language internal;

-- aggregate final function
create function pg_catalog.numeric_poly_stddev_pop(internal) returns numeric
  language internal;

-- aggregate final function
create function pg_catalog.numeric_poly_stddev_samp(internal) returns numeric
  language internal;

-- aggregate final function
create function pg_catalog.numeric_poly_sum(internal) returns numeric
  language internal;

-- aggregate final function
create function pg_catalog.numeric_poly_var_pop(internal) returns numeric
  language internal;

-- aggregate final function
create function pg_catalog.numeric_poly_var_samp(internal) returns numeric
  language internal;

-- implementation of ^ operator
create function pg_catalog.numeric_power(numeric, numeric) returns numeric
  language internal;

-- I/O
create function pg_catalog.numeric_recv(internal, oid, integer) returns numeric
  language internal;

-- I/O
create function pg_catalog.numeric_send(numeric) returns bytea
  language internal;

-- aggregate serial function
create function pg_catalog.numeric_serialize(internal) returns bytea
  language internal;

-- smaller of two
create function pg_catalog.numeric_smaller(numeric, numeric) returns numeric
  language internal;

-- sort support
create function pg_catalog.numeric_sortsupport(internal) returns void
  language internal;

-- square root
create function pg_catalog.numeric_sqrt(numeric) returns numeric
  language internal;

-- aggregate final function
create function pg_catalog.numeric_stddev_pop(internal) returns numeric
  language internal;

-- aggregate final function
create function pg_catalog.numeric_stddev_samp(internal) returns numeric
  language internal;

-- implementation of - operator
create function pg_catalog.numeric_sub(numeric, numeric) returns numeric
  language internal;

-- aggregate final function
create function pg_catalog.numeric_sum(internal) returns numeric
  language internal;

-- planner support for numeric length coercion
create function pg_catalog.numeric_support(internal) returns internal
  language internal;

-- implementation of - operator
create function pg_catalog.numeric_uminus(numeric) returns numeric
  language internal;

-- implementation of + operator
create function pg_catalog.numeric_uplus(numeric) returns numeric
  language internal;

-- aggregate final function
create function pg_catalog.numeric_var_pop(internal) returns numeric
  language internal;

-- aggregate final function
create function pg_catalog.numeric_var_samp(internal) returns numeric
  language internal;

-- I/O typmod
create function pg_catalog.numerictypmodin(cstring[]) returns integer
  language internal;

-- I/O typmod
create function pg_catalog.numerictypmodout(integer) returns cstring
  language internal;

-- nummultirange constructor
create function pg_catalog.nummultirange() returns nummultirange
  language internal;

-- nummultirange constructor
create function pg_catalog.nummultirange(numrange) returns nummultirange
  language internal;

-- nummultirange constructor
create function pg_catalog.nummultirange(VARIADIC numrange[]) returns nummultirange
  language internal;

-- number of nodes
create function pg_catalog.numnode(tsquery) returns integer
  language internal;

-- numrange constructor
create function pg_catalog.numrange(numeric, numeric) returns numrange
  language internal;

-- numrange constructor
create function pg_catalog.numrange(numeric, numeric, text) returns numrange
  language internal;

-- float8 difference of two numeric values
create function pg_catalog.numrange_subdiff(numeric, numeric) returns double precision
  language internal;

-- deprecated, use two-argument form instead
create function pg_catalog.obj_description(oid) returns text
  language sql;

-- get description for object id and catalog name
create function pg_catalog.obj_description(oid, name) returns text
  language sql;

-- octet length
create function pg_catalog.octet_length(bit) returns integer
  language internal;

-- octet length
create function pg_catalog.octet_length(bytea) returns integer
  language internal;

-- octet length
create function pg_catalog.octet_length(character) returns integer
  language internal;

-- octet length
create function pg_catalog.octet_length(text) returns integer
  language internal;

-- convert int8 to oid
create function pg_catalog.oid(bigint) returns oid
  language internal;

-- implementation of = operator
create function pg_catalog.oideq(oid, oid) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.oidge(oid, oid) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.oidgt(oid, oid) returns boolean
  language internal;

-- I/O
create function pg_catalog.oidin(cstring) returns oid
  language internal;

-- larger of two
create function pg_catalog.oidlarger(oid, oid) returns oid
  language internal;

-- implementation of <= operator
create function pg_catalog.oidle(oid, oid) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.oidlt(oid, oid) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.oidne(oid, oid) returns boolean
  language internal;

-- I/O
create function pg_catalog.oidout(oid) returns cstring
  language internal;

-- I/O
create function pg_catalog.oidrecv(internal) returns oid
  language internal;

-- I/O
create function pg_catalog.oidsend(oid) returns bytea
  language internal;

-- smaller of two
create function pg_catalog.oidsmaller(oid, oid) returns oid
  language internal;

-- implementation of = operator
create function pg_catalog.oidvectoreq(oidvector, oidvector) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.oidvectorge(oidvector, oidvector) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.oidvectorgt(oidvector, oidvector) returns boolean
  language internal;

-- I/O
create function pg_catalog.oidvectorin(cstring) returns oidvector
  language internal;

-- implementation of <= operator
create function pg_catalog.oidvectorle(oidvector, oidvector) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.oidvectorlt(oidvector, oidvector) returns boolean
  language internal;

-- implementation of <> operator
create function pg_catalog.oidvectorne(oidvector, oidvector) returns boolean
  language internal;

-- I/O
create function pg_catalog.oidvectorout(oidvector) returns cstring
  language internal;

-- I/O
create function pg_catalog.oidvectorrecv(internal) returns oidvector
  language internal;

-- I/O
create function pg_catalog.oidvectorsend(oidvector) returns bytea
  language internal;

-- print type names of oidvector field
create function pg_catalog.oidvectortypes(oidvector) returns text
  language internal;

-- implementation of <@ operator
create function pg_catalog.on_pb(point, box) returns boolean
  language internal;

-- implementation of <@ operator
create function pg_catalog.on_pl(point, line) returns boolean
  language internal;

-- implementation of <@ operator
create function pg_catalog.on_ppath(point, path) returns boolean
  language internal;

-- implementation of <@ operator
create function pg_catalog.on_ps(point, lseg) returns boolean
  language internal;

-- implementation of <@ operator
create function pg_catalog.on_sb(lseg, box) returns boolean
  language internal;

-- implementation of <@ operator
create function pg_catalog.on_sl(lseg, line) returns boolean
  language internal;

-- aggregate transition function
create function pg_catalog.ordered_set_transition(internal, "any") returns internal
  language internal;

-- aggregate transition function
create function pg_catalog.ordered_set_transition_multi(internal, VARIADIC "any") returns internal
  language internal;

-- intervals overlap?
create function pg_catalog.overlaps(time with time zone, time with time zone, time with time zone, time with time zone) returns boolean
  language internal;

-- intervals overlap?
create function pg_catalog.overlaps(time without time zone, interval, time without time zone, interval) returns boolean
  language sql;

-- intervals overlap?
create function pg_catalog.overlaps(time without time zone, interval, time without time zone, time without time zone) returns boolean
  language sql;

-- intervals overlap?
create function pg_catalog.overlaps(time without time zone, time without time zone, time without time zone, interval) returns boolean
  language sql;

-- intervals overlap?
create function pg_catalog.overlaps(time without time zone, time without time zone, time without time zone, time without time zone) returns boolean
  language internal;

-- intervals overlap?
create function pg_catalog.overlaps(timestamp with time zone, interval, timestamp with time zone, interval) returns boolean
  language sql;

-- intervals overlap?
create function pg_catalog.overlaps(timestamp with time zone, interval, timestamp with time zone, timestamp with time zone) returns boolean
  language sql;

-- intervals overlap?
create function pg_catalog.overlaps(timestamp with time zone, timestamp with time zone, timestamp with time zone, interval) returns boolean
  language sql;

-- intervals overlap?
create function pg_catalog.overlaps(timestamp with time zone, timestamp with time zone, timestamp with time zone, timestamp with time zone) returns boolean
  language internal;

-- intervals overlap?
create function pg_catalog.overlaps(timestamp without time zone, interval, timestamp without time zone, interval) returns boolean
  language sql;

-- intervals overlap?
create function pg_catalog.overlaps(timestamp without time zone, interval, timestamp without time zone, timestamp without time zone) returns boolean
  language sql;

-- intervals overlap?
create function pg_catalog.overlaps(timestamp without time zone, timestamp without time zone, timestamp without time zone, interval) returns boolean
  language sql;

-- intervals overlap?
create function pg_catalog.overlaps(timestamp without time zone, timestamp without time zone, timestamp without time zone, timestamp without time zone) returns boolean
  language internal;

-- substitute portion of bitstring
create function pg_catalog.overlay(bit, bit, integer) returns bit
  language internal;

-- substitute portion of bitstring
create function pg_catalog.overlay(bit, bit, integer, integer) returns bit
  language internal;

-- substitute portion of string
create function pg_catalog.overlay(bytea, bytea, integer) returns bytea
  language internal;

-- substitute portion of string
create function pg_catalog.overlay(bytea, bytea, integer, integer) returns bytea
  language internal;

-- substitute portion of string
create function pg_catalog.overlay(text, text, integer) returns text
  language internal;

-- substitute portion of string
create function pg_catalog.overlay(text, text, integer, integer) returns text
  language internal;

-- parse qualified identifier to array of identifiers
create function pg_catalog.parse_ident(str text, strict boolean DEFAULT true) returns text[]
  language internal;

-- convert polygon to path
create function pg_catalog.path(polygon) returns path
  language internal;

-- implementation of + operator
create function pg_catalog.path_add(path, path) returns path
  language internal;

-- implementation of + operator
create function pg_catalog.path_add_pt(path, point) returns path
  language internal;

-- implementation of @> operator
create function pg_catalog.path_contain_pt(path, point) returns boolean
  language sql;

-- implementation of <-> operator
create function pg_catalog.path_distance(path, path) returns double precision
  language internal;

-- implementation of / operator
create function pg_catalog.path_div_pt(path, point) returns path
  language internal;

-- I/O
create function pg_catalog.path_in(cstring) returns path
  language internal;

-- implementation of ?# operator
create function pg_catalog.path_inter(path, path) returns boolean
  language internal;

-- implementation of @-@ operator
create function pg_catalog.path_length(path) returns double precision
  language internal;

-- implementation of * operator
create function pg_catalog.path_mul_pt(path, point) returns path
  language internal;

-- implementation of = operator
create function pg_catalog.path_n_eq(path, path) returns boolean
  language internal;

-- implementation of >= operator
create function pg_catalog.path_n_ge(path, path) returns boolean
  language internal;

-- implementation of > operator
create function pg_catalog.path_n_gt(path, path) returns boolean
  language internal;

-- implementation of <= operator
create function pg_catalog.path_n_le(path, path) returns boolean
  language internal;

-- implementation of < operator
create function pg_catalog.path_n_lt(path, path) returns boolean
  language internal;

-- implementation of # operator
create function pg_catalog.path_npoints(path) returns integer
  language internal;

-- I/O
create function pg_catalog.path_out(path) returns cstring
  language internal;

-- I/O
create function pg_catalog.path_recv(internal) returns path
  language internal;

-- I/O
create function pg_catalog.path_send(path) returns bytea
  language internal;

-- implementation of - operator
create function pg_catalog.path_sub_pt(path, point) returns path
  language internal;

-- close path
create function pg_catalog.pclose(path) returns path
  language internal;

-- fractional rank within partition
create function pg_catalog.percent_rank() returns double precision
  language internal;

-- aggregate final function
create function pg_catalog.percent_rank_final(internal, VARIADIC "any") returns double precision
  language internal;

-- aggregate final function
create function pg_catalog.percentile_cont_float8_final(internal, double precision) returns double precision
  language internal;

-- aggregate final function
create function pg_catalog.percentile_cont_float8_multi_final(internal, double precision[]) returns double precision[]
  language internal;

-- aggregate final function
create function pg_catalog.percentile_cont_interval_final(internal, double precision) returns interval
  language internal;

-- aggregate final function
create function pg_catalog.percentile_cont_interval_multi_final(internal, double precision[]) returns interval[]
  language internal;

-- aggregate final function
create function pg_catalog.percentile_disc_final(internal, double precision, anyelement) returns anyelement
  language internal;

-- aggregate final function
create function pg_catalog.percentile_disc_multi_final(internal, double precision[], anyelement) returns anyarray
  language internal;

-- obtain exclusive advisory lock
create function pg_catalog.pg_advisory_lock(bigint) returns void
  language internal;

-- obtain exclusive advisory lock
create function pg_catalog.pg_advisory_lock(integer, integer) returns void
  language internal;

-- obtain shared advisory lock
create function pg_catalog.pg_advisory_lock_shared(bigint) returns void
  language internal;

-- obtain shared advisory lock
create function pg_catalog.pg_advisory_lock_shared(integer, integer) returns void
  language internal;

-- release exclusive advisory lock
create function pg_catalog.pg_advisory_unlock(bigint) returns boolean
  language internal;

-- release exclusive advisory lock
create function pg_catalog.pg_advisory_unlock(integer, integer) returns boolean
  language internal;

-- release all advisory locks
create function pg_catalog.pg_advisory_unlock_all() returns void
  language internal;

-- release shared advisory lock
create function pg_catalog.pg_advisory_unlock_shared(bigint) returns boolean
  language internal;

-- release shared advisory lock
create function pg_catalog.pg_advisory_unlock_shared(integer, integer) returns boolean
  language internal;

-- obtain exclusive advisory lock
create function pg_catalog.pg_advisory_xact_lock(bigint) returns void
  language internal;

-- obtain exclusive advisory lock
create function pg_catalog.pg_advisory_xact_lock(integer, integer) returns void
  language internal;

-- obtain shared advisory lock
create function pg_catalog.pg_advisory_xact_lock_shared(bigint) returns void
  language internal;

-- obtain shared advisory lock
create function pg_catalog.pg_advisory_xact_lock_shared(integer, integer) returns void
  language internal;

-- list available extension versions
create function pg_catalog.pg_available_extension_versions(OUT name name, OUT version text, OUT superuser boolean, OUT trusted boolean, OUT relocatable boolean, OUT schema name, OUT requires name[], OUT comment text) returns SETOF record
  language internal;

-- list available extensions
create function pg_catalog.pg_available_extensions(OUT name name, OUT default_version text, OUT comment text) returns SETOF record
  language internal;

-- list of available WAL summary files
create function pg_catalog.pg_available_wal_summaries(OUT tli bigint, OUT start_lsn pg_lsn, OUT end_lsn pg_lsn) returns SETOF record
  language internal;

-- statistics: current backend PID
create function pg_catalog.pg_backend_pid() returns integer
  language internal;

-- prepare for taking an online backup
create function pg_catalog.pg_backup_start(label text, fast boolean DEFAULT false) returns pg_lsn
  language internal;

-- finish taking an online backup
create function pg_catalog.pg_backup_stop(wait_for_archive boolean DEFAULT true, OUT lsn pg_lsn, OUT labelfile text, OUT spcmapfile text) returns record
  language internal;

-- base type of a domain type
create function pg_catalog.pg_basetype(regtype) returns regtype
  language internal;

-- get array of PIDs of sessions blocking specified backend PID from acquiring a heavyweight lock
create function pg_catalog.pg_blocking_pids(integer) returns integer[]
  language internal;

-- cancel a server process' current query
create function pg_catalog.pg_cancel_backend(integer) returns boolean
  language internal;

-- convert encoding name to encoding id
create function pg_catalog.pg_char_to_encoding(name) returns integer
  language internal;

-- clear statistics on attribute
create function pg_catalog.pg_clear_attribute_stats(schemaname text, relname text, attname text, inherited boolean) returns void
  language internal;

-- clear statistics on relation
create function pg_catalog.pg_clear_relation_stats(schemaname text, relname text) returns void
  language internal;

-- encoding name of current database
create function pg_catalog.pg_client_encoding() returns name
  language internal;

-- get actual version of collation from operating system
create function pg_catalog.pg_collation_actual_version(oid) returns text
  language internal;

-- collation of the argument; implementation of the COLLATION FOR expression
create function pg_catalog.pg_collation_for("any") returns text
  language internal;

-- is collation visible in search path?
create function pg_catalog.pg_collation_is_visible(oid) returns boolean
  language internal;

-- compression method for the compressed datum
create function pg_catalog.pg_column_compression("any") returns text
  language internal;

-- is a column updatable
create function pg_catalog.pg_column_is_updatable(regclass, smallint, boolean) returns boolean
  language internal;

-- bytes required to store the value, perhaps with compression
create function pg_catalog.pg_column_size("any") returns integer
  language internal;

-- chunk ID of on-disk TOASTed value
create function pg_catalog.pg_column_toast_chunk_id("any") returns oid
  language internal;

-- configuration load time
create function pg_catalog.pg_conf_load_time() returns timestamp with time zone
  language internal;

-- pg_config binary as a function
create function pg_catalog.pg_config(OUT name text, OUT setting text) returns SETOF record
  language internal;

-- pg_controldata checkpoint state information as a function
create function pg_catalog.pg_control_checkpoint(OUT checkpoint_lsn pg_lsn, OUT redo_lsn pg_lsn, OUT redo_wal_file text, OUT timeline_id integer, OUT prev_timeline_id integer, OUT full_page_writes boolean, OUT next_xid text, OUT next_oid oid, OUT next_multixact_id xid, OUT next_multi_offset xid, OUT oldest_xid xid, OUT oldest_xid_dbid oid, OUT oldest_active_xid xid, OUT oldest_multi_xid xid, OUT oldest_multi_dbid oid, OUT oldest_commit_ts_xid xid, OUT newest_commit_ts_xid xid, OUT checkpoint_time timestamp with time zone) returns record
  language internal;

-- pg_controldata init state information as a function
create function pg_catalog.pg_control_init(OUT max_data_alignment integer, OUT database_block_size integer, OUT blocks_per_segment integer, OUT wal_block_size integer, OUT bytes_per_wal_segment integer, OUT max_identifier_length integer, OUT max_index_columns integer, OUT max_toast_chunk_size integer, OUT large_object_chunk_size integer, OUT float8_pass_by_value boolean, OUT data_page_checksum_version integer, OUT default_char_signedness boolean) returns record
  language internal;

-- pg_controldata recovery state information as a function
create function pg_catalog.pg_control_recovery(OUT min_recovery_end_lsn pg_lsn, OUT min_recovery_end_timeline integer, OUT backup_start_lsn pg_lsn, OUT backup_end_lsn pg_lsn, OUT end_of_backup_record_required boolean) returns record
  language internal;

-- pg_controldata general state information as a function
create function pg_catalog.pg_control_system(OUT pg_control_version integer, OUT catalog_version_no integer, OUT system_identifier bigint, OUT pg_control_last_modified timestamp with time zone) returns record
  language internal;

-- is conversion visible in search path?
create function pg_catalog.pg_conversion_is_visible(oid) returns boolean
  language internal;

-- copy a logical replication slot
create function pg_catalog.pg_copy_logical_replication_slot(src_slot_name name, dst_slot_name name, OUT slot_name name, OUT lsn pg_lsn) returns record
  language internal;

-- copy a logical replication slot, changing temporality
create function pg_catalog.pg_copy_logical_replication_slot(src_slot_name name, dst_slot_name name, temporary boolean, OUT slot_name name, OUT lsn pg_lsn) returns record
  language internal;

-- copy a logical replication slot, changing temporality and plugin
create function pg_catalog.pg_copy_logical_replication_slot(src_slot_name name, dst_slot_name name, temporary boolean, plugin name, OUT slot_name name, OUT lsn pg_lsn) returns record
  language internal;

-- copy a physical replication slot
create function pg_catalog.pg_copy_physical_replication_slot(src_slot_name name, dst_slot_name name, OUT slot_name name, OUT lsn pg_lsn) returns record
  language internal;

-- copy a physical replication slot, changing temporality
create function pg_catalog.pg_copy_physical_replication_slot(src_slot_name name, dst_slot_name name, temporary boolean, OUT slot_name name, OUT lsn pg_lsn) returns record
  language internal;

-- set up a logical replication slot
create function pg_catalog.pg_create_logical_replication_slot(slot_name name, plugin name, temporary boolean DEFAULT false, twophase boolean DEFAULT false, failover boolean DEFAULT false, OUT slot_name name, OUT lsn pg_lsn) returns record
  language internal;

-- create a physical replication slot
create function pg_catalog.pg_create_physical_replication_slot(slot_name name, immediately_reserve boolean DEFAULT false, temporary boolean DEFAULT false, OUT slot_name name, OUT lsn pg_lsn) returns record
  language internal;

-- create a named restore point
create function pg_catalog.pg_create_restore_point(text) returns pg_lsn
  language internal;

-- current logging collector file location
create function pg_catalog.pg_current_logfile() returns text
  language internal;

-- current logging collector file location
create function pg_catalog.pg_current_logfile(text) returns text
  language internal;

-- get current snapshot
create function pg_catalog.pg_current_snapshot() returns pg_snapshot
  language internal;

-- current wal flush location
create function pg_catalog.pg_current_wal_flush_lsn() returns pg_lsn
  language internal;

-- current wal insert location
create function pg_catalog.pg_current_wal_insert_lsn() returns pg_lsn
  language internal;

-- current wal write location
create function pg_catalog.pg_current_wal_lsn() returns pg_lsn
  language internal;

-- get current transaction ID
create function pg_catalog.pg_current_xact_id() returns xid8
  language internal;

-- get current transaction ID
create function pg_catalog.pg_current_xact_id_if_assigned() returns xid8
  language internal;

-- get the open cursors for this session
create function pg_catalog.pg_cursor(OUT name text, OUT statement text, OUT is_holdable boolean, OUT is_binary boolean, OUT is_scrollable boolean, OUT creation_time timestamp with time zone) returns SETOF record
  language internal;

-- get actual version of database collation from operating system
create function pg_catalog.pg_database_collation_actual_version(oid) returns text
  language internal;

-- total disk space usage for the specified database
create function pg_catalog.pg_database_size(name) returns bigint
  language internal;

-- total disk space usage for the specified database
create function pg_catalog.pg_database_size(oid) returns bigint
  language internal;

-- I/O
create function pg_catalog.pg_ddl_command_in(cstring) returns pg_ddl_command
  language internal;

-- I/O
create function pg_catalog.pg_ddl_command_out(pg_ddl_command) returns cstring
  language internal;

-- I/O
create function pg_catalog.pg_ddl_command_recv(internal) returns pg_ddl_command
  language internal;

-- I/O
create function pg_catalog.pg_ddl_command_send(pg_ddl_command) returns bytea
  language internal;

-- I/O
create function pg_catalog.pg_dependencies_in(cstring) returns pg_dependencies
  language internal;

-- I/O
create function pg_catalog.pg_dependencies_out(pg_dependencies) returns cstring
  language internal;

-- I/O
create function pg_catalog.pg_dependencies_recv(internal) returns pg_dependencies
  language internal;

-- I/O
create function pg_catalog.pg_dependencies_send(pg_dependencies) returns bytea
  language internal;

-- get identification of SQL object
create function pg_catalog.pg_describe_object(oid, oid, integer) returns text
  language internal;

-- drop a replication slot
create function pg_catalog.pg_drop_replication_slot(name) returns void
  language internal;

-- maximum octet length of a character in given encoding
create function pg_catalog.pg_encoding_max_length(integer) returns integer
  language internal;

-- convert encoding id to encoding name
create function pg_catalog.pg_encoding_to_char(integer) returns name
  language internal;

-- list DDL actions being executed by the current command
create function pg_catalog.pg_event_trigger_ddl_commands(OUT classid oid, OUT objid oid, OUT objsubid integer, OUT command_tag text, OUT object_type text, OUT schema_name text, OUT object_identity text, OUT in_extension boolean, OUT command pg_ddl_command) returns SETOF record
  language internal;

-- list objects dropped by the current command
create function pg_catalog.pg_event_trigger_dropped_objects(OUT classid oid, OUT objid oid, OUT objsubid integer, OUT original boolean, OUT normal boolean, OUT is_temporary boolean, OUT object_type text, OUT schema_name text, OUT object_name text, OUT object_identity text, OUT address_names text[], OUT address_args text[]) returns SETOF record
  language internal;

-- return Oid of the table getting rewritten
create function pg_catalog.pg_event_trigger_table_rewrite_oid(OUT oid oid) returns oid
  language internal;

-- return reason code for table getting rewritten
create function pg_catalog.pg_event_trigger_table_rewrite_reason() returns integer
  language internal;

-- export a snapshot
create function pg_catalog.pg_export_snapshot() returns text
  language internal;

-- flag an extension's table contents to be emitted by pg_dump
create function pg_catalog.pg_extension_config_dump(regclass, text) returns void
  language internal;

-- list an extension's version update paths
create function pg_catalog.pg_extension_update_paths(name name, OUT source text, OUT target text, OUT path text) returns SETOF record
  language internal;

-- relation OID for filenode and tablespace
create function pg_catalog.pg_filenode_relation(oid, oid) returns regclass
  language internal;

-- is function visible in search path?
create function pg_catalog.pg_function_is_visible(oid) returns boolean
  language internal;

-- get ACL for SQL object
create function pg_catalog.pg_get_acl(classid oid, objid oid, objsubid integer) returns aclitem[]
  language internal;

-- information about in-progress asynchronous IOs
create function pg_catalog.pg_get_aios(OUT pid integer, OUT io_id integer, OUT io_generation bigint, OUT state text, OUT operation text, OUT off bigint, OUT length bigint, OUT target text, OUT handle_data_len smallint, OUT raw_result integer, OUT result text, OUT target_desc text, OUT f_sync boolean, OUT f_localmem boolean, OUT f_buffered boolean) returns SETOF record
  language internal;

-- information about all memory contexts of local backend
create function pg_catalog.pg_get_backend_memory_contexts(OUT name text, OUT ident text, OUT type text, OUT level integer, OUT path integer[], OUT total_bytes bigint, OUT total_nblocks bigint, OUT free_bytes bigint, OUT free_chunks bigint, OUT used_bytes bigint) returns SETOF record
  language internal;

-- list of catalog foreign key relationships
create function pg_catalog.pg_get_catalog_foreign_keys(OUT fktable regclass, OUT fkcols text[], OUT pktable regclass, OUT pkcols text[], OUT is_array boolean, OUT is_opt boolean) returns SETOF record
  language internal;

-- constraint description
create function pg_catalog.pg_get_constraintdef(oid) returns text
  language internal;

-- constraint description with pretty-print option
create function pg_catalog.pg_get_constraintdef(oid, boolean) returns text
  language internal;

-- deparse an encoded expression
create function pg_catalog.pg_get_expr(pg_node_tree, oid) returns text
  language internal;

-- deparse an encoded expression with pretty-print option
create function pg_catalog.pg_get_expr(pg_node_tree, oid, boolean) returns text
  language internal;

-- function argument default
create function pg_catalog.pg_get_function_arg_default(oid, integer) returns text
  language internal;

-- argument list of a function
create function pg_catalog.pg_get_function_arguments(oid) returns text
  language internal;

-- identity argument list of a function
create function pg_catalog.pg_get_function_identity_arguments(oid) returns text
  language internal;

-- result type of a function
create function pg_catalog.pg_get_function_result(oid) returns text
  language internal;

-- function SQL body
create function pg_catalog.pg_get_function_sqlbody(oid) returns text
  language internal;

-- definition of a function
create function pg_catalog.pg_get_functiondef(oid) returns text
  language internal;

-- index description
create function pg_catalog.pg_get_indexdef(oid) returns text
  language internal;

-- index description (full create statement or single expression) with pretty-print option
create function pg_catalog.pg_get_indexdef(oid, integer, boolean) returns text
  language internal;

-- list of SQL keywords
create function pg_catalog.pg_get_keywords(OUT word text, OUT catcode "char", OUT barelabel boolean, OUT catdesc text, OUT baredesc text) returns SETOF record
  language internal;

-- get info about loaded modules
create function pg_catalog.pg_get_loaded_modules(OUT module_name text, OUT version text, OUT file_name text) returns SETOF record
  language internal;

-- view members of a multixactid
create function pg_catalog.pg_get_multixact_members(multixid xid, OUT xid xid, OUT mode text) returns SETOF record
  language internal;

-- get OID-based object address from name/args arrays
create function pg_catalog.pg_get_object_address(type text, object_names text[], object_args text[], OUT classid oid, OUT objid oid, OUT objsubid integer) returns record
  language internal;

-- partition constraint description
create function pg_catalog.pg_get_partition_constraintdef(oid) returns text
  language internal;

-- partition key description
create function pg_catalog.pg_get_partkeydef(oid) returns text
  language internal;

-- get information of the tables that are part of the specified publications
create function pg_catalog.pg_get_publication_tables(VARIADIC pubname text[], OUT pubid oid, OUT relid oid, OUT attrs int2vector, OUT qual pg_node_tree) returns SETOF record
  language internal;

-- oid of replica identity index if any
create function pg_catalog.pg_get_replica_identity_index(regclass) returns regclass
  language internal;

-- information about replication slots currently in use
create function pg_catalog.pg_get_replication_slots(OUT slot_name name, OUT plugin name, OUT slot_type text, OUT datoid oid, OUT temporary boolean, OUT active boolean, OUT active_pid integer, OUT xmin xid, OUT catalog_xmin xid, OUT restart_lsn pg_lsn, OUT confirmed_flush_lsn pg_lsn, OUT wal_status text, OUT safe_wal_size bigint, OUT two_phase boolean, OUT two_phase_at pg_lsn, OUT inactive_since timestamp with time zone, OUT conflicting boolean, OUT invalidation_reason text, OUT failover boolean, OUT synced boolean) returns SETOF record
  language internal;

-- source text of a rule
create function pg_catalog.pg_get_ruledef(oid) returns text
  language internal;

-- source text of a rule with pretty-print option
create function pg_catalog.pg_get_ruledef(oid, boolean) returns text
  language internal;

-- return sequence tuple, for use by pg_dump
create function pg_catalog.pg_get_sequence_data(sequence_oid regclass, OUT last_value bigint, OUT is_called boolean) returns record
  language internal;

-- name of sequence for a serial column
create function pg_catalog.pg_get_serial_sequence(text, text) returns text
  language internal;

-- allocations from the main shared memory segment
create function pg_catalog.pg_get_shmem_allocations(OUT name text, OUT off bigint, OUT size bigint, OUT allocated_size bigint) returns SETOF record
  language internal;

-- NUMA mappings for the main shared memory segment
create function pg_catalog.pg_get_shmem_allocations_numa(OUT name text, OUT numa_node integer, OUT size bigint) returns SETOF record
  language internal;

-- extended statistics object description
create function pg_catalog.pg_get_statisticsobjdef(oid) returns text
  language internal;

-- extended statistics columns
create function pg_catalog.pg_get_statisticsobjdef_columns(oid) returns text
  language internal;

-- extended statistics expressions
create function pg_catalog.pg_get_statisticsobjdef_expressions(oid) returns text[]
  language internal;

-- trigger description
create function pg_catalog.pg_get_triggerdef(oid) returns text
  language internal;

-- trigger description with pretty-print option
create function pg_catalog.pg_get_triggerdef(oid, boolean) returns text
  language internal;

-- role name by OID (with fallback)
create function pg_catalog.pg_get_userbyid(oid) returns name
  language internal;

-- select statement of a view
create function pg_catalog.pg_get_viewdef(oid) returns text
  language internal;

-- select statement of a view with pretty-print option
create function pg_catalog.pg_get_viewdef(oid, boolean) returns text
  language internal;

-- select statement of a view with pretty-printing and specified line wrapping
create function pg_catalog.pg_get_viewdef(oid, integer) returns text
  language internal;

-- select statement of a view
create function pg_catalog.pg_get_viewdef(text) returns text
  language internal;

-- select statement of a view with pretty-print option
create function pg_catalog.pg_get_viewdef(text, boolean) returns text
  language internal;

-- describe wait events
create function pg_catalog.pg_get_wait_events(OUT type text, OUT name text, OUT description text) returns SETOF record
  language internal;

-- get wal replay pause state
create function pg_catalog.pg_get_wal_replay_pause_state() returns text
  language internal;

-- get resource managers loaded in system
create function pg_catalog.pg_get_wal_resource_managers(OUT rm_id integer, OUT rm_name text, OUT rm_builtin boolean) returns SETOF record
  language internal;

-- WAL summarizer state
create function pg_catalog.pg_get_wal_summarizer_state(OUT summarized_tli bigint, OUT summarized_lsn pg_lsn, OUT pending_lsn pg_lsn, OUT summarizer_pid integer) returns record
  language internal;

-- user privilege on role by username, role name
create function pg_catalog.pg_has_role(name, name, text) returns boolean
  language internal;

-- user privilege on role by username, role oid
create function pg_catalog.pg_has_role(name, oid, text) returns boolean
  language internal;

-- current user privilege on role by role name
create function pg_catalog.pg_has_role(name, text) returns boolean
  language internal;

-- user privilege on role by user oid, role name
create function pg_catalog.pg_has_role(oid, name, text) returns boolean
  language internal;

-- user privilege on role by user oid, role oid
create function pg_catalog.pg_has_role(oid, oid, text) returns boolean
  language internal;

-- current user privilege on role by role oid
create function pg_catalog.pg_has_role(oid, text) returns boolean
  language internal;

-- show pg_hba.conf rules
create function pg_catalog.pg_hba_file_rules(OUT rule_number integer, OUT file_name text, OUT line_number integer, OUT type text, OUT database text[], OUT user_name text[], OUT address text, OUT netmask text, OUT auth_method text, OUT options text[], OUT error text) returns SETOF record
  language internal;

-- show pg_ident.conf mappings
create function pg_catalog.pg_ident_file_mappings(OUT map_number integer, OUT file_name text, OUT line_number integer, OUT map_name text, OUT sys_name text, OUT pg_username text, OUT error text) returns SETOF record
  language internal;

-- get machine-parseable identification of SQL object
create function pg_catalog.pg_identify_object(classid oid, objid oid, objsubid integer, OUT type text, OUT schema text, OUT name text, OUT identity text) returns record
  language internal;

-- get identification of SQL object for pg_get_object_address()
create function pg_catalog.pg_identify_object_as_address(classid oid, objid oid, objsubid integer, OUT type text, OUT object_names text[], OUT object_args text[]) returns record
  language internal;

-- import collations from operating system
create function pg_catalog.pg_import_system_collations(regnamespace) returns integer
  language internal;

-- test property of an index column
create function pg_catalog.pg_index_column_has_property(regclass, integer, text) returns boolean
  language internal;

-- test property of an index
create function pg_catalog.pg_index_has_property(regclass, text) returns boolean
  language internal;

-- test property of an index access method
create function pg_catalog.pg_indexam_has_property(oid, text) returns boolean
  language internal;

-- return name of given index build phase
create function pg_catalog.pg_indexam_progress_phasename(oid, bigint) returns text
  language internal;

-- disk space usage for all indexes attached to the specified table
create function pg_catalog.pg_indexes_size(regclass) returns bigint
  language internal;

-- get error details if string is not valid input for data type
create function pg_catalog.pg_input_error_info(value text, type_name text, OUT message text, OUT detail text, OUT hint text, OUT sql_error_code text) returns record
  language internal;

-- test whether string is valid input for data type
create function pg_catalog.pg_input_is_valid(text, text) returns boolean
  language internal;

-- true if server is in recovery
create function pg_catalog.pg_is_in_recovery() returns boolean
  language internal;

-- is schema another session's temp schema?
create function pg_catalog.pg_is_other_temp_schema(oid) returns boolean
  language internal;

-- true if wal replay is paused
create function pg_catalog.pg_is_wal_replay_paused() returns boolean
  language internal;

-- isolationtester support function
